From 8daa83a594a2e98f39d764422bfbdbc62c9efd44 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 19:20:00 +0200 Subject: Adding upstream version 2:4.20.0+dfsg. Signed-off-by: Daniel Baumann --- source3/torture/bench_pthreadpool.c | 68 + source3/torture/cmd_vfs.c | 2362 ++++ source3/torture/denytest.c | 1600 +++ source3/torture/locktest2.c | 610 + source3/torture/mangle_test.c | 223 + source3/torture/msg_sink.c | 285 + source3/torture/msg_source.c | 159 + source3/torture/msgtest.c | 171 + source3/torture/nbench.c | 504 + source3/torture/nbio.c | 377 + source3/torture/pdbtest.c | 736 ++ source3/torture/proto.h | 192 + source3/torture/scanner.c | 515 + source3/torture/test_addrchange.c | 94 + source3/torture/test_async_echo.c | 148 + source3/torture/test_authinfo_structs.c | 218 + source3/torture/test_buffersize.c | 55 + source3/torture/test_case_insensitive.c | 80 + source3/torture/test_chain3.c | 296 + source3/torture/test_cleanup.c | 240 + source3/torture/test_ctdbd_conn.c | 312 + source3/torture/test_dbwrap_ctdb.c | 163 + source3/torture/test_dbwrap_do_locked.c | 161 + source3/torture/test_dbwrap_watch.c | 467 + source3/torture/test_g_lock.c | 1403 +++ source3/torture/test_hidenewfiles.c | 234 + source3/torture/test_idmap_cache.c | 122 + source3/torture/test_idmap_tdb_common.c | 1047 ++ source3/torture/test_matching.c | 276 + source3/torture/test_messaging_fd_passing.c | 397 + source3/torture/test_messaging_read.c | 706 ++ source3/torture/test_messaging_send_all.c | 279 + source3/torture/test_namemap_cache.c | 270 + source3/torture/test_notify.c | 731 ++ source3/torture/test_notify_online.c | 293 + source3/torture/test_nttrans_create.c | 108 + source3/torture/test_nttrans_fsctl.c | 288 + source3/torture/test_oplock_cancel.c | 168 + source3/torture/test_posix.c | 1972 +++ source3/torture/test_posix_append.c | 100 + source3/torture/test_pthreadpool_tevent.c | 82 + source3/torture/test_readdir_timestamp.c | 533 + source3/torture/test_rpc_scale.c | 301 + source3/torture/test_smb1_dfs.c | 4284 +++++++ source3/torture/test_smb2.c | 5471 +++++++++ source3/torture/test_smbsock_any_connect.c | 47 + source3/torture/test_tdb_validate.c | 68 + source3/torture/torture.c | 16512 ++++++++++++++++++++++++++ source3/torture/utable.c | 210 + source3/torture/vfstest.c | 650 + source3/torture/vfstest.h | 51 + source3/torture/vfstest_chain.c | 342 + source3/torture/wbc_async.c | 758 ++ source3/torture/wbc_async.h | 171 + source3/torture/wscript_build | 135 + 55 files changed, 48045 insertions(+) create mode 100644 source3/torture/bench_pthreadpool.c create mode 100644 source3/torture/cmd_vfs.c create mode 100644 source3/torture/denytest.c create mode 100644 source3/torture/locktest2.c create mode 100644 source3/torture/mangle_test.c create mode 100644 source3/torture/msg_sink.c create mode 100644 source3/torture/msg_source.c create mode 100644 source3/torture/msgtest.c create mode 100644 source3/torture/nbench.c create mode 100644 source3/torture/nbio.c create mode 100644 source3/torture/pdbtest.c create mode 100644 source3/torture/proto.h create mode 100644 source3/torture/scanner.c create mode 100644 source3/torture/test_addrchange.c create mode 100644 source3/torture/test_async_echo.c create mode 100644 source3/torture/test_authinfo_structs.c create mode 100644 source3/torture/test_buffersize.c create mode 100644 source3/torture/test_case_insensitive.c create mode 100644 source3/torture/test_chain3.c create mode 100644 source3/torture/test_cleanup.c create mode 100644 source3/torture/test_ctdbd_conn.c create mode 100644 source3/torture/test_dbwrap_ctdb.c create mode 100644 source3/torture/test_dbwrap_do_locked.c create mode 100644 source3/torture/test_dbwrap_watch.c create mode 100644 source3/torture/test_g_lock.c create mode 100644 source3/torture/test_hidenewfiles.c create mode 100644 source3/torture/test_idmap_cache.c create mode 100644 source3/torture/test_idmap_tdb_common.c create mode 100644 source3/torture/test_matching.c create mode 100644 source3/torture/test_messaging_fd_passing.c create mode 100644 source3/torture/test_messaging_read.c create mode 100644 source3/torture/test_messaging_send_all.c create mode 100644 source3/torture/test_namemap_cache.c create mode 100644 source3/torture/test_notify.c create mode 100644 source3/torture/test_notify_online.c create mode 100644 source3/torture/test_nttrans_create.c create mode 100644 source3/torture/test_nttrans_fsctl.c create mode 100644 source3/torture/test_oplock_cancel.c create mode 100644 source3/torture/test_posix.c create mode 100644 source3/torture/test_posix_append.c create mode 100644 source3/torture/test_pthreadpool_tevent.c create mode 100644 source3/torture/test_readdir_timestamp.c create mode 100644 source3/torture/test_rpc_scale.c create mode 100644 source3/torture/test_smb1_dfs.c create mode 100644 source3/torture/test_smb2.c create mode 100644 source3/torture/test_smbsock_any_connect.c create mode 100644 source3/torture/test_tdb_validate.c create mode 100644 source3/torture/torture.c create mode 100644 source3/torture/utable.c create mode 100644 source3/torture/vfstest.c create mode 100644 source3/torture/vfstest.h create mode 100644 source3/torture/vfstest_chain.c create mode 100644 source3/torture/wbc_async.c create mode 100644 source3/torture/wbc_async.h create mode 100644 source3/torture/wscript_build (limited to 'source3/torture') diff --git a/source3/torture/bench_pthreadpool.c b/source3/torture/bench_pthreadpool.c new file mode 100644 index 0000000..3d581e9 --- /dev/null +++ b/source3/torture/bench_pthreadpool.c @@ -0,0 +1,68 @@ +/* + * Unix SMB/CIFS implementation. + * Little pthreadpool benchmark + * + * Copyright (C) Volker Lendecke 2014 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "../lib/pthreadpool/pthreadpool_pipe.h" +#include "proto.h" + +extern int torture_numops; + +static void null_job(void *private_data) +{ + return; +} + +bool run_bench_pthreadpool(int dummy) +{ + struct pthreadpool_pipe *pool; + int i, ret; + + ret = pthreadpool_pipe_init(1, &pool); + if (ret != 0) { + d_fprintf(stderr, "pthreadpool_pipe_init failed: %s\n", + strerror(ret)); + return false; + } + + for (i=0; i. +*/ + +#include "includes.h" +#include "smbd/smbd.h" +#include "system/passwd.h" +#include "system/filesys.h" +#include "vfstest.h" +#include "../lib/util/util_pw.h" +#include "libcli/security/security.h" +#include "passdb/machine_sid.h" +#include "source3/smbd/dir.h" + +static const char *null_string = ""; + +static uint32_t ssf_flags(void) +{ + return lp_posix_pathnames() ? SMB_FILENAME_POSIX_PATH : 0; +} + +static NTSTATUS cmd_load_module(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int i; + + if (argc < 2) { + printf("Usage: load \n"); + return NT_STATUS_OK; + } + + for (i=argc-1;i>0;i--) { + if (!vfs_init_custom(vfs->conn, argv[i])) { + DEBUG(0, ("load: (vfs_init_custom failed for %s)\n", argv[i])); + return NT_STATUS_UNSUCCESSFUL; + } + } + printf("load: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + char c; + size_t size; + if (argc != 3) { + printf("Usage: populate \n"); + return NT_STATUS_OK; + } + c = argv[1][0]; + size = atoi(argv[2]); + vfs->data = talloc_array(mem_ctx, char, size); + if (vfs->data == NULL) { + printf("populate: error=-1 (not enough memory)"); + return NT_STATUS_UNSUCCESSFUL; + } + memset(vfs->data, c, size); + vfs->data_size = size; + return NT_STATUS_OK; +} + +static NTSTATUS cmd_show_data(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + size_t offset; + size_t len; + if (argc != 1 && argc != 3) { + printf("Usage: showdata [ ]\n"); + return NT_STATUS_OK; + } + if (vfs->data == NULL || vfs->data_size == 0) { + printf("show_data: error=-1 (buffer empty)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (argc == 3) { + offset = atoi(argv[1]); + len = atoi(argv[2]); + } else { + offset = 0; + len = vfs->data_size; + } + if ((offset + len) > vfs->data_size) { + printf("show_data: error=-1 (not enough data in buffer)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + dump_data(0, (uint8_t *)(vfs->data) + offset, len); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + const struct loadparm_substitution *lp_sub = + loadparm_s3_global_substitution(); + + SMB_VFS_CONNECT(vfs->conn, lp_servicename(talloc_tos(), lp_sub, SNUM(vfs->conn)), "vfstest"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_disconnect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + SMB_VFS_DISCONNECT(vfs->conn); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_filename *smb_fname = NULL; + uint64_t diskfree, bsize, dfree, dsize; + if (argc != 2) { + printf("Usage: disk_free \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname(talloc_tos(), + argv[1], + NULL, + NULL, + 0, + ssf_flags()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + diskfree = SMB_VFS_DISK_FREE(vfs->conn, smb_fname, + &bsize, &dfree, &dsize); + printf("disk_free: %lu, bsize = %lu, dfree = %lu, dsize = %lu\n", + (unsigned long)diskfree, + (unsigned long)bsize, + (unsigned long)dfree, + (unsigned long)dsize); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_opendir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_filename *smb_fname = NULL; + NTSTATUS status; + + if (argc != 2) { + printf("Usage: opendir \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname(talloc_tos(), + argv[1], + NULL, + NULL, + 0, + ssf_flags()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = OpenDir(vfs->conn, + vfs->conn, + smb_fname, + NULL, + 0, + &vfs->currentdir); + if (!NT_STATUS_IS_OK(status)) { + int err = map_errno_from_nt_status(status); + printf("opendir error=%d (%s)\n", err, strerror(err)); + TALLOC_FREE(smb_fname); + errno = err; + return NT_STATUS_UNSUCCESSFUL; + } + + TALLOC_FREE(smb_fname); + printf("opendir: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_Dir *currentdir = vfs->currentdir; + files_struct *dirfsp = dir_hnd_fetch_fsp(currentdir); + connection_struct *conn = dirfsp->conn; + SMB_STRUCT_STAT st; + const char *dname = NULL; + struct smb_filename *fname = NULL; + char *talloced = NULL; + int ret; + + if (vfs->currentdir == NULL) { + printf("readdir: error=-1 (no open directory)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + dname = ReadDirName(vfs->currentdir, &talloced); + if (dname == NULL) { + printf("readdir: NULL\n"); + return NT_STATUS_OK; + } + + fname = synthetic_smb_fname( + talloc_tos(), dname, NULL, 0, 0, ssf_flags()); + if (fname == NULL) { + printf("readdir: no memory\n"); + return NT_STATUS_OK; + } + + printf("readdir: %s\n", dname); + + ret = SMB_VFS_FSTATAT(conn, dirfsp, fname, &st, AT_SYMLINK_NOFOLLOW); + + if ((ret == 0) && VALID_STAT(st)) { + time_t tmp_time; + printf(" stat available"); + if (S_ISREG(st.st_ex_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_ex_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_ex_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_ex_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_ex_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_ex_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_ex_mode)) printf(" Socket\n"); + printf(" Size: %10u", (unsigned int)st.st_ex_size); +#ifdef HAVE_STAT_ST_BLOCKS + printf(" Blocks: %9u", (unsigned int)st.st_ex_blocks); +#endif +#ifdef HAVE_STAT_ST_BLKSIZE + printf(" IO Block: %u\n", (unsigned int)st.st_ex_blksize); +#endif + printf(" Device: 0x%10x", (unsigned int)st.st_ex_dev); + printf(" Inode: %10u", (unsigned int)st.st_ex_ino); + printf(" Links: %10u\n", (unsigned int)st.st_ex_nlink); + printf(" Access: %05o", (int)((st.st_ex_mode) & 007777)); + printf(" Uid: %5lu Gid: %5lu\n", + (unsigned long)st.st_ex_uid, + (unsigned long)st.st_ex_gid); + tmp_time = convert_timespec_to_time_t(st.st_ex_atime); + printf(" Access: %s", ctime(&tmp_time)); + tmp_time = convert_timespec_to_time_t(st.st_ex_mtime); + printf(" Modify: %s", ctime(&tmp_time)); + tmp_time = convert_timespec_to_time_t(st.st_ex_ctime); + printf(" Change: %s", ctime(&tmp_time)); + } + + TALLOC_FREE(talloced); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_mkdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_filename *smb_fname = NULL; + int ret; + + if (argc != 2) { + printf("Usage: mkdir \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname(talloc_tos(), + argv[1], + NULL, + NULL, + 0, + ssf_flags()); + + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + ret = SMB_VFS_MKDIRAT(vfs->conn, + vfs->conn->cwd_fsp, + smb_fname, + 00755); + if (ret == -1) { + printf("mkdir error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("mkdir: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + if (vfs->currentdir == NULL) { + printf("closedir: failure (no directory open)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + TALLOC_FREE(vfs->currentdir); + + printf("closedir: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct vfs_open_how how = { .mode = 0400, }; + const char *flagstr; + files_struct *fsp; + struct files_struct *fspcwd = NULL; + struct smb_filename *smb_fname = NULL; + NTSTATUS status; + int fd; + + if (argc < 3 || argc > 5) { + printf("Usage: open \n"); + printf(" flags: O = O_RDONLY\n"); + printf(" R = O_RDWR\n"); + printf(" W = O_WRONLY\n"); + printf(" C = O_CREAT\n"); + printf(" E = O_EXCL\n"); + printf(" T = O_TRUNC\n"); + printf(" A = O_APPEND\n"); + printf(" N = O_NONBLOCK/O_NDELAY\n"); +#ifdef O_SYNC + printf(" S = O_SYNC\n"); +#endif +#ifdef O_NOFOLLOW + printf(" F = O_NOFOLLOW\n"); +#endif + printf(" mode: see open.2\n"); + printf(" mode is ignored if C flag not present\n"); + printf(" mode defaults to 00400\n"); + return NT_STATUS_OK; + } + flagstr = argv[2]; + while (*flagstr) { + switch (*flagstr) { + case 'O': + how.flags |= O_RDONLY; + break; + case 'R': + how.flags |= O_RDWR; + break; + case 'W': + how.flags |= O_WRONLY; + break; + case 'C': + how.flags |= O_CREAT; + break; + case 'E': + how.flags |= O_EXCL; + break; + case 'T': + how.flags |= O_TRUNC; + break; + case 'A': + how.flags |= O_APPEND; + break; + case 'N': + how.flags |= O_NONBLOCK; + break; +#ifdef O_SYNC + case 'S': + how.flags |= O_SYNC; + break; +#endif +#ifdef O_NOFOLLOW + case 'F': + how.flags |= O_NOFOLLOW; + break; +#endif + default: + printf("open: error=-1 (invalid flag!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + flagstr++; + } + if ((how.flags & O_CREAT) && argc == 4) { + short _mode = 0; + + if (sscanf(argv[3], "%ho", &_mode) == 0) { + printf("open: error=-1 (invalid mode!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + how.mode = _mode; + } + + fsp = talloc_zero(vfs, struct files_struct); + if (fsp == NULL) { + goto nomem; + } + fsp->fh = fd_handle_create(fsp); + if (fsp->fh == NULL) { + goto nomem; + } + fsp->conn = vfs->conn; + + smb_fname = synthetic_smb_fname_split(NULL, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + goto nomem; + } + + fsp->fsp_name = smb_fname; + + status = vfs_at_fspcwd(fsp, vfs->conn, &fspcwd); + if (!NT_STATUS_IS_OK(status)) { + goto fail; + } + + if (is_named_stream(smb_fname)) { + struct smb_filename *base_name = NULL; + + base_name = cp_smb_filename_nostream(NULL, smb_fname); + if (base_name == NULL) { + goto nomem; + } + + status = openat_pathref_fsp(fspcwd, base_name); + if (!NT_STATUS_IS_OK(status)) { + goto fail; + } + + TALLOC_FREE(fspcwd); + + fsp->base_fsp = base_name->fsp; + } + + fd = SMB_VFS_OPENAT(vfs->conn, + fspcwd, + smb_fname, + fsp, + &how); + if (fd == -1) { + printf("open: error=%d (%s)\n", errno, strerror(errno)); + status = map_nt_error_from_unix(errno); + goto fail; + } + fsp_set_fd(fsp, fd); + + status = vfs_stat_fsp(fsp); + if (!NT_STATUS_IS_OK(status)) { + /* If we have an fd, this stat should succeed. */ + DEBUG(0,("Error doing fstat on open file %s " + "(%s)\n", + smb_fname_str_dbg(smb_fname), + nt_errstr(status) )); + } else if (S_ISDIR(smb_fname->st.st_ex_mode)) { + errno = EISDIR; + status = NT_STATUS_FILE_IS_A_DIRECTORY; + } + + if (!NT_STATUS_IS_OK(status)) { + fd_close(fsp); + goto fail; + } + + fsp->file_id = vfs_file_id_from_sbuf(vfs->conn, &smb_fname->st); + fsp->vuid = UID_FIELD_INVALID; + fsp->file_pid = 0; + fsp->fsp_flags.can_lock = true; + fsp->fsp_flags.can_read = true; + fsp->fsp_flags.can_write = CAN_WRITE(vfs->conn); + fsp->print_file = NULL; + fsp->fsp_flags.modified = false; + fsp->sent_oplock_break = NO_BREAK_SENT; + fsp->fsp_flags.is_directory = false; + + vfs->files[fsp_get_pathref_fd(fsp)] = fsp; + printf("open: fd=%d\n", fsp_get_pathref_fd(fsp)); + return NT_STATUS_OK; + +nomem: + status = NT_STATUS_NO_MEMORY; +fail: + TALLOC_FREE(smb_fname); + TALLOC_FREE(fsp); + return status; +} + + +static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_filename *smb_fname = NULL; + int ret = -1; + + if (argc != 2) { + printf("Usage: %s \n", argv[0]); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname(talloc_tos(), + argv[1], + NULL, + NULL, + 0, + ssf_flags()); + + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + if (strcmp("rmdir", argv[0]) == 0 ) { + ret = SMB_VFS_UNLINKAT(vfs->conn, + vfs->conn->cwd_fsp, + smb_fname, + AT_REMOVEDIR); + TALLOC_FREE(smb_fname); + } else if (strcmp("unlink", argv[0]) == 0 ) { + TALLOC_FREE(smb_fname); + /* unlink can be a stream:name */ + smb_fname = synthetic_smb_fname_split(talloc_tos(), + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + ret = SMB_VFS_UNLINKAT(vfs->conn, + vfs->conn->cwd_fsp, + smb_fname, + 0); + TALLOC_FREE(smb_fname); + } else if (strcmp("chdir", argv[0]) == 0 ) { + ret = SMB_VFS_CHDIR(vfs->conn, smb_fname); + TALLOC_FREE(smb_fname); + } else { + printf("%s: error=%d (invalid function name!)\n", argv[0], errno); + return NT_STATUS_UNSUCCESSFUL; + } + + if (ret == -1) { + printf("%s: error=%d (%s)\n", argv[0], errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("%s: ok\n", argv[0]); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int fd; + NTSTATUS status; + + if (argc != 2) { + printf("Usage: close \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (vfs->files[fd] == NULL) { + printf("close: error=-1 (invalid file descriptor)\n"); + return NT_STATUS_OK; + } + + status = fd_close(vfs->files[fd]); + if (!NT_STATUS_IS_OK(status)) + printf("close: error=%s\n", nt_errstr(status)); + else + printf("close: ok\n"); + + TALLOC_FREE(vfs->files[fd]); + vfs->files[fd] = NULL; + return status; +} + + +static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int fd; + size_t size; + ssize_t rsize; + + if (argc != 3) { + printf("Usage: read \n"); + return NT_STATUS_OK; + } + + /* do some error checking on these */ + fd = atoi(argv[1]); + size = atoi(argv[2]); + vfs->data = talloc_array(mem_ctx, char, size); + if (vfs->data == NULL) { + printf("read: error=-1 (not enough memory)"); + return NT_STATUS_UNSUCCESSFUL; + } + vfs->data_size = size; + + rsize = read_file(vfs->files[fd], vfs->data, 0, size); + if (rsize == -1) { + printf("read: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("read: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int fd, wsize; + size_t size; + + if (argc != 3) { + printf("Usage: write \n"); + return NT_STATUS_OK; + } + + /* some error checking should go here */ + fd = atoi(argv[1]); + size = atoi(argv[2]); + if (vfs->data == NULL) { + printf("write: error=-1 (buffer empty, please populate it before writing)"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (vfs->data_size < size) { + printf("write: error=-1 (buffer too small, please put some more data in)"); + return NT_STATUS_UNSUCCESSFUL; + } + + wsize = write_file(NULL, vfs->files[fd], vfs->data, 0, size); + + if (wsize == -1) { + printf("write: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("write: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int fd, offset, whence; + off_t pos; + + if (argc != 4) { + printf("Usage: lseek \n...where whence is 1 => SEEK_SET, 2 => SEEK_CUR, 3 => SEEK_END\n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + offset = atoi(argv[2]); + whence = atoi(argv[3]); + switch (whence) { + case 1: whence = SEEK_SET; break; + case 2: whence = SEEK_CUR; break; + default: whence = SEEK_END; + } + + pos = SMB_VFS_LSEEK(vfs->files[fd], offset, whence); + if (pos == (off_t)-1) { + printf("lseek: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("lseek: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int ret; + struct smb_filename *smb_fname_src = NULL; + struct smb_filename *smb_fname_dst = NULL; + + if (argc != 3) { + printf("Usage: rename \n"); + return NT_STATUS_OK; + } + + smb_fname_src = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname_src == NULL) { + return NT_STATUS_NO_MEMORY; + } + + smb_fname_dst = synthetic_smb_fname_split(mem_ctx, + argv[2], + lp_posix_pathnames()); + if (smb_fname_dst == NULL) { + TALLOC_FREE(smb_fname_src); + return NT_STATUS_NO_MEMORY; + } + + ret = SMB_VFS_RENAMEAT(vfs->conn, + vfs->conn->cwd_fsp, + smb_fname_src, + vfs->conn->cwd_fsp, + smb_fname_dst); + + TALLOC_FREE(smb_fname_src); + TALLOC_FREE(smb_fname_dst); + if (ret == -1) { + printf("rename: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("rename: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int ret, fd; + if (argc != 2) { + printf("Usage: fsync \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + ret = smb_vfs_fsync_sync(vfs->files[fd]); + if (ret == -1) { + printf("fsync: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("fsync: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int ret; + const char *user; + const char *group; + struct passwd *pwd = NULL; + struct group *grp = NULL; + struct smb_filename *smb_fname = NULL; + SMB_STRUCT_STAT st; + time_t tmp_time; + + if (argc != 2) { + printf("Usage: stat \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + ret = SMB_VFS_STAT(vfs->conn, smb_fname); + if (ret == -1) { + printf("stat: error=%d (%s)\n", errno, strerror(errno)); + TALLOC_FREE(smb_fname); + return NT_STATUS_UNSUCCESSFUL; + } + st = smb_fname->st; + TALLOC_FREE(smb_fname); + + pwd = getpwuid(st.st_ex_uid); + if (pwd != NULL) user = pwd->pw_name; + else user = null_string; + grp = getgrgid(st.st_ex_gid); + if (grp != NULL) group = grp->gr_name; + else group = null_string; + + printf("stat: ok\n"); + printf(" File: %s", argv[1]); + if (S_ISREG(st.st_ex_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_ex_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_ex_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_ex_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_ex_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_ex_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_ex_mode)) printf(" Socket\n"); + printf(" Size: %10u", (unsigned int)st.st_ex_size); +#ifdef HAVE_STAT_ST_BLOCKS + printf(" Blocks: %9u", (unsigned int)st.st_ex_blocks); +#endif +#ifdef HAVE_STAT_ST_BLKSIZE + printf(" IO Block: %u\n", (unsigned int)st.st_ex_blksize); +#endif + printf(" Device: 0x%10x", (unsigned int)st.st_ex_dev); + printf(" Inode: %10u", (unsigned int)st.st_ex_ino); + printf(" Links: %10u\n", (unsigned int)st.st_ex_nlink); + printf(" Access: %05o", (int)((st.st_ex_mode) & 007777)); + printf(" Uid: %5lu/%.16s Gid: %5lu/%.16s\n", (unsigned long)st.st_ex_uid, user, + (unsigned long)st.st_ex_gid, group); + tmp_time = convert_timespec_to_time_t(st.st_ex_atime); + printf(" Access: %s", ctime(&tmp_time)); + tmp_time = convert_timespec_to_time_t(st.st_ex_mtime); + printf(" Modify: %s", ctime(&tmp_time)); + tmp_time = convert_timespec_to_time_t(st.st_ex_ctime); + printf(" Change: %s", ctime(&tmp_time)); + + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int fd; + const char *user; + const char *group; + struct passwd *pwd = NULL; + struct group *grp = NULL; + SMB_STRUCT_STAT st; + time_t tmp_time; + + if (argc != 2) { + printf("Usage: fstat \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (fd < 0 || fd >= 1024) { + printf("fstat: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + + if (vfs->files[fd] == NULL) { + printf("fstat: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + if (SMB_VFS_FSTAT(vfs->files[fd], &st) == -1) { + printf("fstat: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + pwd = getpwuid(st.st_ex_uid); + if (pwd != NULL) user = pwd->pw_name; + else user = null_string; + grp = getgrgid(st.st_ex_gid); + if (grp != NULL) group = grp->gr_name; + else group = null_string; + + printf("fstat: ok\n"); + if (S_ISREG(st.st_ex_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_ex_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_ex_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_ex_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_ex_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_ex_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_ex_mode)) printf(" Socket\n"); + printf(" Size: %10u", (unsigned int)st.st_ex_size); +#ifdef HAVE_STAT_ST_BLOCKS + printf(" Blocks: %9u", (unsigned int)st.st_ex_blocks); +#endif +#ifdef HAVE_STAT_ST_BLKSIZE + printf(" IO Block: %u\n", (unsigned int)st.st_ex_blksize); +#endif + printf(" Device: 0x%10x", (unsigned int)st.st_ex_dev); + printf(" Inode: %10u", (unsigned int)st.st_ex_ino); + printf(" Links: %10u\n", (unsigned int)st.st_ex_nlink); + printf(" Access: %05o", (int)((st.st_ex_mode) & 007777)); + printf(" Uid: %5lu/%.16s Gid: %5lu/%.16s\n", (unsigned long)st.st_ex_uid, user, + (unsigned long)st.st_ex_gid, group); + tmp_time = convert_timespec_to_time_t(st.st_ex_atime); + printf(" Access: %s", ctime(&tmp_time)); + tmp_time = convert_timespec_to_time_t(st.st_ex_mtime); + printf(" Modify: %s", ctime(&tmp_time)); + tmp_time = convert_timespec_to_time_t(st.st_ex_ctime); + printf(" Change: %s", ctime(&tmp_time)); + + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + const char *user; + const char *group; + struct passwd *pwd = NULL; + struct group *grp = NULL; + struct smb_filename *smb_fname = NULL; + SMB_STRUCT_STAT st; + time_t tmp_time; + + if (argc != 2) { + printf("Usage: lstat \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + if (SMB_VFS_LSTAT(vfs->conn, smb_fname) == -1) { + printf("lstat: error=%d (%s)\n", errno, strerror(errno)); + TALLOC_FREE(smb_fname); + return NT_STATUS_UNSUCCESSFUL; + } + st = smb_fname->st; + TALLOC_FREE(smb_fname); + + pwd = getpwuid(st.st_ex_uid); + if (pwd != NULL) user = pwd->pw_name; + else user = null_string; + grp = getgrgid(st.st_ex_gid); + if (grp != NULL) group = grp->gr_name; + else group = null_string; + + printf("lstat: ok\n"); + if (S_ISREG(st.st_ex_mode)) printf(" Regular File\n"); + else if (S_ISDIR(st.st_ex_mode)) printf(" Directory\n"); + else if (S_ISCHR(st.st_ex_mode)) printf(" Character Device\n"); + else if (S_ISBLK(st.st_ex_mode)) printf(" Block Device\n"); + else if (S_ISFIFO(st.st_ex_mode)) printf(" Fifo\n"); + else if (S_ISLNK(st.st_ex_mode)) printf(" Symbolic Link\n"); + else if (S_ISSOCK(st.st_ex_mode)) printf(" Socket\n"); + printf(" Size: %10u", (unsigned int)st.st_ex_size); +#ifdef HAVE_STAT_ST_BLOCKS + printf(" Blocks: %9u", (unsigned int)st.st_ex_blocks); +#endif +#ifdef HAVE_STAT_ST_BLKSIZE + printf(" IO Block: %u\n", (unsigned int)st.st_ex_blksize); +#endif + printf(" Device: 0x%10x", (unsigned int)st.st_ex_dev); + printf(" Inode: %10u", (unsigned int)st.st_ex_ino); + printf(" Links: %10u\n", (unsigned int)st.st_ex_nlink); + printf(" Access: %05o", (int)((st.st_ex_mode) & 007777)); + printf(" Uid: %5lu/%.16s Gid: %5lu/%.16s\n", (unsigned long)st.st_ex_uid, user, + (unsigned long)st.st_ex_gid, group); + tmp_time = convert_timespec_to_time_t(st.st_ex_atime); + printf(" Access: %s", ctime(&tmp_time)); + tmp_time = convert_timespec_to_time_t(st.st_ex_mtime); + printf(" Modify: %s", ctime(&tmp_time)); + tmp_time = convert_timespec_to_time_t(st.st_ex_ctime); + printf(" Change: %s", ctime(&tmp_time)); + + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_filename *smb_fname = NULL; + mode_t mode; + struct smb_filename *pathref_fname = NULL; + NTSTATUS status; + if (argc != 3) { + printf("Usage: chmod \n"); + return NT_STATUS_OK; + } + + mode = atoi(argv[2]); + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = synthetic_pathref(mem_ctx, + vfs->conn->cwd_fsp, + smb_fname->base_name, + NULL, + NULL, + smb_fname->twrp, + smb_fname->flags, + &pathref_fname); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + if (SMB_VFS_FCHMOD(pathref_fname->fsp, mode) == -1) { + printf("chmod: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("chmod: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int fd; + mode_t mode; + if (argc != 3) { + printf("Usage: fchmod \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + mode = atoi(argv[2]); + if (fd < 0 || fd >= 1024) { + printf("fchmod: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("fchmod: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + if (SMB_VFS_FCHMOD(vfs->files[fd], mode) == -1) { + printf("fchmod: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("fchmod: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + uid_t uid; + gid_t gid; + int fd; + if (argc != 4) { + printf("Usage: fchown \n"); + return NT_STATUS_OK; + } + + uid = atoi(argv[2]); + gid = atoi(argv[3]); + fd = atoi(argv[1]); + if (fd < 0 || fd >= 1024) { + printf("fchown: failure=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("fchown: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + if (SMB_VFS_FCHOWN(vfs->files[fd], uid, gid) == -1) { + printf("fchown error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("fchown: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_filename *smb_fname = SMB_VFS_GETWD(vfs->conn, talloc_tos()); + if (smb_fname == NULL) { + printf("getwd: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("getwd: %s\n", smb_fname->base_name); + TALLOC_FREE(smb_fname); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_file_time ft; + struct files_struct *dirfsp = NULL; + struct smb_filename *smb_fname = NULL; + NTSTATUS status; + + if (argc != 4) { + printf("Usage: utime \n"); + return NT_STATUS_OK; + } + + init_smb_file_time(&ft); + + ft.atime = time_t_to_full_timespec(atoi(argv[2])); + ft.mtime = time_t_to_full_timespec(atoi(argv[3])); + + status = filename_convert_dirfsp(mem_ctx, + vfs->conn, + argv[1], + 0, /* ucf_flags */ + 0, /* twrp */ + &dirfsp, + &smb_fname); + if (!NT_STATUS_IS_OK(status)) { + printf("utime: %s\n", nt_errstr(status)); + return status; + } + + if (SMB_VFS_FNTIMES(smb_fname->fsp, &ft) != 0) { + printf("utime: error=%d (%s)\n", errno, strerror(errno)); + TALLOC_FREE(smb_fname); + return NT_STATUS_UNSUCCESSFUL; + } + + TALLOC_FREE(smb_fname); + printf("utime: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int fd; + off_t off; + if (argc != 3) { + printf("Usage: ftruncate \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + off = atoi(argv[2]); + if (fd < 0 || fd >= 1024) { + printf("ftruncate: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("ftruncate: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + if (SMB_VFS_FTRUNCATE(vfs->files[fd], off) == -1) { + printf("ftruncate: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("ftruncate: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_lock(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int fd; + int op; + long offset; + long count; + int type; + const char *typestr; + + if (argc != 6) { + printf("Usage: lock \n"); + printf(" ops: G = F_GETLK\n"); + printf(" S = F_SETLK\n"); + printf(" W = F_SETLKW\n"); + printf(" type: R = F_RDLCK\n"); + printf(" W = F_WRLCK\n"); + printf(" U = F_UNLCK\n"); + return NT_STATUS_OK; + } + + if (sscanf(argv[1], "%d", &fd) == 0) { + printf("lock: error=-1 (error parsing fd)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + op = 0; + switch (*argv[2]) { + case 'G': + op = F_GETLK; + break; + case 'S': + op = F_SETLK; + break; + case 'W': + op = F_SETLKW; + break; + default: + printf("lock: error=-1 (invalid op flag!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (sscanf(argv[3], "%ld", &offset) == 0) { + printf("lock: error=-1 (error parsing fd)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + if (sscanf(argv[4], "%ld", &count) == 0) { + printf("lock: error=-1 (error parsing fd)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + type = 0; + typestr = argv[5]; + while(*typestr) { + switch (*typestr) { + case 'R': + type |= F_RDLCK; + break; + case 'W': + type |= F_WRLCK; + break; + case 'U': + type |= F_UNLCK; + break; + default: + printf("lock: error=-1 (invalid type flag!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + typestr++; + } + + printf("lock: debug lock(fd=%d, op=%d, offset=%ld, count=%ld, type=%d))\n", fd, op, offset, count, type); + + if (SMB_VFS_LOCK(vfs->files[fd], op, offset, count, type) == False) { + printf("lock: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("lock: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_symlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + int ret; + char *target = NULL; + struct smb_filename target_fname; + struct smb_filename *new_smb_fname = NULL; + NTSTATUS status; + + if (argc != 3) { + printf("Usage: symlink \n"); + return NT_STATUS_OK; + } + + new_smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[2], + lp_posix_pathnames()); + if (new_smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + target = talloc_strdup(mem_ctx, argv[1]); + if (target == NULL) { + return NT_STATUS_NO_MEMORY; + } + + target_fname = (struct smb_filename) { + .base_name = target, + }; + + /* Removes @GMT tokens if any */ + status = canonicalize_snapshot_path(&target_fname, UCF_GMT_PATHNAME, 0); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + ret = SMB_VFS_SYMLINKAT(vfs->conn, + &target_fname, + vfs->conn->cwd_fsp, + new_smb_fname); + if (ret == -1) { + printf("symlink: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("symlink: ok\n"); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_readlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + char buffer[PATH_MAX]; + struct smb_filename *smb_fname = NULL; + int size; + + if (argc != 2) { + printf("Usage: readlink \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + size = SMB_VFS_READLINKAT(vfs->conn, + vfs->conn->cwd_fsp, + smb_fname, + buffer, + PATH_MAX); + + if (size == -1) { + printf("readlink: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + buffer[size] = '\0'; + printf("readlink: %s\n", buffer); + return NT_STATUS_OK; +} + + +static NTSTATUS cmd_link(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_filename *old_smb_fname = NULL; + struct smb_filename *new_smb_fname = NULL; + int ret; + + if (argc != 3) { + printf("Usage: link \n"); + return NT_STATUS_OK; + } + + old_smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (old_smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + new_smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[2], + lp_posix_pathnames()); + if (new_smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + ret = SMB_VFS_LINKAT(vfs->conn, + vfs->conn->cwd_fsp, + old_smb_fname, + vfs->conn->cwd_fsp, + new_smb_fname, + 0); + if (ret == -1) { + printf("link: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("link: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_mknod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + short _mode = 0; + mode_t mode; + unsigned int dev_val; + SMB_DEV_T dev; + struct smb_filename *smb_fname = NULL; + int ret; + + if (argc != 4) { + printf("Usage: mknod \n"); + printf(" mode is octal\n"); + printf(" dev is hex\n"); + return NT_STATUS_OK; + } + + if (sscanf(argv[2], "%ho", &_mode) == 0) { + printf("open: error=-1 (invalid mode!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + mode = _mode; + + if (sscanf(argv[3], "%x", &dev_val) == 0) { + printf("open: error=-1 (invalid dev!)\n"); + return NT_STATUS_UNSUCCESSFUL; + } + dev = (SMB_DEV_T)dev_val; + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + ret = SMB_VFS_MKNODAT(vfs->conn, + vfs->conn->cwd_fsp, + smb_fname, + mode, + dev); + + if (ret == -1) { + printf("mknod: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("mknod: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_realpath(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct smb_filename *smb_fname = NULL; + + if (argc != 2) { + printf("Usage: realpath \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + if (SMB_VFS_REALPATH(vfs->conn, mem_ctx, smb_fname) == NULL) { + printf("realpath: error=%d (%s)\n", errno, strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + + printf("realpath: ok\n"); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_getxattr(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + uint8_t *buf; + ssize_t ret; + struct smb_filename *smb_fname = NULL; + struct smb_filename *pathref_fname = NULL; + NTSTATUS status; + + if (argc != 3) { + printf("Usage: getxattr \n"); + return NT_STATUS_OK; + } + + buf = NULL; + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + status = synthetic_pathref(mem_ctx, + vfs->conn->cwd_fsp, + smb_fname->base_name, + NULL, + NULL, + smb_fname->twrp, + smb_fname->flags, + &pathref_fname); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + ret = SMB_VFS_FGETXATTR(pathref_fname->fsp, + argv[2], + buf, + talloc_get_size(buf)); + if (ret == -1) { + int err = errno; + printf("getxattr returned (%s)\n", strerror(err)); + return map_nt_error_from_unix(err); + } + buf = talloc_array(mem_ctx, uint8_t, ret); + if (buf == NULL) { + return NT_STATUS_NO_MEMORY; + } + ret = SMB_VFS_FGETXATTR(pathref_fname->fsp, + argv[2], + buf, + talloc_get_size(buf)); + if (ret == -1) { + int err = errno; + printf("getxattr returned (%s)\n", strerror(err)); + return map_nt_error_from_unix(err); + } + dump_data_file(buf, talloc_get_size(buf), false, stdout); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_listxattr(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + char *buf, *p; + ssize_t ret; + struct smb_filename *smb_fname = NULL; + struct smb_filename *pathref_fname = NULL; + NTSTATUS status; + if (argc != 2) { + printf("Usage: listxattr \n"); + return NT_STATUS_OK; + } + + buf = NULL; + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + status = synthetic_pathref(mem_ctx, + vfs->conn->cwd_fsp, + smb_fname->base_name, + NULL, + NULL, + smb_fname->twrp, + smb_fname->flags, + &pathref_fname); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + ret = SMB_VFS_FLISTXATTR(pathref_fname->fsp, + buf, talloc_get_size(buf)); + if (ret == -1) { + int err = errno; + printf("listxattr returned (%s)\n", strerror(err)); + return map_nt_error_from_unix(err); + } + buf = talloc_array(mem_ctx, char, ret); + if (buf == NULL) { + return NT_STATUS_NO_MEMORY; + } + ret = SMB_VFS_FLISTXATTR(pathref_fname->fsp, + buf, talloc_get_size(buf)); + if (ret == -1) { + int err = errno; + printf("listxattr returned (%s)\n", strerror(err)); + return map_nt_error_from_unix(err); + } + if (ret == 0) { + return NT_STATUS_OK; + } + if (buf[ret-1] != '\0') { + printf("listxattr returned non 0-terminated strings\n"); + return NT_STATUS_INTERNAL_ERROR; + } + + p = buf; + while (p < buf+ret) { + printf("%s\n", p); + p = strchr(p, 0); + p += 1; + } + return NT_STATUS_OK; +} + +static NTSTATUS cmd_fsetxattr(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + ssize_t ret; + int flags = 0; + struct smb_filename *smb_fname = NULL; + struct smb_filename *pathref_fname = NULL; + NTSTATUS status; + + if ((argc < 4) || (argc > 5)) { + printf("Usage: setxattr [flags]\n"); + return NT_STATUS_OK; + } + + if (argc == 5) { + flags = atoi(argv[4]); + } + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = synthetic_pathref(mem_ctx, + vfs->conn->cwd_fsp, + smb_fname->base_name, + NULL, + NULL, + smb_fname->twrp, + smb_fname->flags, + &pathref_fname); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + ret = SMB_VFS_FSETXATTR(pathref_fname->fsp, argv[2], + argv[3], strlen(argv[3]), flags); + if (ret == -1) { + int err = errno; + printf("fsetxattr returned (%s)\n", strerror(err)); + return map_nt_error_from_unix(err); + } + return NT_STATUS_OK; +} + +static NTSTATUS cmd_removexattr(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + ssize_t ret; + struct smb_filename *smb_fname = NULL; + struct smb_filename *pathref_fname = NULL; + NTSTATUS status; + + if (argc != 3) { + printf("Usage: removexattr \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + status = synthetic_pathref(mem_ctx, + vfs->conn->cwd_fsp, + smb_fname->base_name, + NULL, + NULL, + smb_fname->twrp, + smb_fname->flags, + &pathref_fname); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + ret = SMB_VFS_FREMOVEXATTR(pathref_fname->fsp, argv[2]); + if (ret == -1) { + int err = errno; + printf("removexattr returned (%s)\n", strerror(err)); + return map_nt_error_from_unix(err); + } + return NT_STATUS_OK; +} + +static NTSTATUS cmd_fget_nt_acl(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + int fd; + NTSTATUS status; + struct security_descriptor *sd; + + if (argc != 2) { + printf("Usage: fget_nt_acl \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (fd < 0 || fd >= 1024) { + printf("fget_nt_acl: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("fget_nt_acl: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + status = SMB_VFS_FGET_NT_ACL(metadata_fsp(vfs->files[fd]), + SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL, + talloc_tos(), &sd); + if (!NT_STATUS_IS_OK(status)) { + printf("fget_nt_acl returned (%s)\n", nt_errstr(status)); + return status; + } + printf("%s\n", sddl_encode(talloc_tos(), sd, get_global_sam_sid())); + TALLOC_FREE(sd); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_get_nt_acl(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + NTSTATUS status; + struct security_descriptor *sd; + struct smb_filename *smb_fname = NULL; + struct smb_filename *pathref_fname = NULL; + + if (argc != 2) { + printf("Usage: get_nt_acl \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname(talloc_tos(), + argv[1], + NULL, + NULL, + 0, + ssf_flags()); + + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = synthetic_pathref(mem_ctx, + vfs->conn->cwd_fsp, + smb_fname->base_name, + NULL, + NULL, + smb_fname->twrp, + smb_fname->flags, + &pathref_fname); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(smb_fname); + return status; + } + status = SMB_VFS_FGET_NT_ACL(pathref_fname->fsp, + SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL, + talloc_tos(), + &sd); + if (!NT_STATUS_IS_OK(status)) { + printf("get_nt_acl returned (%s)\n", nt_errstr(status)); + TALLOC_FREE(smb_fname); + TALLOC_FREE(pathref_fname); + return status; + } + printf("%s\n", sddl_encode(talloc_tos(), sd, get_global_sam_sid())); + TALLOC_FREE(sd); + TALLOC_FREE(smb_fname); + TALLOC_FREE(pathref_fname); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_fset_nt_acl(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + int fd; + NTSTATUS status; + struct security_descriptor *sd; + + if (argc != 3) { + printf("Usage: fset_nt_acl \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (fd < 0 || fd >= 1024) { + printf("fset_nt_acl: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("fset_nt_acl: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + sd = sddl_decode(talloc_tos(), argv[2], get_global_sam_sid()); + if (!sd) { + printf("sddl_decode failed to parse %s as SDDL\n", argv[2]); + return NT_STATUS_INVALID_PARAMETER; + } + + status = SMB_VFS_FSET_NT_ACL( + metadata_fsp(vfs->files[fd]), + SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL, + sd); + if (!NT_STATUS_IS_OK(status)) { + printf("fset_nt_acl returned (%s)\n", nt_errstr(status)); + return status; + } + TALLOC_FREE(sd); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_set_nt_acl(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + struct vfs_open_how how = { .mode = 0400, }; + files_struct *fsp; + struct files_struct *fspcwd = NULL; + struct smb_filename *smb_fname = NULL; + NTSTATUS status; + struct security_descriptor *sd = NULL; + int fd; + + if (argc != 3) { + printf("Usage: set_nt_acl \n"); + return NT_STATUS_OK; + } + + + fsp = talloc_zero(vfs, struct files_struct); + if (fsp == NULL) { + return NT_STATUS_NO_MEMORY; + } + fsp->fh = fd_handle_create(fsp); + if (fsp->fh == NULL) { + TALLOC_FREE(fsp); + return NT_STATUS_NO_MEMORY; + } + fsp->conn = vfs->conn; + + smb_fname = synthetic_smb_fname_split(NULL, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + TALLOC_FREE(fsp); + return NT_STATUS_NO_MEMORY; + } + + fsp->fsp_name = smb_fname; + + status = vfs_at_fspcwd(fsp, vfs->conn, &fspcwd); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + how.flags = O_RDWR; + fd = SMB_VFS_OPENAT(vfs->conn, + fspcwd, + smb_fname, + fsp, + &how); + if (fd == -1 && errno == EISDIR) { +#ifdef O_DIRECTORY + how.flags = O_RDONLY|O_DIRECTORY; +#else + /* POSIX allows us to open a directory with O_RDONLY. */ + how.flags = O_RDONLY; +#endif + fd = SMB_VFS_OPENAT(vfs->conn, + fspcwd, + smb_fname, + fsp, + &how); + } + if (fd == -1) { + printf("open: error=%d (%s)\n", errno, strerror(errno)); + TALLOC_FREE(fsp); + TALLOC_FREE(smb_fname); + return NT_STATUS_UNSUCCESSFUL; + } + fsp_set_fd(fsp, fd); + + status = vfs_stat_fsp(fsp); + if (!NT_STATUS_IS_OK(status)) { + /* If we have an fd, this stat should succeed. */ + DEBUG(0,("Error doing fstat on open file %s " + "(%s)\n", + smb_fname_str_dbg(smb_fname), + nt_errstr(status) )); + goto out; + } + + fsp->file_id = vfs_file_id_from_sbuf(vfs->conn, &smb_fname->st); + fsp->vuid = UID_FIELD_INVALID; + fsp->file_pid = 0; + fsp->fsp_flags.can_lock = true; + fsp->fsp_flags.can_read = true; + fsp->fsp_flags.can_write = true; + fsp->print_file = NULL; + fsp->fsp_flags.modified = false; + fsp->sent_oplock_break = NO_BREAK_SENT; + fsp->fsp_flags.is_directory = S_ISDIR(smb_fname->st.st_ex_mode); + + sd = sddl_decode(talloc_tos(), argv[2], get_global_sam_sid()); + if (!sd) { + printf("sddl_decode failed to parse %s as SDDL\n", argv[2]); + status = NT_STATUS_INVALID_PARAMETER; + goto out; + } + + status = SMB_VFS_FSET_NT_ACL( + metadata_fsp(fsp), + SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL, + sd); + if (!NT_STATUS_IS_OK(status)) { + printf("fset_nt_acl returned (%s)\n", nt_errstr(status)); + goto out; + } +out: + TALLOC_FREE(sd); + + status = fd_close(fsp); + if (!NT_STATUS_IS_OK(status)) + printf("close: error= (%s)\n", nt_errstr(status)); + + TALLOC_FREE(fsp); + + return status; +} + + + +static NTSTATUS cmd_sys_acl_get_fd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + int fd; + SMB_ACL_T acl; + char *acl_text; + + if (argc != 2) { + printf("Usage: sys_acl_get_fd \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (fd < 0 || fd >= 1024) { + printf("sys_acl_get_fd: error=%d (file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("sys_acl_get_fd: error=%d (invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + acl = SMB_VFS_SYS_ACL_GET_FD(vfs->files[fd], + SMB_ACL_TYPE_ACCESS, + talloc_tos()); + if (!acl) { + printf("sys_acl_get_fd failed (%s)\n", strerror(errno)); + return NT_STATUS_UNSUCCESSFUL; + } + acl_text = sys_acl_to_text(acl, NULL); + printf("%s", acl_text); + TALLOC_FREE(acl); + SAFE_FREE(acl_text); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_sys_acl_get_file(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + SMB_ACL_T acl; + char *acl_text; + int type; + struct smb_filename *smb_fname = NULL; + struct smb_filename *pathref_fname = NULL; + NTSTATUS status; + + if (argc != 3) { + printf("Usage: sys_acl_get_file \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname_split(talloc_tos(), + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + type = atoi(argv[2]); + + status = synthetic_pathref(mem_ctx, + vfs->conn->cwd_fsp, + smb_fname->base_name, + NULL, + NULL, + smb_fname->twrp, + smb_fname->flags, + &pathref_fname); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(smb_fname); + return status; + } + + acl = SMB_VFS_SYS_ACL_GET_FD(pathref_fname->fsp, + type, talloc_tos()); + if (!acl) { + printf("sys_acl_get_fd failed (%s)\n", strerror(errno)); + TALLOC_FREE(smb_fname); + TALLOC_FREE(pathref_fname); + return NT_STATUS_UNSUCCESSFUL; + } + acl_text = sys_acl_to_text(acl, NULL); + printf("%s", acl_text); + TALLOC_FREE(acl); + TALLOC_FREE(smb_fname); + TALLOC_FREE(pathref_fname); + SAFE_FREE(acl_text); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_sys_acl_blob_get_file(struct vfs_state *vfs, + TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + char *description; + DATA_BLOB blob; + int ret; + size_t i; + struct smb_filename *smb_fname = NULL; + struct smb_filename *pathref_fname = NULL; + NTSTATUS status; + + if (argc != 2) { + printf("Usage: sys_acl_blob_get_file \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + status = synthetic_pathref(mem_ctx, + vfs->conn->cwd_fsp, + smb_fname->base_name, + NULL, + NULL, + smb_fname->twrp, + smb_fname->flags, + &pathref_fname); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(smb_fname); + return status; + } + + ret = SMB_VFS_SYS_ACL_BLOB_GET_FD(pathref_fname->fsp, + talloc_tos(), + &description, + &blob); + if (ret != 0) { + status = map_nt_error_from_unix(errno); + printf("sys_acl_blob_get_file failed (%s)\n", strerror(errno)); + TALLOC_FREE(smb_fname); + TALLOC_FREE(pathref_fname); + return status; + } + printf("Description: %s\n", description); + for (i = 0; i < blob.length; i++) { + printf("%.2x ", blob.data[i]); + } + printf("\n"); + + TALLOC_FREE(smb_fname); + TALLOC_FREE(pathref_fname); + return NT_STATUS_OK; +} + +static NTSTATUS cmd_sys_acl_blob_get_fd(struct vfs_state *vfs, + TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + int fd; + char *description; + DATA_BLOB blob; + int ret; + size_t i; + + if (argc != 2) { + printf("Usage: sys_acl_blob_get_fd \n"); + return NT_STATUS_OK; + } + + fd = atoi(argv[1]); + if (fd < 0 || fd >= 1024) { + printf("sys_acl_blob_get_fd: error=%d " + "(file descriptor out of range)\n", EBADF); + return NT_STATUS_OK; + } + if (vfs->files[fd] == NULL) { + printf("sys_acl_blob_get_fd: error=%d " + "(invalid file descriptor)\n", EBADF); + return NT_STATUS_OK; + } + + ret = SMB_VFS_SYS_ACL_BLOB_GET_FD(vfs->files[fd], talloc_tos(), + &description, &blob); + if (ret != 0) { + printf("sys_acl_blob_get_fd failed (%s)\n", strerror(errno)); + return map_nt_error_from_unix(errno); + } + printf("Description: %s\n", description); + for (i = 0; i < blob.length; i++) { + printf("%.2x ", blob.data[i]); + } + printf("\n"); + + return NT_STATUS_OK; +} + + + +static NTSTATUS cmd_sys_acl_delete_def_file(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + int ret; + struct smb_filename *smb_fname = NULL; + struct smb_filename *pathref_fname = NULL; + NTSTATUS status; + + if (argc != 2) { + printf("Usage: sys_acl_delete_def_file \n"); + return NT_STATUS_OK; + } + + smb_fname = synthetic_smb_fname_split(mem_ctx, + argv[1], + lp_posix_pathnames()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + status = synthetic_pathref(mem_ctx, + vfs->conn->cwd_fsp, + smb_fname->base_name, + NULL, + NULL, + smb_fname->twrp, + smb_fname->flags, + &pathref_fname); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(smb_fname); + return status; + } + if (!pathref_fname->fsp->fsp_flags.is_directory) { + printf("sys_acl_delete_def_file - %s is not a directory\n", + smb_fname->base_name); + TALLOC_FREE(smb_fname); + TALLOC_FREE(pathref_fname); + return NT_STATUS_INVALID_PARAMETER; + } + ret = SMB_VFS_SYS_ACL_DELETE_DEF_FD(pathref_fname->fsp); + if (ret == -1) { + int err = errno; + printf("sys_acl_delete_def_file failed (%s)\n", strerror(err)); + TALLOC_FREE(smb_fname); + TALLOC_FREE(pathref_fname); + return map_nt_error_from_unix(err); + } + TALLOC_FREE(smb_fname); + TALLOC_FREE(pathref_fname); + return NT_STATUS_OK; +} + +/* Afaik translate name was first introduced with vfs_catia, to be able + to translate unix file/dir-names, containing invalid windows characters, + to valid windows names. + The used translation direction is always unix --> windows +*/ +static NTSTATUS cmd_translate_name(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + const char *dname = NULL; + char *dname_talloced = NULL; + bool found = false; + char *translated = NULL; + struct smb_filename *smb_fname = NULL; + NTSTATUS status; + + if (argc != 2) { + DEBUG(0, ("Usage: translate_name unix_filename\n")); + return NT_STATUS_UNSUCCESSFUL; + } + + smb_fname = synthetic_smb_fname(talloc_tos(), + ".", + NULL, + NULL, + 0, + ssf_flags()); + if (smb_fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = OpenDir(vfs->conn, + vfs->conn, + smb_fname, + NULL, + 0, + &vfs->currentdir); + if (!NT_STATUS_IS_OK(status)) { + int err = map_errno_from_nt_status(status); + DEBUG(0, ("cmd_translate_name: opendir error=%d (%s)\n", + err, strerror(err))); + TALLOC_FREE(smb_fname); + errno = err; + return NT_STATUS_UNSUCCESSFUL; + } + + while (true) { + /* ReadDirName() returns Windows "encoding" */ + dname = ReadDirName(vfs->currentdir, &dname_talloced); + if (dname == NULL) { + break; + } + + /* Convert Windows "encoding" from ReadDirName() to UNIX */ + status = SMB_VFS_TRANSLATE_NAME(vfs->conn, + dname, + vfs_translate_to_unix, + talloc_tos(), + &translated); + if (!NT_STATUS_IS_OK(status)) { + DBG_ERR("file '%s' cannot be translated\n", argv[1]); + goto cleanup; + } + + /* + * argv[1] uses UNIX "encoding", so compare with translation + * result. + */ + if (strcmp(translated, argv[1]) == 0) { + found = true; + break; + } + TALLOC_FREE(dname_talloced); + TALLOC_FREE(translated); + }; + + if (!found) { + DEBUG(0, ("cmd_translate_name: file '%s' not found.\n", + argv[1])); + status = NT_STATUS_UNSUCCESSFUL; + goto cleanup; + } + + /* translation success. But that could also mean + that translating "aaa" to "aaa" was successful :-( + */ + DBG_ERR("file '%s' --> '%s'\n", argv[1], dname); + status = NT_STATUS_OK; + +cleanup: + TALLOC_FREE(dname_talloced); + TALLOC_FREE(translated); + TALLOC_FREE(smb_fname); + TALLOC_FREE(vfs->currentdir); + return status; +} + +/* + * This is a quick hack to demonstrate a crash in the full_audit + * module when passing fsp->smb_fname into SMB_VFS_CREATE_FILE leading + * to an error. + * + * Feel free to expand with more options as needed + */ +static NTSTATUS cmd_create_file( + struct vfs_state *vfs, + TALLOC_CTX *mem_ctx, + int argc, + const char **argv) +{ + struct smb_filename *fname = NULL; + struct files_struct *fsp = NULL; + int info, ret; + NTSTATUS status; + + if (argc != 2) { + DBG_ERR("Usage: create_file filename\n"); + return NT_STATUS_UNSUCCESSFUL; + } + + fname = synthetic_smb_fname( + talloc_tos(), argv[1], NULL, NULL, 0, 0); + if (fname == NULL) { + return NT_STATUS_NO_MEMORY; + } + + ret = vfs_stat(vfs->conn, fname); + if (ret != 0) { + status = map_nt_error_from_unix(errno); + DBG_DEBUG("vfs_stat() failed: %s\n", strerror(errno)); + TALLOC_FREE(fname); + return status; + } + + status = openat_pathref_fsp(vfs->conn->cwd_fsp, fname); + if (!NT_STATUS_IS_OK(status)) { + DBG_DEBUG("Could not open %s: %s\n", + fname->base_name, + nt_errstr(status)); + TALLOC_FREE(fname); + return status; + } + + status = SMB_VFS_CREATE_FILE( + vfs->conn, + NULL, + NULL, + + /* + * Using fname->fsp->fsp_name seems to be legal, + * there's code to handle this in + * create_file_unixpath(). And it is actually very + * worthwhile re-using the fsp_name, we can save quite + * a few copies of smb_filename with that. + */ + fname->fsp->fsp_name, + SEC_FILE_ALL, + FILE_SHARE_NONE, + FILE_OPEN, + FILE_NON_DIRECTORY_FILE, + 0, + 0, + NULL, + 0, + 0, + NULL, + NULL, + &fsp, + &info, + NULL, + NULL + ); + DBG_DEBUG("create_file returned %s\n", nt_errstr(status)); + + TALLOC_FREE(fname); + + return NT_STATUS_OK; +} + +struct cmd_set vfs_commands[] = { + + { .name = "VFS Commands" }, + + { "load", cmd_load_module, "Load a module", "load " }, + { "populate", cmd_populate, "Populate a data buffer", "populate " }, + { "showdata", cmd_show_data, "Show data currently in data buffer", "show_data [ ]"}, + { "connect", cmd_connect, "VFS connect()", "connect" }, + { "disconnect", cmd_disconnect, "VFS disconnect()", "disconnect" }, + { "disk_free", cmd_disk_free, "VFS disk_free()", "disk_free " }, + { "opendir", cmd_opendir, "VFS opendir()", "opendir " }, + { "readdir", cmd_readdir, "VFS readdir()", "readdir" }, + { "mkdir", cmd_mkdir, "VFS mkdir()", "mkdir " }, + { "rmdir", cmd_pathfunc, "VFS rmdir()", "rmdir " }, + { "closedir", cmd_closedir, "VFS closedir()", "closedir" }, + { "open", cmd_open, "VFS open()", "open " }, + { "close", cmd_close, "VFS close()", "close " }, + { "read", cmd_read, "VFS read()", "read " }, + { "write", cmd_write, "VFS write()", "write " }, + { "lseek", cmd_lseek, "VFS lseek()", "lseek " }, + { "rename", cmd_rename, "VFS rename()", "rename " }, + { "fsync", cmd_fsync, "VFS fsync()", "fsync " }, + { "stat", cmd_stat, "VFS stat()", "stat " }, + { "fstat", cmd_fstat, "VFS fstat()", "fstat " }, + { "lstat", cmd_lstat, "VFS lstat()", "lstat " }, + { "unlink", cmd_pathfunc, "VFS unlink()", "unlink " }, + { "chmod", cmd_chmod, "VFS chmod()", "chmod " }, + { "fchmod", cmd_fchmod, "VFS fchmod()", "fchmod " }, + { "fchown", cmd_fchown, "VFS fchown()", "fchown " }, + { "chdir", cmd_pathfunc, "VFS chdir()", "chdir " }, + { "getwd", cmd_getwd, "VFS getwd()", "getwd" }, + { "utime", cmd_utime, "VFS utime()", "utime " }, + { "ftruncate", cmd_ftruncate, "VFS ftruncate()", "ftruncate " }, + { "lock", cmd_lock, "VFS lock()", "lock " }, + { "symlink", cmd_symlink, "VFS symlink()", "symlink " }, + { "readlink", cmd_readlink, "VFS readlink()", "readlink " }, + { "link", cmd_link, "VFS link()", "link " }, + { "mknod", cmd_mknod, "VFS mknod()", "mknod " }, + { "realpath", cmd_realpath, "VFS realpath()", "realpath " }, + { "getxattr", cmd_getxattr, "VFS getxattr()", + "getxattr " }, + { "listxattr", cmd_listxattr, "VFS listxattr()", + "listxattr " }, + { "fsetxattr", cmd_fsetxattr, "VFS fsetxattr()", + "fsetxattr []" }, + { "removexattr", cmd_removexattr, "VFS removexattr()", + "removexattr \n" }, + { "fget_nt_acl", cmd_fget_nt_acl, "VFS fget_nt_acl()", + "fget_nt_acl \n" }, + { "get_nt_acl", cmd_get_nt_acl, "VFS get_nt_acl()", + "get_nt_acl \n" }, + { "fset_nt_acl", cmd_fset_nt_acl, "VFS fset_nt_acl()", + "fset_nt_acl \n" }, + { "set_nt_acl", cmd_set_nt_acl, "VFS open() and fset_nt_acl()", + "set_nt_acl \n" }, + { "sys_acl_get_file", cmd_sys_acl_get_file, "VFS sys_acl_get_file()", "sys_acl_get_file " }, + { "sys_acl_get_fd", cmd_sys_acl_get_fd, "VFS sys_acl_get_fd()", "sys_acl_get_fd " }, + { "sys_acl_blob_get_file", cmd_sys_acl_blob_get_file, + "VFS sys_acl_blob_get_file()", "sys_acl_blob_get_file " }, + { "sys_acl_blob_get_fd", cmd_sys_acl_blob_get_fd, + "VFS sys_acl_blob_get_fd()", "sys_acl_blob_get_fd " }, + { "sys_acl_delete_def_file", cmd_sys_acl_delete_def_file, "VFS sys_acl_delete_def_file()", "sys_acl_delete_def_file " }, + + +#if defined(WITH_SMB1SERVER) + { "test_chain", cmd_test_chain, "test chain code", + "test_chain" }, +#endif + { "translate_name", cmd_translate_name, "VFS translate_name()", "translate_name unix_filename" }, + { "create_file", + cmd_create_file, + "VFS create_file()", + "create_file " + }, + {0} +}; diff --git a/source3/torture/denytest.c b/source3/torture/denytest.c new file mode 100644 index 0000000..34497c3 --- /dev/null +++ b/source3/torture/denytest.c @@ -0,0 +1,1600 @@ +/* + Unix SMB/CIFS implementation. + SMB torture tester - scanning functions + Copyright (C) Andrew Tridgell 2001 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "system/filesys.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" + +extern bool torture_showall; + +enum deny_result {A_0=0, A_X=1, A_R=2, A_W=3, A_RW=5}; + + +static const char *denystr(int denymode) +{ + struct { + int v; + const char *name; + } deny_modes[] = { + {DENY_DOS, "DENY_DOS"}, + {DENY_ALL, "DENY_ALL"}, + {DENY_WRITE, "DENY_WRITE"}, + {DENY_READ, "DENY_READ"}, + {DENY_NONE, "DENY_NONE"}, + {DENY_FCB, "DENY_FCB"}, + {-1, NULL}}; + int i; + for (i=0;deny_modes[i].name;i++) { + if (deny_modes[i].v == denymode) return deny_modes[i].name; + } + return "DENY_XXX"; +} + +static const char *openstr(int mode) +{ + struct { + int v; + const char *name; + } open_modes[] = { + {O_RDWR, "O_RDWR"}, + {O_RDONLY, "O_RDONLY"}, + {O_WRONLY, "O_WRONLY"}, + {-1, NULL}}; + int i; + for (i=0;open_modes[i].name;i++) { + if (open_modes[i].v == mode) return open_modes[i].name; + } + return "O_XXX"; +} + +static const char *resultstr(enum deny_result res) +{ + struct { + enum deny_result res; + const char *name; + } results[] = { + {A_X, "X"}, + {A_0, "-"}, + {A_R, "R"}, + {A_W, "W"}, + {A_RW,"RW"}}; + size_t i; + for (i=0;i. +*/ + +#include "includes.h" +#include "libsmb/libsmb.h" +#include "system/filesys.h" +#include "locking/share_mode_lock.h" +#include "locking/proto.h" +#include "lib/util/string_wrappers.h" + +static fstring password; +static fstring username; +static int got_pass; +static int numops = 1000; +static bool showall; +static bool analyze; +static bool hide_unlock_fails; +static bool use_oplocks; + +extern char *optarg; +extern int optind; + +#define FILENAME "\\locktest.dat" +#define LOCKRANGE 100 +#define LOCKBASE 0 + +/* +#define LOCKBASE (0x40000000 - 50) +*/ + +#define READ_PCT 50 +#define LOCK_PCT 25 +#define UNLOCK_PCT 65 +#define RANGE_MULTIPLE 1 + +#define NSERVERS 2 +#define NCONNECTIONS 2 +#define NUMFSTYPES 2 +#define NFILES 2 +#define LOCK_TIMEOUT 0 + +#define FSTYPE_SMB 0 +#define FSTYPE_NFS 1 + +struct record { + char r1, r2; + char conn, f, fstype; + unsigned start, len; + char needed; +}; + +static struct record *recorded; + +static int try_open(struct cli_state *c, char *nfs, int fstype, const char *fname, int flags) +{ + char *path; + + switch (fstype) { + case FSTYPE_SMB: + { + uint16_t fd; + if (!NT_STATUS_IS_OK(cli_openx(c, fname, flags, DENY_NONE, &fd))) { + return -1; + } + return fd; + } + + case FSTYPE_NFS: + if (asprintf(&path, "%s%s", nfs, fname) > 0) { + int ret; + string_replace(path,'\\', '/'); + ret = open(path, flags, 0666); + SAFE_FREE(path); + return ret; + } + break; + } + + return -1; +} + +static bool try_close(struct cli_state *c, int fstype, int fd) +{ + switch (fstype) { + case FSTYPE_SMB: + return NT_STATUS_IS_OK(cli_close(c, fd)); + + case FSTYPE_NFS: + return close(fd) == 0; + } + + return False; +} + +static bool try_lock(struct cli_state *c, int fstype, + int fd, unsigned start, unsigned len, + enum brl_type op) +{ + struct flock lock; + + switch (fstype) { + case FSTYPE_SMB: + return NT_STATUS_IS_OK(cli_lock32(c, fd, start, len, + LOCK_TIMEOUT, op)); + + case FSTYPE_NFS: + lock.l_type = (op==READ_LOCK) ? F_RDLCK:F_WRLCK; + lock.l_whence = SEEK_SET; + lock.l_start = start; + lock.l_len = len; + lock.l_pid = getpid(); + return fcntl(fd,F_SETLK,&lock) == 0; + } + + return False; +} + +static bool try_unlock(struct cli_state *c, int fstype, + int fd, unsigned start, unsigned len) +{ + struct flock lock; + + switch (fstype) { + case FSTYPE_SMB: + return NT_STATUS_IS_OK(cli_unlock(c, fd, start, len)); + + case FSTYPE_NFS: + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = start; + lock.l_len = len; + lock.l_pid = getpid(); + return fcntl(fd,F_SETLK,&lock) == 0; + } + + return False; +} + +static void print_brl(struct file_id id, struct server_id pid, + enum brl_type lock_type, + enum brl_flavour lock_flav, + br_off start, br_off size, + void *private_data) +{ + struct file_id_buf idbuf; + + printf("%6d %s %s %.0f:%.0f(%.0f)\n", + (int)procid_to_pid(&pid), + file_id_str_buf(id, &idbuf), + lock_type==READ_LOCK?"R":"W", + (double)start, (double)start+size-1,(double)size); + +} + +/***************************************************** +return a connection to a server +*******************************************************/ +static struct cli_state *connect_one(char *share) +{ + struct cli_state *c; + char *server_n; + fstring server; + fstring myname; + static int count; + NTSTATUS nt_status; + bool use_kerberos = false; + bool fallback_after_kerberos = false; + bool use_ccache = false; + bool pw_nt_hash = false; + struct cli_credentials *creds = NULL; + + fstrcpy(server,share+2); + share = strchr_m(server,'\\'); + if (!share) return NULL; + *share = 0; + share++; + + server_n = server; + + if (!got_pass) { + char pwd[256] = {0}; + int rc; + + rc = samba_getpass("Password: ", pwd, sizeof(pwd), false, false); + if (rc == 0) { + fstrcpy(password, pwd); + } + } + + creds = cli_session_creds_init(NULL, + username, + lp_workgroup(), + NULL, /* realm (use default) */ + password, + use_kerberos, + fallback_after_kerberos, + use_ccache, + pw_nt_hash); + if (creds == NULL) { + DEBUG(0, ("cli_session_creds_init failed\n")); + return NULL; + } + + slprintf(myname,sizeof(myname), "lock-%lu-%u", (unsigned long)getpid(), count++); + + nt_status = cli_full_connection_creds(&c, + myname, + server_n, + NULL, + 0, + share, + "?????", + creds, + 0); + TALLOC_FREE(creds); + if (!NT_STATUS_IS_OK(nt_status)) { + DEBUG(0, ("cli_full_connection failed with error %s\n", nt_errstr(nt_status))); + return NULL; + } + + c->use_oplocks = use_oplocks; + + return c; +} + + +static void reconnect(struct cli_state *cli[NSERVERS][NCONNECTIONS], + char *nfs[NSERVERS], + int fnum[NSERVERS][NUMFSTYPES][NCONNECTIONS][NFILES], + char *share1, char *share2) +{ + int server, conn, f, fstype; + char *share[2]; + share[0] = share1; + share[1] = share2; + + fstype = FSTYPE_SMB; + + for (server=0;serverconn; + unsigned f = rec->f; + unsigned fstype = rec->fstype; + unsigned start = rec->start; + unsigned len = rec->len; + unsigned r1 = rec->r1; + unsigned r2 = rec->r2; + enum brl_type op; + int server; + bool ret[NSERVERS]; + + if (r1 < READ_PCT) { + op = READ_LOCK; + } else { + op = WRITE_LOCK; + } + + if (fstype >= NUMFSTYPES) { + return false; + } + + if (r2 < LOCK_PCT) { + /* set a lock */ + for (server=0;server %u:%u\n", + conn, fstype, f, + start, start+len-1, len, + op==READ_LOCK?"READ_LOCK":"WRITE_LOCK", + ret[0], ret[1]); + } + if (showall) brl_forall(print_brl, NULL); + if (ret[0] != ret[1]) return False; + } else if (r2 < LOCK_PCT+UNLOCK_PCT) { + /* unset a lock */ + for (server=0;server %u:%u\n", + conn, fstype, f, + start, start+len-1, len, + ret[0], ret[1]); + } + if (showall) brl_forall(print_brl, NULL); + if (!hide_unlock_fails && ret[0] != ret[1]) return False; + } else { + /* reopen the file */ + for (server=0;server. +*/ + +#include "includes.h" +#include "system/filesys.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "libsmb/clirap.h" +#include "util_tdb.h" +#include "lib/util/string_wrappers.h" + +extern int torture_numops; + +static TDB_CONTEXT *tdb; + +#define NAME_LENGTH 20 + +static unsigned total, collisions, failures; + +static bool test_one(struct cli_state *cli, const char *name) +{ + uint16_t fnum; + fstring shortname; + fstring name2; + NTSTATUS status; + TDB_DATA data; + + total++; + + status = cli_openx(cli, name, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", name, nt_errstr(status)); + return False; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close of %s failed (%s)\n", name, nt_errstr(status)); + return False; + } + + /* get the short name */ + status = cli_qpathinfo_alt_name(cli, name, shortname); + if (!NT_STATUS_IS_OK(status)) { + printf("query altname of %s failed (%s)\n", name, nt_errstr(status)); + return False; + } + + fstr_sprintf(name2, "\\mangle_test\\%s", shortname); + status = cli_unlink(cli, name2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink of %s (%s) failed (%s)\n", + name2, name, nt_errstr(status)); + return False; + } + + /* recreate by short name */ + status = cli_openx(cli, name2, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open2 of %s failed (%s)\n", name2, nt_errstr(status)); + return False; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close of %s failed (%s)\n", name, nt_errstr(status)); + return False; + } + + /* and unlink by long name */ + status = cli_unlink(cli, name, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink2 of %s (%s) failed (%s)\n", + name, name2, nt_errstr(status)); + failures++; + cli_unlink(cli, name2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + return True; + } + + /* see if the short name is already in the tdb */ + data = tdb_fetch_bystring(tdb, shortname); + if (data.dptr) { + /* maybe its a duplicate long name? */ + if (!strequal(name, (const char *)data.dptr)) { + /* we have a collision */ + collisions++; + printf("Collision between %s and %s -> %s " + " (coll/tot: %u/%u)\n", + name, data.dptr, shortname, collisions, total); + } + free(data.dptr); + } else { + TDB_DATA namedata; + /* store it for later */ + namedata.dptr = discard_const_p(uint8_t, name); + namedata.dsize = strlen(name)+1; + tdb_store_bystring(tdb, shortname, namedata, TDB_REPLACE); + } + + return True; +} + + +static void gen_name(char *name) +{ + const char *chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz._-$~... "; + unsigned max_idx = strlen(chars); + unsigned len; + int i; + char *p; + + fstrcpy(name, "\\mangle_test\\"); + p = name + strlen(name); + + len = 1 + random() % NAME_LENGTH; + + for (i=0;i. + */ + +#include "replace.h" +#include "includes.h" +#include "lib/util/server_id.h" +#include "messages.h" +#include "lib/util/tevent_unix.h" +#include + +struct sink_state { + struct tevent_context *ev; + struct messaging_context *msg_ctx; + int msg_type; + unsigned *counter; +}; + +static void sink_done(struct tevent_req *subreq); + +static struct tevent_req *sink_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct messaging_context *msg_ctx, + int msg_type, unsigned *counter) +{ + struct tevent_req *req, *subreq; + struct sink_state *state; + + req = tevent_req_create(mem_ctx, &state, struct sink_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->msg_ctx = msg_ctx; + state->msg_type = msg_type; + state->counter = counter; + + subreq = messaging_read_send(state, state->ev, state->msg_ctx, + state->msg_type); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, sink_done, req); + return req; +} + +static void sink_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct sink_state *state = tevent_req_data( + req, struct sink_state); + int ret; + + ret = messaging_read_recv(subreq, NULL, NULL); + TALLOC_FREE(subreq); + if (tevent_req_error(req, ret)) { + return; + } + + *state->counter += 1; + + subreq = messaging_read_send(state, state->ev, state->msg_ctx, + state->msg_type); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, sink_done, req); +} + +static int sink_recv(struct tevent_req *req) +{ + int err; + + if (tevent_req_is_unix_error(req, &err)) { + return err; + } + return 0; +} + +struct prcount_state { + struct tevent_context *ev; + struct timeval interval; + unsigned *counter; +}; + +static void prcount_waited(struct tevent_req *subreq); + +static struct tevent_req *prcount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct timeval interval, + unsigned *counter) +{ + struct tevent_req *req, *subreq; + struct prcount_state *state; + + req = tevent_req_create(mem_ctx, &state, struct prcount_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->interval = interval; + state->counter = counter; + + subreq = tevent_wakeup_send( + state, state->ev, + timeval_current_ofs(state->interval.tv_sec, + state->interval.tv_usec)); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, prcount_waited, req); + return req; +} + +static void prcount_waited(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct prcount_state *state = tevent_req_data( + req, struct prcount_state); + bool ok; + + ok = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (!ok) { + tevent_req_error(req, ENOMEM); + return; + } + + printf("%u\n", *state->counter); + + subreq = tevent_wakeup_send( + state, state->ev, + timeval_current_ofs(state->interval.tv_sec, + state->interval.tv_usec)); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, prcount_waited, req); +} + +static int prcount_recv(struct tevent_req *req) +{ + int err; + + if (tevent_req_is_unix_error(req, &err)) { + return err; + } + return 0; +} + +struct msgcount_state { + unsigned count; +}; + +static void msgcount_sunk(struct tevent_req *subreq); +static void msgcount_printed(struct tevent_req *subreq); + +static struct tevent_req *msgcount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct messaging_context *msg_ctx, + int msg_type, struct timeval interval) +{ + struct tevent_req *req, *subreq; + struct msgcount_state *state; + + req = tevent_req_create(mem_ctx, &state, struct msgcount_state); + if (req == NULL) { + return NULL; + } + + subreq = sink_send(state, ev, msg_ctx, msg_type, &state->count); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, msgcount_sunk, req); + + subreq = prcount_send(state, ev, interval, &state->count); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, msgcount_printed, req); + + return req; +} + +static void msgcount_sunk(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + int ret; + + ret = sink_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_error(req, ret)) { + return; + } + tevent_req_done(req); +} + +static void msgcount_printed(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + int ret; + + ret = prcount_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_error(req, ret)) { + return; + } + tevent_req_done(req); +} + +static int msgcount_recv(struct tevent_req *req) +{ + int err; + + if (tevent_req_is_unix_error(req, &err)) { + return err; + } + return 0; +} + +int main(void) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct tevent_context *ev; + struct messaging_context *msg_ctx; + struct tevent_req *req; + int ret; + struct server_id id; + struct server_id_buf tmp; + + lp_load_global(get_dyn_CONFIGFILE()); + + ev = tevent_context_init(frame); + if (ev == NULL) { + perror("tevent_context_init failed"); + return -1; + } + + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + perror("messaging_init failed"); + return -1; + } + + id = messaging_server_id(msg_ctx); + + printf("server_id: %s\n", server_id_str_buf(id, &tmp)); + + req = msgcount_send(ev, ev, msg_ctx, MSG_SMB_NOTIFY, + timeval_set(1, 0)); + if (req == NULL) { + perror("msgcount_send failed"); + return -1; + } + + if (!tevent_req_poll(req, ev)) { + perror("tevent_req_poll failed"); + return -1; + } + + ret = msgcount_recv(req); + printf("msgcount_recv returned %d\n", ret); + + return 0; +} diff --git a/source3/torture/msg_source.c b/source3/torture/msg_source.c new file mode 100644 index 0000000..e718018 --- /dev/null +++ b/source3/torture/msg_source.c @@ -0,0 +1,159 @@ +/* + * Unix SMB/CIFS implementation. + * Send messages once a second + * Copyright (C) Volker Lendecke 2014 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "replace.h" +#include "includes.h" +#include "lib/util/server_id.h" +#include "messages.h" +#include "lib/util/tevent_unix.h" +#include + +struct source_state { + struct tevent_context *ev; + struct messaging_context *msg_ctx; + int msg_type; + struct timeval interval; + struct server_id dst; +}; + +static void source_waited(struct tevent_req *subreq); + +static struct tevent_req *source_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct messaging_context *msg_ctx, + int msg_type, + struct timeval interval, + struct server_id dst) +{ + struct tevent_req *req, *subreq; + struct source_state *state; + + req = tevent_req_create(mem_ctx, &state, struct source_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->msg_ctx = msg_ctx; + state->msg_type = msg_type; + state->interval = interval; + state->dst = dst; + + subreq = tevent_wakeup_send( + state, state->ev, + timeval_current_ofs(state->interval.tv_sec, + state->interval.tv_usec)); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, source_waited, req); + return req; +} + +static void source_waited(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct source_state *state = tevent_req_data( + req, struct source_state); + bool ok; + uint8_t buf[200] = { }; + + ok = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (!ok) { + tevent_req_error(req, ENOMEM); + return; + } + + messaging_send_buf(state->msg_ctx, state->dst, state->msg_type, + buf, sizeof(buf)); + + subreq = tevent_wakeup_send( + state, state->ev, + timeval_current_ofs(state->interval.tv_sec, + state->interval.tv_usec)); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, source_waited, req); +} + +static int source_recv(struct tevent_req *req) +{ + int err; + + if (tevent_req_is_unix_error(req, &err)) { + return err; + } + return 0; +} + +int main(int argc, const char *argv[]) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct tevent_context *ev; + struct messaging_context *msg_ctx; + struct tevent_req *req; + int ret; + struct server_id my_id, id; + + if (argc != 2) { + fprintf(stderr, "Usage: %s \n", argv[0]); + return -1; + } + + lp_load_global(get_dyn_CONFIGFILE()); + + ev = tevent_context_init(frame); + if (ev == NULL) { + perror("tevent_context_init failed"); + return -1; + } + + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + perror("messaging_init failed"); + return -1; + } + my_id = messaging_server_id(msg_ctx); + + id = server_id_from_string(my_id.vnn, argv[1]); + if (!procid_valid(&id)) { + fprintf(stderr, "pid %s invalid\n", argv[1]); + return -1; + } + + req = source_send(ev, ev, msg_ctx, MSG_SMB_NOTIFY, + timeval_set(0, 10000), id); + if (req == NULL) { + perror("source_send failed"); + return -1; + } + + if (!tevent_req_poll(req, ev)) { + perror("tevent_req_poll failed"); + return -1; + } + + ret = source_recv(req); + + printf("source_recv returned %d\n", ret); + + return 0; +} diff --git a/source3/torture/msgtest.c b/source3/torture/msgtest.c new file mode 100644 index 0000000..1d2a8a9 --- /dev/null +++ b/source3/torture/msgtest.c @@ -0,0 +1,171 @@ +/* + Unix SMB/CIFS implementation. + Copyright (C) Andrew Tridgell 2000 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/* + test code for internal messaging + */ + +#include "includes.h" +#include "messages.h" + +static int pong_count; + + +/**************************************************************************** +a useful function for testing the message system +****************************************************************************/ +static void pong_message(struct messaging_context *msg_ctx, + void *private_data, + uint32_t msg_type, + struct server_id pid, + DATA_BLOB *data) +{ + pong_count++; +} + + int main(int argc, char *argv[]) +{ + struct tevent_context *evt_ctx; + struct messaging_context *msg_ctx; + pid_t pid; + int i, n; + char buf[12]; + int ret; + TALLOC_CTX *frame = talloc_stackframe(); + + smb_init_locale(); + + setup_logging(argv[0], DEBUG_STDOUT); + + lp_load_global(get_dyn_CONFIGFILE()); + + if (!(evt_ctx = samba_tevent_context_init(NULL)) || + !(msg_ctx = messaging_init(NULL, evt_ctx))) { + fprintf(stderr, "could not init messaging context\n"); + TALLOC_FREE(frame); + exit(1); + } + + if (argc != 3) { + fprintf(stderr, "%s: Usage - %s pid count\n", argv[0], + argv[0]); + TALLOC_FREE(frame); + exit(1); + } + + pid = atoi(argv[1]); + n = atoi(argv[2]); + + messaging_register(msg_ctx, NULL, MSG_PONG, pong_message); + + for (i=0;i pong_count + 20) { + ret = tevent_loop_once(evt_ctx); + if (ret != 0) { + break; + } + } + } + + printf("waiting for %d remaining replies (done %d)\n", + (int)(ping_count - pong_count), pong_count); + while (timeval_elapsed(&tv) < 30 && pong_count < ping_count) { + ret = tevent_loop_once(evt_ctx); + if (ret != 0) { + break; + } + } + + if (ping_count != pong_count) { + fprintf(stderr, "ping test failed! received %d, sent " + "%d\n", pong_count, (int)ping_count); + } + + printf("ping rate of %.0f messages/sec\n", + (ping_count+pong_count)/timeval_elapsed(&tv)); + } + + TALLOC_FREE(frame); + return (0); +} + diff --git a/source3/torture/nbench.c b/source3/torture/nbench.c new file mode 100644 index 0000000..8646d7a --- /dev/null +++ b/source3/torture/nbench.c @@ -0,0 +1,504 @@ +/* + Unix SMB/CIFS implementation. + In-memory cache + Copyright (C) Volker Lendecke 2007 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "libsmb/clirap.h" +#include "../lib/util/tevent_ntstatus.h" + +static long long int ival(const char *str) +{ + return strtoll(str, NULL, 0); +} + +struct nbench_state { + struct tevent_context *ev; + struct cli_state *cli; + const char *cliname; + FILE *loadfile; + struct ftable *ftable; + void (*bw_report)(size_t nread, + size_t nwritten, + void *private_data); + void *bw_report_private; +}; + +struct lock_info { + struct lock_info *next, *prev; + off_t offset; + int size; +}; + +struct createx_params { + char *fname; + unsigned int cr_options; + unsigned int cr_disposition; + int handle; +}; + +struct ftable { + struct ftable *next, *prev; + struct createx_params cp; + struct lock_info *locks; + uint16_t fnum; /* the fd that we got back from the server */ +}; + +enum nbench_cmd { + NBENCH_CMD_NTCREATEX, + NBENCH_CMD_CLOSE, + NBENCH_CMD_RENAME, + NBENCH_CMD_UNLINK, + NBENCH_CMD_DELTREE, + NBENCH_CMD_RMDIR, + NBENCH_CMD_MKDIR, + NBENCH_CMD_QUERY_PATH_INFORMATION, + NBENCH_CMD_QUERY_FILE_INFORMATION, + NBENCH_CMD_QUERY_FS_INFORMATION, + NBENCH_CMD_SET_FILE_INFORMATION, + NBENCH_CMD_FIND_FIRST, + NBENCH_CMD_WRITEX, + NBENCH_CMD_WRITE, + NBENCH_CMD_LOCKX, + NBENCH_CMD_UNLOCKX, + NBENCH_CMD_READX, + NBENCH_CMD_FLUSH, + NBENCH_CMD_SLEEP, +}; + +struct nbench_cmd_struct { + char **params; + int num_params; + NTSTATUS status; + enum nbench_cmd cmd; +}; + +static struct nbench_cmd_struct *nbench_parse(TALLOC_CTX *mem_ctx, + const char *line) +{ + struct nbench_cmd_struct *result; + char *cmd; + char *status; + + result = talloc(mem_ctx, struct nbench_cmd_struct); + if (result == NULL) { + return NULL; + } + result->params = str_list_make_shell(mem_ctx, line, " "); + if (result->params == NULL) { + goto fail; + } + result->num_params = talloc_array_length(result->params) - 1; + if (result->num_params < 2) { + goto fail; + } + status = result->params[result->num_params-1]; + if (strncmp(status, "NT_STATUS_", 10) != 0 && + strncmp(status, "0x", 2) != 0) { + goto fail; + } + /* accept numeric or string status codes */ + if (strncmp(status, "0x", 2) == 0) { + result->status = NT_STATUS(strtoul(status, NULL, 16)); + } else { + result->status = nt_status_string_to_code(status); + } + + cmd = result->params[0]; + + if (!strcmp(cmd, "NTCreateX")) { + result->cmd = NBENCH_CMD_NTCREATEX; + } else if (!strcmp(cmd, "Close")) { + result->cmd = NBENCH_CMD_CLOSE; + } else if (!strcmp(cmd, "Rename")) { + result->cmd = NBENCH_CMD_RENAME; + } else if (!strcmp(cmd, "Unlink")) { + result->cmd = NBENCH_CMD_UNLINK; + } else if (!strcmp(cmd, "Deltree")) { + result->cmd = NBENCH_CMD_DELTREE; + } else if (!strcmp(cmd, "Rmdir")) { + result->cmd = NBENCH_CMD_RMDIR; + } else if (!strcmp(cmd, "Mkdir")) { + result->cmd = NBENCH_CMD_MKDIR; + } else if (!strcmp(cmd, "QUERY_PATH_INFORMATION")) { + result->cmd = NBENCH_CMD_QUERY_PATH_INFORMATION; + } else if (!strcmp(cmd, "QUERY_FILE_INFORMATION")) { + result->cmd = NBENCH_CMD_QUERY_FILE_INFORMATION; + } else if (!strcmp(cmd, "QUERY_FS_INFORMATION")) { + result->cmd = NBENCH_CMD_QUERY_FS_INFORMATION; + } else if (!strcmp(cmd, "SET_FILE_INFORMATION")) { + result->cmd = NBENCH_CMD_SET_FILE_INFORMATION; + } else if (!strcmp(cmd, "FIND_FIRST")) { + result->cmd = NBENCH_CMD_FIND_FIRST; + } else if (!strcmp(cmd, "WriteX")) { + result->cmd = NBENCH_CMD_WRITEX; + } else if (!strcmp(cmd, "Write")) { + result->cmd = NBENCH_CMD_WRITE; + } else if (!strcmp(cmd, "LockX")) { + result->cmd = NBENCH_CMD_LOCKX; + } else if (!strcmp(cmd, "UnlockX")) { + result->cmd = NBENCH_CMD_UNLOCKX; + } else if (!strcmp(cmd, "ReadX")) { + result->cmd = NBENCH_CMD_READX; + } else if (!strcmp(cmd, "Flush")) { + result->cmd = NBENCH_CMD_FLUSH; + } else if (!strcmp(cmd, "Sleep")) { + result->cmd = NBENCH_CMD_SLEEP; + } else { + goto fail; + } + return result; +fail: + TALLOC_FREE(result); + return NULL; +} + +static struct ftable *ft_find(struct ftable *ftlist, int handle) +{ + while (ftlist != NULL) { + if (ftlist->cp.handle == handle) { + return ftlist; + } + ftlist = ftlist->next; + } + return NULL; +} + +struct nbench_cmd_state { + struct tevent_context *ev; + struct nbench_state *state; + struct nbench_cmd_struct *cmd; + struct ftable *ft; + bool eof; +}; + +static void nbench_cmd_done(struct tevent_req *subreq); + +static struct tevent_req *nbench_cmd_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct nbench_state *nb_state) +{ + struct tevent_req *req, *subreq; + struct nbench_cmd_state *state; + char line[1024]; + size_t len; + + req = tevent_req_create(mem_ctx, &state, struct nbench_cmd_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->state = nb_state; + + if (fgets(line, sizeof(line), nb_state->loadfile) == NULL) { + tevent_req_nterror(req, NT_STATUS_END_OF_FILE); + return tevent_req_post(req, ev); + } + len = strlen(line); + if (len == 0) { + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + return tevent_req_post(req, ev); + } + if (line[len-1] == '\n') { + line[len-1] = '\0'; + } + + state->cmd = nbench_parse(state, line); + if (state->cmd == NULL) { + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + return tevent_req_post(req, ev); + } + + switch (state->cmd->cmd) { + case NBENCH_CMD_NTCREATEX: { + uint32_t desired_access; + uint32_t share_mode; + unsigned int flags = 0; + + state->ft = talloc(state, struct ftable); + if (tevent_req_nomem(state->ft, req)) { + return tevent_req_post(req, ev); + } + + state->ft->cp.fname = talloc_all_string_sub( + state->ft, state->cmd->params[1], "client1", + nb_state->cliname); + if (tevent_req_nomem(state->ft->cp.fname, req)) { + return tevent_req_post(req, ev); + } + state->ft->cp.cr_options = ival(state->cmd->params[2]); + state->ft->cp.cr_disposition = ival(state->cmd->params[3]); + state->ft->cp.handle = ival(state->cmd->params[4]); + + if (state->ft->cp.cr_options & FILE_DIRECTORY_FILE) { + desired_access = SEC_FILE_READ_DATA; + } else { + desired_access = + SEC_FILE_READ_DATA | + SEC_FILE_WRITE_DATA | + SEC_FILE_READ_ATTRIBUTE | + SEC_FILE_WRITE_ATTRIBUTE; + flags = EXTENDED_RESPONSE_REQUIRED + | REQUEST_OPLOCK | REQUEST_BATCH_OPLOCK; + } + share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE; + + subreq = cli_ntcreate_send( + state, ev, nb_state->cli, state->ft->cp.fname, flags, + desired_access, 0, share_mode, + state->ft->cp.cr_disposition, + state->ft->cp.cr_options, + SMB2_IMPERSONATION_IMPERSONATION, 0); + break; + } + case NBENCH_CMD_CLOSE: { + state->ft = ft_find(state->state->ftable, + ival(state->cmd->params[1])); + if (state->ft == NULL) { + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + return tevent_req_post(req, ev); + } + subreq = cli_close_send(state, + ev, + nb_state->cli, + state->ft->fnum, + 0); + break; + } + case NBENCH_CMD_MKDIR: { + char *fname; + fname = talloc_all_string_sub( + state, state->cmd->params[1], "client1", + nb_state->cliname); + if (tevent_req_nomem(state->ft->cp.fname, req)) { + return tevent_req_post(req, ev); + } + subreq = cli_mkdir_send(state, ev, nb_state->cli, fname); + break; + } + case NBENCH_CMD_QUERY_PATH_INFORMATION: { + char *fname; + fname = talloc_all_string_sub( + state, state->cmd->params[1], "client1", + nb_state->cliname); + if (tevent_req_nomem(state->ft->cp.fname, req)) { + return tevent_req_post(req, ev); + } + subreq = cli_qpathinfo_send(state, ev, nb_state->cli, fname, + ival(state->cmd->params[2]), + 0, CLI_BUFFER_SIZE); + break; + } + default: + tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED); + return tevent_req_post(req, ev); + } + + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, nbench_cmd_done, req); + return req; +} + +static bool status_wrong(struct tevent_req *req, NTSTATUS expected, + NTSTATUS status) +{ + if (NT_STATUS_EQUAL(expected, status)) { + return false; + } + if (NT_STATUS_IS_OK(status)) { + status = NT_STATUS_INVALID_NETWORK_RESPONSE; + } + tevent_req_nterror(req, status); + return true; +} + +static void nbench_cmd_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct nbench_cmd_state *state = tevent_req_data( + req, struct nbench_cmd_state); + struct nbench_state *nbstate = state->state; + NTSTATUS status; + + switch (state->cmd->cmd) { + case NBENCH_CMD_NTCREATEX: { + struct ftable *ft; + status = cli_ntcreate_recv(subreq, &state->ft->fnum, NULL); + TALLOC_FREE(subreq); + if (status_wrong(req, state->cmd->status, status)) { + return; + } + if (!NT_STATUS_IS_OK(status)) { + tevent_req_done(req); + return; + } + ft = talloc_move(nbstate, &state->ft); + DLIST_ADD(nbstate->ftable, ft); + break; + } + case NBENCH_CMD_CLOSE: { + status = cli_close_recv(subreq); + TALLOC_FREE(subreq); + if (status_wrong(req, state->cmd->status, status)) { + return; + } + DLIST_REMOVE(state->state->ftable, state->ft); + TALLOC_FREE(state->ft); + break; + } + case NBENCH_CMD_MKDIR: { + status = cli_mkdir_recv(subreq); + TALLOC_FREE(subreq); + if (status_wrong(req, state->cmd->status, status)) { + return; + } + break; + } + case NBENCH_CMD_QUERY_PATH_INFORMATION: { + status = cli_qpathinfo_recv(subreq, NULL, NULL, NULL); + TALLOC_FREE(subreq); + if (status_wrong(req, state->cmd->status, status)) { + return; + } + break; + } + default: + break; + } + tevent_req_done(req); +} + +static NTSTATUS nbench_cmd_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static void nbench_done(struct tevent_req *subreq); + +static struct tevent_req *nbench_send( + TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct cli_state *cli, + const char *cliname, FILE *loadfile, + void (*bw_report)(size_t nread, size_t nwritten, void *private_data), + void *bw_report_private) +{ + struct tevent_req *req, *subreq; + struct nbench_state *state; + + req = tevent_req_create(mem_ctx, &state, struct nbench_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + state->cliname = cliname; + state->loadfile = loadfile; + state->bw_report = bw_report; + state->bw_report_private = bw_report_private; + + subreq = nbench_cmd_send(state, ev, state); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, nbench_done, req); + return req; +} + +static void nbench_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct nbench_state *state = tevent_req_data( + req, struct nbench_state); + NTSTATUS status; + + status = nbench_cmd_recv(subreq); + TALLOC_FREE(subreq); + + if (NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE)) { + tevent_req_done(req); + return; + } + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + subreq = nbench_cmd_send(state, state->ev, state); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, nbench_done, req); +} + +static NTSTATUS nbench_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +bool run_nbench2(int dummy) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct tevent_context *ev; + struct cli_state *cli = NULL; + FILE *loadfile; + bool ret = false; + struct tevent_req *req; + NTSTATUS status; + + loadfile = fopen("client.txt", "r"); + if (loadfile == NULL) { + fprintf(stderr, "Could not open \"client.txt\": %s\n", + strerror(errno)); + return false; + } + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + goto fail; + } + if (!torture_open_connection(&cli, 0)) { + goto fail; + } + + req = nbench_send(talloc_tos(), ev, cli, "client1", loadfile, + NULL, NULL); + if (req == NULL) { + goto fail; + } + if (!tevent_req_poll(req, ev)) { + goto fail; + } + status = nbench_recv(req); + TALLOC_FREE(req); + printf("nbench returned %s\n", nt_errstr(status)); + + ret = true; +fail: + if (cli != NULL) { + torture_close_connection(cli); + } + TALLOC_FREE(ev); + if (loadfile != NULL) { + fclose(loadfile); + loadfile = NULL; + } + TALLOC_FREE(frame); + return ret; +} diff --git a/source3/torture/nbio.c b/source3/torture/nbio.c new file mode 100644 index 0000000..4fedfc5 --- /dev/null +++ b/source3/torture/nbio.c @@ -0,0 +1,377 @@ +#define NBDEBUG 0 + +/* + Unix SMB/CIFS implementation. + SMB torture tester + Copyright (C) Andrew Tridgell 1997-1998 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "../libcli/security/security.h" +#include "libsmb/libsmb.h" +#include "libsmb/clirap.h" + +#define MAX_FILES 1000 + +static char buf[70000]; +extern int line_count; +extern int nbio_id; +static int nprocs; +static struct timeval nb_start; + +static struct { + int fd; + int handle; +} ftable[MAX_FILES]; + +static struct children { + double bytes_in, bytes_out; + int line; + int done; +} *children; + +double nbio_total(void) +{ + int i; + double total = 0; + for (i=0;iname[0] == '.') { + return NT_STATUS_OK; + } + + n = SMB_STRDUP(name); + n[strlen(n)-1] = 0; + if (asprintf(&s, "%s%s", n, finfo->name) == -1) { + free(n); + printf("asprintf failed\n"); + return NT_STATUS_NO_MEMORY; + } + if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) { + char *s2; + if (asprintf(&s2, "%s\\*", s) == -1) { + printf("asprintf failed\n"); + free(s); + free(n); + return NT_STATUS_NO_MEMORY; + } + status = cli_list(c, s2, FILE_ATTRIBUTE_DIRECTORY, delete_fn, NULL); + free(s2); + if (!NT_STATUS_IS_OK(status)) { + free(s); + free(n); + return status; + } + nb_rmdir(s); + } else { + total_deleted++; + nb_unlink(s); + } + free(s); + free(n); + return NT_STATUS_OK; +} + +void nb_deltree(const char *dname) +{ + char *mask; + if (asprintf(&mask, "%s\\*", dname) == -1) { + printf("asprintf failed\n"); + return; + } + + total_deleted = 0; + cli_list(c, mask, FILE_ATTRIBUTE_DIRECTORY, delete_fn, NULL); + free(mask); + cli_rmdir(c, dname); + + if (total_deleted) printf("WARNING: Cleaned up %d files\n", total_deleted); +} + + +void nb_cleanup(void) +{ + cli_rmdir(c, "clients"); + children[nbio_id].done = 1; +} diff --git a/source3/torture/pdbtest.c b/source3/torture/pdbtest.c new file mode 100644 index 0000000..d153f3e --- /dev/null +++ b/source3/torture/pdbtest.c @@ -0,0 +1,736 @@ +/* + Unix SMB/CIFS implementation. + passdb testing utility + + Copyright (C) Wilco Baan Hofman 2006 + Copyright (C) Jelmer Vernooij 2006 + Copyright (C) Andrew Bartlett 2012 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + + +#include "includes.h" +#include "lib/cmdline/cmdline.h" +#include "passdb.h" + +#include "../librpc/gen_ndr/drsblobs.h" +#include "../librpc/gen_ndr/ndr_drsblobs.h" +#include "../libcli/security/dom_sid.h" +#include "../libcli/auth/libcli_auth.h" +#include "../auth/common_auth.h" +#include "lib/tsocket/tsocket.h" +#include "include/auth.h" +#include "nsswitch/libwbclient/wbclient.h" +#include "auth/auth_sam_reply.h" + +#define TRUST_DOM "trustdom" +#define TRUST_PWD "trustpwd1232" +#define TRUST_SID "S-1-5-21-1111111111-2222222222-3333333333" + +static bool samu_correct(struct samu *s1, struct samu *s2) +{ + bool ret = True; + uint32_t s1_len, s2_len; + const char *s1_buf, *s2_buf; + const uint8_t *d1_buf, *d2_buf; + const struct dom_sid *s1_sid, *s2_sid; + + /* Check Unix username */ + s1_buf = pdb_get_username(s1); + s2_buf = pdb_get_username(s2); + if (s2_buf == NULL && s1_buf != NULL) { + DEBUG(0, ("Username is not set\n")); + ret = False; + } else if (s1_buf == NULL) { + /* Do nothing */ + } else if (strcmp(s1_buf,s2_buf)) { + DEBUG(0, ("Username not written correctly, want %s, got \"%s\"\n", + pdb_get_username(s1), + pdb_get_username(s2))); + ret = False; + } + + /* Check NT username */ + s1_buf = pdb_get_nt_username(s1); + s2_buf = pdb_get_nt_username(s2); + if (s2_buf == NULL && s1_buf != NULL) { + DEBUG(0, ("NT Username is not set\n")); + ret = False; + } else if (s1_buf == NULL) { + /* Do nothing */ + } else if (strcmp(s1_buf, s2_buf)) { + DEBUG(0, ("NT Username not written correctly, want \"%s\", got \"%s\"\n", + pdb_get_nt_username(s1), + pdb_get_nt_username(s2))); + ret = False; + } + + /* Check acct ctrl */ + if (pdb_get_acct_ctrl(s1) != pdb_get_acct_ctrl(s2)) { + DEBUG(0, ("Acct ctrl field not written correctly, want %d (0x%X), got %d (0x%X)\n", + pdb_get_acct_ctrl(s1), + pdb_get_acct_ctrl(s1), + pdb_get_acct_ctrl(s2), + pdb_get_acct_ctrl(s2))); + ret = False; + } + + /* Check NT password */ + d1_buf = pdb_get_nt_passwd(s1); + d2_buf = pdb_get_nt_passwd(s2); + if (d2_buf == NULL && d1_buf != NULL) { + DEBUG(0, ("NT password is not set\n")); + ret = False; + } else if (d1_buf == NULL) { + /* Do nothing */ + } else if (memcmp(d1_buf, d2_buf, NT_HASH_LEN)) { + DEBUG(0, ("NT password not written correctly\n")); + ret = False; + } + + /* Check lanman password */ + d1_buf = pdb_get_lanman_passwd(s1); + d2_buf = pdb_get_lanman_passwd(s2); + if (d2_buf == NULL && d1_buf != NULL) { + DEBUG(0, ("Lanman password is not set\n")); + } else if (d1_buf == NULL) { + /* Do nothing */ + } else if (memcmp(d1_buf, d2_buf, NT_HASH_LEN)) { + DEBUG(0, ("Lanman password not written correctly\n")); + ret = False; + } + + /* Check password history */ + d1_buf = pdb_get_pw_history(s1, &s1_len); + d2_buf = pdb_get_pw_history(s2, &s2_len); + if (d2_buf == NULL && d1_buf != NULL) { + DEBUG(0, ("Password history is not set\n")); + } else if (d1_buf == NULL) { + /* Do nothing */ + } else if (s1_len != s2_len) { + DEBUG(0, ("Password history not written correctly, lengths differ, want %d, got %d\n", + s1_len, s2_len)); + ret = False; + } else if (strncmp(s1_buf, s2_buf, s1_len)) { + DEBUG(0, ("Password history not written correctly\n")); + ret = False; + } + + /* Check logon time */ + if (pdb_get_logon_time(s1) != pdb_get_logon_time(s2)) { + DEBUG(0, ("Logon time is not written correctly\n")); + ret = False; + } + + /* Check logoff time */ + if (pdb_get_logoff_time(s1) != pdb_get_logoff_time(s2)) { + DEBUG(0, ("Logoff time is not written correctly: %s vs %s \n", + http_timestring(talloc_tos(), pdb_get_logoff_time(s1)), + http_timestring(talloc_tos(), pdb_get_logoff_time(s2)))); + ret = False; + } + + /* Check kickoff time */ + if (pdb_get_kickoff_time(s1) != pdb_get_kickoff_time(s2)) { + DEBUG(0, ("Kickoff time is not written correctly: %s vs %s \n", + http_timestring(talloc_tos(), pdb_get_kickoff_time(s1)), + http_timestring(talloc_tos(), pdb_get_kickoff_time(s2)))); + ret = False; + } + + /* Check bad password time */ + if (pdb_get_bad_password_time(s1) != pdb_get_bad_password_time(s2)) { + DEBUG(0, ("Bad password time is not written correctly\n")); + ret = False; + } + + /* Check password last set time */ + if (pdb_get_pass_last_set_time(s1) != pdb_get_pass_last_set_time(s2)) { + DEBUG(0, ("Password last set time is not written correctly: %s vs %s \n", + http_timestring(talloc_tos(), pdb_get_pass_last_set_time(s1)), + http_timestring(talloc_tos(), pdb_get_pass_last_set_time(s2)))); + ret = False; + } + + /* Check password can change time */ + if (pdb_get_pass_can_change_time(s1) != pdb_get_pass_can_change_time(s2)) { + DEBUG(0, ("Password can change time is not written correctly %s vs %s \n", + http_timestring(talloc_tos(), pdb_get_pass_can_change_time(s1)), + http_timestring(talloc_tos(), pdb_get_pass_can_change_time(s2)))); + ret = False; + } + + /* Check password must change time */ + if (pdb_get_pass_must_change_time(s1) != pdb_get_pass_must_change_time(s2)) { + DEBUG(0, ("Password must change time is not written correctly\n")); + ret = False; + } + + /* Check logon divs */ + if (pdb_get_logon_divs(s1) != pdb_get_logon_divs(s2)) { + DEBUG(0, ("Logon divs not written correctly\n")); + ret = False; + } + + /* Check logon hours */ + if (pdb_get_hours_len(s1) != pdb_get_hours_len(s2)) { + DEBUG(0, ("Logon hours length not written correctly\n")); + ret = False; + } else if (pdb_get_hours_len(s1) != 0) { + d1_buf = pdb_get_hours(s1); + d2_buf = pdb_get_hours(s2); + if (d2_buf == NULL && d1_buf != NULL) { + DEBUG(0, ("Logon hours is not set\n")); + ret = False; + } else if (d1_buf == NULL) { + /* Do nothing */ + } else if (memcmp(d1_buf, d2_buf, MAX_HOURS_LEN)) { + DEBUG(0, ("Logon hours is not written correctly\n")); + ret = False; + } + } + + /* Check profile path */ + s1_buf = pdb_get_profile_path(s1); + s2_buf = pdb_get_profile_path(s2); + if (s2_buf == NULL && s1_buf != NULL) { + DEBUG(0, ("Profile path is not set\n")); + ret = False; + } else if (s1_buf == NULL) { + /* Do nothing */ + } else if (strcmp(s1_buf, s2_buf)) { + DEBUG(0, ("Profile path is not written correctly\n")); + ret = False; + } + + /* Check home dir */ + s1_buf = pdb_get_homedir(s1); + s2_buf = pdb_get_homedir(s2); + if (s2_buf == NULL && s1_buf != NULL) { + DEBUG(0, ("Home dir is not set\n")); + ret = False; + } else if (s1_buf == NULL) { + /* Do nothing */ + } else if (strcmp(s1_buf, s2_buf)) { + DEBUG(0, ("Home dir is not written correctly\n")); + ret = False; + } + + /* Check logon script */ + s1_buf = pdb_get_logon_script(s1); + s2_buf = pdb_get_logon_script(s2); + if (s2_buf == NULL && s1_buf != NULL) { + DEBUG(0, ("Logon script not set\n")); + ret = False; + } else if (s1_buf == NULL) { + /* Do nothing */ + } else if (strcmp(s1_buf, s2_buf)) { + DEBUG(0, ("Logon script is not written correctly\n")); + ret = False; + } + + /* Check user and group sids */ + s1_sid = pdb_get_user_sid(s1); + s2_sid = pdb_get_user_sid(s2); + if (s2_sid == NULL && s1_sid != NULL) { + DEBUG(0, ("USER SID not set\n")); + ret = False; + } else if (s1_sid == NULL) { + /* Do nothing */ + } else if (!dom_sid_equal(s1_sid, s2_sid)) { + DEBUG(0, ("USER SID is not written correctly\n")); + ret = False; + } + + return ret; +} + +static bool test_auth(TALLOC_CTX *mem_ctx, struct samu *pdb_entry) +{ + struct auth_usersupplied_info *user_info; + struct auth_context *auth_context; + static const uint8_t challenge_8[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + DATA_BLOB challenge = data_blob_const(challenge_8, sizeof(challenge_8)); + struct tsocket_address *remote_address; + struct tsocket_address *local_address; + unsigned char local_nt_response[24]; + DATA_BLOB nt_resp = data_blob_const(local_nt_response, sizeof(local_nt_response)); + unsigned char local_nt_session_key[16]; + struct netr_SamInfo3 *info3_sam, *info3_auth; + struct auth_serversupplied_info *server_info; + struct wbcAuthUserParams params = { .flags = 0 }; + struct wbcAuthUserInfo *info = NULL; + struct wbcAuthErrorInfo *err = NULL; + wbcErr wbc_status; + struct netr_SamInfo6 *info6_wbc = NULL; + NTSTATUS status; + bool ok; + uint8_t authoritative = 1; + int rc; + + rc = SMBOWFencrypt(pdb_get_nt_passwd(pdb_entry), challenge_8, + local_nt_response); + if (rc != 0) { + return False; + } + + SMBsesskeygen_ntv1(pdb_get_nt_passwd(pdb_entry), local_nt_session_key); + + if (tsocket_address_inet_from_strings(NULL, "ip", NULL, 0, &remote_address) != 0) { + return False; + } + + if (tsocket_address_inet_from_strings(NULL, "ip", NULL, 0, &local_address) != 0) { + return False; + } + + status = make_user_info(mem_ctx, + &user_info, pdb_get_username(pdb_entry), pdb_get_username(pdb_entry), + pdb_get_domain(pdb_entry), pdb_get_domain(pdb_entry), lp_netbios_name(), + remote_address,local_address, "pdbtest", + NULL, &nt_resp, NULL, NULL, NULL, + AUTH_PASSWORD_RESPONSE); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Failed to test authentication with check_sam_security_info3: %s\n", nt_errstr(status))); + return False; + } + + status = check_sam_security_info3(&challenge, NULL, user_info, &info3_sam); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Failed to test authentication with check_sam_security_info3: %s\n", nt_errstr(status))); + return False; + } + + if (memcmp(info3_sam->base.key.key, local_nt_session_key, 16) != 0) { + DEBUG(0, ("Returned NT session key is incorrect\n")); + return False; + } + + status = make_auth3_context_for_ntlm(NULL, &auth_context); + + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Failed to test authentication with check_sam_security_info3: %s\n", nt_errstr(status))); + return False; + } + + ok = auth3_context_set_challenge( + auth_context, challenge.data, "fixed"); + if (!ok) { + DBG_ERR("auth3_context_set_challenge failed\n"); + return false; + } + + status = auth_check_ntlm_password(mem_ctx, + auth_context, + user_info, + &server_info, + &authoritative); + + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Failed to test authentication with auth module: " + "%s authoritative[%u].\n", + nt_errstr(status), authoritative)); + return False; + } + + info3_auth = talloc_zero(mem_ctx, struct netr_SamInfo3); + if (info3_auth == NULL) { + return False; + } + + status = serverinfo_to_SamInfo3(server_info, info3_auth); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("serverinfo_to_SamInfo3 failed: %s\n", + nt_errstr(status))); + return False; + } + + if (memcmp(info3_auth->base.key.key, local_nt_session_key, 16) != 0) { + DEBUG(0, ("Returned NT session key is incorrect\n")); + return False; + } + + if (!dom_sid_equal(info3_sam->base.domain_sid, info3_auth->base.domain_sid)) { + struct dom_sid_buf buf1, buf2; + DEBUG(0, ("domain_sid in SAM info3 %s does not match domain_sid in AUTH info3 %s\n", + dom_sid_str_buf(info3_sam->base.domain_sid, &buf1), + dom_sid_str_buf(info3_auth->base.domain_sid, + &buf2))); + return False; + } + + /* TODO: + * Compare more details from the two info3 structures, + * then test that an expired/disabled/pwdmustchange account + * returns the correct errors + */ + + params.parameter_control = user_info->logon_parameters; + params.parameter_control |= WBC_MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT | + WBC_MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT; + params.level = WBC_AUTH_USER_LEVEL_RESPONSE; + + params.account_name = user_info->client.account_name; + params.domain_name = user_info->client.domain_name; + params.workstation_name = user_info->workstation_name; + + memcpy(params.password.response.challenge, + challenge.data, + sizeof(params.password.response.challenge)); + + params.password.response.lm_length = + user_info->password.response.lanman.length; + params.password.response.nt_length = + user_info->password.response.nt.length; + + params.password.response.lm_data = + user_info->password.response.lanman.data; + params.password.response.nt_data = + user_info->password.response.nt.data; + + wbc_status = wbcAuthenticateUserEx(¶ms, &info, &err); + if (wbc_status != WBC_ERR_WINBIND_NOT_AVAILABLE) { + if (wbc_status == WBC_ERR_AUTH_ERROR) { + if (err) { + DEBUG(1, ("error was %s (0x%08x)\nerror message was '%s'\n", + err->nt_string, err->nt_status, err->display_string)); + status = NT_STATUS(err->nt_status); + wbcFreeMemory(err); + } else { + status = NT_STATUS_LOGON_FAILURE; + } + if (!NT_STATUS_IS_OK(status)) { + return false; + } + } else if (!WBC_ERROR_IS_OK(wbc_status)) { + DEBUG(1, ("wbcAuthenticateUserEx: failed with %u - %s\n", + wbc_status, wbcErrorString(wbc_status))); + if (err) { + DEBUG(1, ("error was %s (0x%08x)\nerror message was '%s'\n", + err->nt_string, err->nt_status, err->display_string)); + } + return false; + } + info6_wbc = wbcAuthUserInfo_to_netr_SamInfo6(mem_ctx, info); + wbcFreeMemory(info); + if (!info6_wbc) { + DEBUG(1, ("wbcAuthUserInfo_to_netr_SamInfo6 failed\n")); + return false; + } + + if (memcmp(info6_wbc->base.key.key, local_nt_session_key, 16) != 0) { + DEBUG(0, ("Returned NT session key is incorrect\n")); + return false; + } + + if (!dom_sid_equal(info3_sam->base.domain_sid, info6_wbc->base.domain_sid)) { + struct dom_sid_buf buf1, buf2; + DEBUG(0, ("domain_sid in SAM info3 %s does not match domain_sid in AUTH info3 %s\n", + dom_sid_str_buf(info3_sam->base.domain_sid, + &buf1), + dom_sid_str_buf(info6_wbc->base.domain_sid, + &buf2))); + return false; + } + } + + return True; +} + +static bool test_trusted_domains(TALLOC_CTX *ctx, + struct pdb_methods *pdb, + bool *error) +{ + NTSTATUS rv; + /* test trustdom calls */ + struct pdb_trusted_domain *td; + struct pdb_trusted_domain *new_td; + struct trustAuthInOutBlob taiob; + struct AuthenticationInformation aia; + enum ndr_err_code ndr_err; + bool ok; + + td = talloc_zero(ctx ,struct pdb_trusted_domain); + if (!td) { + fprintf(stderr, "talloc failed\n"); + return false; + } + + td->domain_name = talloc_strdup(td, TRUST_DOM); + td->netbios_name = talloc_strdup(td, TRUST_DOM); + if (!td->domain_name || !td->netbios_name) { + fprintf(stderr, "talloc failed\n"); + return false; + } + ok = dom_sid_parse("S-1-5-21-123-456-789", &td->security_identifier); + if (!ok) { + fprintf(stderr, "dom_sid_parse S-1-5-21-123-456-789 failed\n"); + return false; + } + + td->trust_auth_incoming = data_blob_null; + + ZERO_STRUCT(taiob); + ZERO_STRUCT(aia); + taiob.count = 1; + taiob.current.count = 1; + taiob.current.array = &aia; + unix_to_nt_time(&aia.LastUpdateTime, time(NULL)); + aia.AuthType = TRUST_AUTH_TYPE_CLEAR; + aia.AuthInfo.clear.password = (uint8_t *) talloc_strdup(ctx, TRUST_PWD); + aia.AuthInfo.clear.size = strlen(TRUST_PWD); + + taiob.previous.count = 0; + taiob.previous.array = NULL; + + ndr_err = ndr_push_struct_blob(&td->trust_auth_outgoing, + td, &taiob, + (ndr_push_flags_fn_t) ndr_push_trustAuthInOutBlob); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + fprintf(stderr, "ndr_push_struct_blob failed.\n"); + return false; + } + + td->trust_direction = LSA_TRUST_DIRECTION_OUTBOUND; + td->trust_type = LSA_TRUST_TYPE_DOWNLEVEL; + td->trust_attributes = 0; + td->trust_forest_trust_info = data_blob_null; + + rv = pdb->set_trusted_domain(pdb, TRUST_DOM, td); + if (!NT_STATUS_IS_OK(rv)) { + fprintf(stderr, "Error in set_trusted_domain %s\n", + get_friendly_nt_error_msg(rv)); + *error = true; + } + + rv = pdb->get_trusted_domain(pdb, ctx, TRUST_DOM, &new_td); + if (!NT_STATUS_IS_OK(rv)) { + fprintf(stderr, "Error in get_trusted_domain %s\n", + get_friendly_nt_error_msg(rv)); + *error = true; + } + + if (!strequal(td->domain_name, new_td->domain_name) || + !strequal(td->netbios_name, new_td->netbios_name) || + !dom_sid_equal(&td->security_identifier, + &new_td->security_identifier) || + td->trust_direction != new_td->trust_direction || + td->trust_type != new_td->trust_type || + td->trust_attributes != new_td->trust_attributes || + td->trust_auth_incoming.length != new_td->trust_auth_incoming.length || + td->trust_forest_trust_info.length != new_td->trust_forest_trust_info.length || + data_blob_cmp(&td->trust_auth_outgoing, &new_td->trust_auth_outgoing) != 0) { + fprintf(stderr, "Old and new trusdet domain data do not match\n"); + *error = true; + } + + rv = pdb->del_trusted_domain(pdb, TRUST_DOM); + if (!NT_STATUS_IS_OK(rv)) { + fprintf(stderr, "Error in del_trusted_domain %s\n", + get_friendly_nt_error_msg(rv)); + *error = true; + } + + return true; +} + + +int main(int argc, const char **argv) +{ + TALLOC_CTX *ctx; + struct samu *out = NULL; + struct samu *in = NULL; + NTSTATUS rv; + int i; + int opt; + struct timeval tv; + bool error = False; + struct passwd *pwd; + uint8_t *buf; + uint32_t expire, min_age, history; + struct pdb_methods *pdb; + poptContext pc; + static const char *backend = NULL; + static const char *unix_user = "nobody"; + bool ok; + struct poptOption long_options[] = { + {"username", 'u', POPT_ARG_STRING, &unix_user, 0, "Unix user to use for testing", "USERNAME" }, + {"backend", 'b', POPT_ARG_STRING, &backend, 0, "Backend to use if not default", "BACKEND[:SETTINGS]" }, + POPT_AUTOHELP + POPT_COMMON_SAMBA + POPT_COMMON_VERSION + POPT_TABLEEND + }; + + ctx = talloc_stackframe(); + + smb_init_locale(); + + ok = samba_cmdline_init(ctx, + SAMBA_CMDLINE_CONFIG_CLIENT, + true /* require_smbconf */); + if (!ok) { + TALLOC_FREE(ctx); + exit(1); + } + + pc = samba_popt_get_context(getprogname(), argc, argv, long_options, 0); + if (pc == NULL) { + TALLOC_FREE(ctx); + exit(1); + } + + poptSetOtherOptionHelp(pc, "backend[:settings] username"); + + while ((opt = poptGetNextOpt(pc)) != -1) { + switch (opt) { + case POPT_ERROR_BADOPT: + fprintf(stderr, "\nInvalid option %s: %s\n\n", + poptBadOption(pc, 0), poptStrerror(opt)); + poptPrintUsage(pc, stderr, 0); + exit(1); + } + } + + poptFreeContext(pc); + + if (backend == NULL) { + backend = lp_passdb_backend(); + } + + rv = make_pdb_method_name(&pdb, backend); + if (NT_STATUS_IS_ERR(rv)) { + fprintf(stderr, "Error initializing '%s': %s\n", backend, get_friendly_nt_error_msg(rv)); + exit(1); + } + + if (!(out = samu_new(ctx))) { + fprintf(stderr, "Can't create samu structure.\n"); + exit(1); + } + + if ((pwd = Get_Pwnam_alloc(ctx, unix_user)) == NULL) { + fprintf(stderr, "Error getting user information for %s\n", unix_user); + exit(1); + } + + samu_set_unix(out, pwd); + + pdb_set_profile_path(out, "\\\\torture\\profile", PDB_SET); + pdb_set_homedir(out, "\\\\torture\\home", PDB_SET); + pdb_set_logon_script(out, "torture_script.cmd", PDB_SET); + + pdb_set_acct_ctrl(out, ACB_NORMAL, PDB_SET); + + pdb_get_account_policy(PDB_POLICY_PASSWORD_HISTORY, &history); + if (history * PW_HISTORY_ENTRY_LEN < NT_HASH_LEN) { + buf = (uint8_t *)TALLOC(ctx, NT_HASH_LEN); + } else { + buf = (uint8_t *)TALLOC(ctx, history * PW_HISTORY_ENTRY_LEN); + } + + /* Generate some random hashes */ + GetTimeOfDay(&tv); + srand(tv.tv_usec); + for (i = 0; i < NT_HASH_LEN; i++) { + buf[i] = (uint8_t) rand(); + } + pdb_set_nt_passwd(out, buf, PDB_SET); + for (i = 0; i < LM_HASH_LEN; i++) { + buf[i] = (uint8_t) rand(); + } + pdb_set_lanman_passwd(out, buf, PDB_SET); + for (i = 0; i < history * PW_HISTORY_ENTRY_LEN; i++) { + buf[i] = (uint8_t) rand(); + } + pdb_set_pw_history(out, buf, history, PDB_SET); + + pdb_get_account_policy(PDB_POLICY_MAX_PASSWORD_AGE, &expire); + pdb_get_account_policy(PDB_POLICY_MIN_PASSWORD_AGE, &min_age); + pdb_set_pass_last_set_time(out, time(NULL), PDB_SET); + + if (min_age == (uint32_t)-1) { + pdb_set_pass_can_change_time(out, 0, PDB_SET); + } else { + pdb_set_pass_can_change_time(out, time(NULL)+min_age, PDB_SET); + } + + pdb_set_logon_time(out, time(NULL)-3600, PDB_SET); + + pdb_set_logoff_time(out, time(NULL), PDB_SET); + + pdb_set_kickoff_time(out, time(NULL)+3600, PDB_SET); + + /* Create account */ + if (!NT_STATUS_IS_OK(rv = pdb->add_sam_account(pdb, out))) { + fprintf(stderr, "Error in add_sam_account: %s\n", + get_friendly_nt_error_msg(rv)); + exit(1); + } + + if (!(in = samu_new(ctx))) { + fprintf(stderr, "Can't create samu structure.\n"); + exit(1); + } + + /* Get account information through getsampwnam() */ + rv = pdb->getsampwnam(pdb, in, out->username); + if (NT_STATUS_IS_ERR(rv)) { + fprintf(stderr, "Error getting sampw of added user %s: %s\n", + out->username, nt_errstr(rv)); + if (!NT_STATUS_IS_OK(rv = pdb->delete_sam_account(pdb, out))) { + fprintf(stderr, "Error in delete_sam_account %s\n", + get_friendly_nt_error_msg(rv)); + } + TALLOC_FREE(ctx); + exit(1); + } + + /* Verify integrity */ + if (samu_correct(out, in)) { + printf("User info written correctly\n"); + } else { + printf("User info NOT written correctly\n"); + error = True; + } + + if (test_auth(ctx, out)) { + printf("Authentication module test passed\n"); + } else { + printf("Authentication module test failed!\n"); + error = True; + } + + + /* Delete account */ + if (!NT_STATUS_IS_OK(rv = pdb->delete_sam_account(pdb, out))) { + fprintf(stderr, "Error in delete_sam_account %s\n", + get_friendly_nt_error_msg(rv)); + } + + if (pdb_capabilities() & PDB_CAP_TRUSTED_DOMAINS_EX) { + if (!test_trusted_domains(ctx, pdb, &error)) { + fprintf(stderr, "failed testing trusted domains.\n"); + exit(1); + } + } + + TALLOC_FREE(ctx); + + if (error) { + return 1; + } + return 0; +} diff --git a/source3/torture/proto.h b/source3/torture/proto.h new file mode 100644 index 0000000..26b5120 --- /dev/null +++ b/source3/torture/proto.h @@ -0,0 +1,192 @@ +/* + Unix SMB/CIFS implementation. + + SMB torture tester - header file + + Copyright (C) Andrew Tridgell 1997-1998 + Copyright (C) Jeremy Allison 2009 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef __TORTURE_H__ +#define __TORTURE_H__ + +struct cli_state; + +/* The following definitions come from torture/denytest.c */ + +bool torture_denytest1(int dummy); +bool torture_denytest2(int dummy); + +/* The following definitions come from torture/mangle_test.c */ + +bool torture_mangle(int dummy); + +/* The following definitions come from torture/nbio.c */ + +double nbio_total(void); +void nb_alarm(int ignore); +void nbio_shmem(int n); +void nb_setup(struct cli_state *cli); +void nb_unlink(const char *fname); +void nb_createx(const char *fname, + unsigned create_options, unsigned create_disposition, int handle); +void nb_writex(int handle, int offset, int size, int ret_size); +void nb_readx(int handle, int offset, int size, int ret_size); +void nb_close(int handle); +void nb_rmdir(const char *fname); +void nb_rename(const char *oldname, const char *newname); +void nb_qpathinfo(const char *fname); +void nb_qfileinfo(int fnum); +void nb_qfsinfo(int level); +void nb_findfirst(const char *mask); +void nb_flush(int fnum); +void nb_deltree(const char *dname); +void nb_cleanup(void); + +/* The following definitions come from torture/scanner.c */ + +bool torture_trans2_scan(int dummy); +bool torture_nttrans_scan(int dummy); + +/* The following definitions come from torture/torture.c */ + +bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx, + char **hostname, char **sharename); +bool torture_open_connection_flags(struct cli_state **c, int conn_index, int flags); +bool torture_open_connection(struct cli_state **c, int conn_index); +bool torture_init_connection(struct cli_state **pcli); +bool torture_cli_session_setup2(struct cli_state *cli, uint16_t *new_vuid); +bool torture_close_connection(struct cli_state *c); +bool torture_ioctl_test(int dummy); +bool torture_chkpath_test(int dummy); +NTSTATUS torture_setup_unix_extensions(struct cli_state *cli); +void torture_conn_set_sockopt(struct cli_state *cli); +void torture_deltree(struct cli_state *cli, const char *dname); + +NTSTATUS cli_qpathinfo1(struct cli_state *cli, + const char *fname, + time_t *change_time, + time_t *access_time, + time_t *write_time, + off_t *size, + uint32_t *pattr); + +/* The following definitions come from torture/utable.c */ + +bool torture_utable(int dummy); +bool torture_casetable(int dummy); + +/* + * Misc + */ + +bool run_posix_append(int dummy); +bool run_posix_ls_wildcard_test(int dummy); +bool run_posix_ls_single_test(int dummy); +bool run_posix_readlink_test(int dummy); +bool run_posix_stat_test(int dummy); +bool run_posix_symlink_parent_test(int dummy); +bool run_posix_symlink_chmod_test(int dummy); +bool run_posix_dir_default_acl_test(int dummy); +bool run_case_insensitive_create(int dummy); +bool run_posix_symlink_rename_test(int dummy); +bool run_posix_symlink_getpathinfo_test(int dummy); +bool run_posix_symlink_setpathinfo_test(int dummy); + +bool run_nbench2(int dummy); +bool run_async_echo(int dummy); +bool run_smb_any_connect(int dummy); +bool run_addrchange(int dummy); +bool run_str_match_mswild(int dummy); +bool run_str_match_regex_sub1(int dummy); +bool run_notify_online(int dummy); +bool run_nttrans_create(int dummy); +bool run_nttrans_fsctl(int dummy); +bool run_smb2_basic(int dummy); +bool run_smb2_negprot(int dummy); +bool run_smb2_anonymous(int dummy); +bool run_smb2_session_reconnect(int dummy); +bool run_smb2_tcon_dependence(int dummy); +bool run_smb2_multi_channel(int dummy); +bool run_smb2_session_reauth(int dummy); +bool run_smb2_ftruncate(int dummy); +bool run_smb2_dir_fsync(int dummy); +bool run_smb2_path_slash(int dummy); +bool run_smb2_sacl(int dummy); +bool run_smb2_quota1(int dummy); +bool run_smb2_stream_acl(int dummy); +bool run_smb2_dfs_paths(int dummy); +bool run_smb2_non_dfs_share(int dummy); +bool run_smb2_dfs_share_non_dfs_path(int dummy); +bool run_smb2_dfs_filename_leading_backslash(int dummy); +bool run_smb2_pipe_read_async_disconnect(int dummy); +bool run_smb2_invalid_pipename(int dummy); +bool run_smb1_dfs_paths(int dummy); +bool run_smb1_dfs_search_paths(int dummy); +bool run_smb1_dfs_operations(int dummy); +bool run_smb1_dfs_check_badpath(int dummy); +bool run_list_dir_async_test(int dummy); +bool run_delete_on_close_non_empty(int dummy); +bool run_delete_on_close_nonwrite_delete_yes_test(int dummy); +bool run_delete_on_close_nonwrite_delete_no_test(int dummy); +bool run_chain3(int dummy); +bool run_local_conv_auth_info(int dummy); +bool run_local_sprintf_append(int dummy); +bool run_cleanup1(int dummy); +bool run_cleanup2(int dummy); +bool run_cleanup4(int dummy); +bool run_notify_bench2(int dummy); +bool run_notify_bench3(int dummy); +bool run_dbwrap_watch1(int dummy); +bool run_dbwrap_watch2(int dummy); +bool run_dbwrap_watch3(int dummy); +bool run_dbwrap_watch4(int dummy); +bool run_dbwrap_do_locked1(int dummy); +bool run_idmap_tdb_common_test(int dummy); +bool run_local_dbwrap_ctdb1(int dummy); +bool run_qpathinfo_bufsize(int dummy); +bool run_bench_pthreadpool(int dummy); +bool run_messaging_read1(int dummy); +bool run_messaging_read2(int dummy); +bool run_messaging_read3(int dummy); +bool run_messaging_read4(int dummy); +bool run_messaging_fdpass1(int dummy); +bool run_messaging_fdpass2(int dummy); +bool run_messaging_fdpass2a(int dummy); +bool run_messaging_fdpass2b(int dummy); +bool run_messaging_send_all(int dummy); +bool run_oplock_cancel(int dummy); +bool run_pthreadpool_tevent(int dummy); +bool run_g_lock1(int dummy); +bool run_g_lock2(int dummy); +bool run_g_lock3(int dummy); +bool run_g_lock4(int dummy); +bool run_g_lock4a(int dummy); +bool run_g_lock5(int dummy); +bool run_g_lock6(int dummy); +bool run_g_lock7(int dummy); +bool run_g_lock8(int dummy); +bool run_g_lock_ping_pong(int dummy); +bool run_local_namemap_cache1(int dummy); +bool run_local_idmap_cache1(int dummy); +bool run_hidenewfiles(int dummy); +bool run_hidenewfiles_showdirs(int dummy); +bool run_readdir_timestamp(int dummy); +bool run_ctdbd_conn1(int dummy); +bool run_rpc_scale(int dummy); +bool run_tdb_validate(int dummy); + +#endif /* __TORTURE_H__ */ diff --git a/source3/torture/scanner.c b/source3/torture/scanner.c new file mode 100644 index 0000000..ad44f33 --- /dev/null +++ b/source3/torture/scanner.c @@ -0,0 +1,515 @@ +/* + Unix SMB/CIFS implementation. + SMB torture tester - scanning functions + Copyright (C) Andrew Tridgell 2001 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "system/filesys.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "../libcli/smb/smbXcli_base.h" + +#define VERBOSE 0 +#define OP_MIN 0 +#define OP_MAX 20 + +#define DATA_SIZE 1024 +#define PARAM_SIZE 1024 + +/**************************************************************************** +look for a partial hit +****************************************************************************/ +static void trans2_check_hit(const char *format, int op, int level, NTSTATUS status) +{ + if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_LEVEL) || + NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_IMPLEMENTED) || + NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_SUPPORTED) || + NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL) || + NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_INFO_CLASS)) { + return; + } +#if VERBOSE + printf("possible %s hit op=%3d level=%5d status=%s\n", + format, op, level, nt_errstr(status)); +#endif +} + +/**************************************************************************** +check for existence of a trans2 call +****************************************************************************/ +static NTSTATUS try_trans2(struct cli_state *cli, + int op, + uint8_t *param, uint8_t *data, + uint32_t param_len, uint32_t data_len, + uint32_t *rparam_len, uint32_t *rdata_len) +{ + uint16_t setup[1]; + uint8_t *rparam=NULL, *rdata=NULL; + NTSTATUS status; + + SSVAL(setup+0, 0, op); + + status = cli_trans(talloc_tos(), cli, SMBtrans2, + NULL, -1, /* name, fid */ + op, 0, + NULL, 0, 0, /* setup */ + param, param_len, 2, + data, data_len, CLI_BUFFER_SIZE, + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup */ + &rparam, 0, rparam_len, + &rdata, 0, rdata_len); + + TALLOC_FREE(rdata); + TALLOC_FREE(rparam); + + return status; +} + + +static NTSTATUS try_trans2_len(struct cli_state *cli, + const char *format, + int op, int level, + uint8_t *param, uint8_t *data, + uint32_t param_len, uint32_t *data_len, + uint32_t *rparam_len, uint32_t *rdata_len) +{ + NTSTATUS ret=NT_STATUS_OK; + + ret = try_trans2(cli, op, param, data, param_len, + DATA_SIZE, rparam_len, rdata_len); +#if VERBOSE + printf("op=%d level=%d ret=%s\n", op, level, nt_errstr(ret)); +#endif + if (!NT_STATUS_IS_OK(ret)) return ret; + + *data_len = 0; + while (*data_len < DATA_SIZE) { + ret = try_trans2(cli, op, param, data, param_len, + *data_len, rparam_len, rdata_len); + if (NT_STATUS_IS_OK(ret)) break; + *data_len += 2; + } + if (NT_STATUS_IS_OK(ret)) { + printf("found %s level=%d data_len=%d rparam_len=%d rdata_len=%d\n", + format, level, *data_len, *rparam_len, *rdata_len); + } else { + trans2_check_hit(format, op, level, ret); + } + return ret; +} + +/**************************************************************************** +check for existence of a trans2 call +****************************************************************************/ +static bool scan_trans2(struct cli_state *cli, int op, int level, + int fnum, int dnum, const char *fname) +{ + uint32_t data_len = 0; + uint32_t param_len = 0; + uint32_t rparam_len, rdata_len; + uint8_t *param = NULL; + uint8_t data[DATA_SIZE]; + const char *newfname; + const char *dname; + NTSTATUS status; + + memset(data, 0, sizeof(data)); + data_len = 4; + + /* try with a info level only */ + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 2); + if (param == NULL) return True; + + SSVAL(param, 0, level); + + param_len = talloc_get_size(param); + status = try_trans2_len(cli, "void", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + if (NT_STATUS_IS_OK(status)) return True; + + /* try with a file descriptor */ + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 6); + if (param == NULL) return True; + + SSVAL(param, 0, fnum); + SSVAL(param, 2, level); + SSVAL(param, 4, 0); + + param_len = talloc_get_size(param); + status = try_trans2_len(cli, "fnum", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + if (NT_STATUS_IS_OK(status)) return True; + + + /* try with a notify style */ + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 6); + if (param == NULL) return True; + + SSVAL(param, 0, dnum); + SSVAL(param, 2, dnum); + SSVAL(param, 4, level); + + param_len = talloc_get_size(param); + status = try_trans2_len(cli, "notify", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + if (NT_STATUS_IS_OK(status)) return True; + + /* try with a file name */ + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 6); + if (param == NULL) return True; + + SSVAL(param, 0, level); + SSVAL(param, 2, 0); + SSVAL(param, 4, 0); + param = trans2_bytes_push_str(param, smbXcli_conn_use_unicode(cli->conn), + fname, strlen(fname)+1, NULL); + if (param == NULL) return True; + + param_len = talloc_get_size(param); + status = try_trans2_len(cli, "fname", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + if (NT_STATUS_IS_OK(status)) return True; + + /* try with a new file name */ + newfname = "\\newfile.dat"; + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 6); + if (param == NULL) return True; + + SSVAL(param, 0, level); + SSVAL(param, 2, 0); + SSVAL(param, 4, 0); + param = trans2_bytes_push_str(param, smbXcli_conn_use_unicode(cli->conn), + newfname, strlen(newfname)+1, NULL); + if (param == NULL) return True; + + param_len = talloc_get_size(param); + status = try_trans2_len(cli, "newfile", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + cli_unlink(cli, newfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_rmdir(cli, newfname); + if (NT_STATUS_IS_OK(status)) return True; + + /* try dfs style */ + dname = "\\testdir"; + cli_mkdir(cli, dname); + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 2); + if (param == NULL) return True; + + SSVAL(param, 0, level); + param = trans2_bytes_push_str(param, smbXcli_conn_use_unicode(cli->conn), + dname, strlen(dname)+1, NULL); + if (param == NULL) return True; + + param_len = talloc_get_size(param); + status = try_trans2_len(cli, "dfs", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + cli_rmdir(cli, dname); + if (NT_STATUS_IS_OK(status)) return True; + + return False; +} + + +bool torture_trans2_scan(int dummy) +{ + static struct cli_state *cli; + int op, level; + const char *fname = "\\scanner.dat"; + uint16_t fnum, dnum; + + printf("starting trans2 scan test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + if (!NT_STATUS_IS_OK(cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, + DENY_NONE, &fnum))) { + printf("open of %s failed\n", fname); + return false; + } + if (!NT_STATUS_IS_OK(cli_openx(cli, "\\", O_RDONLY, DENY_NONE, &dnum))) { + printf("open of \\ failed\n"); + return false; + } + + for (op=OP_MIN; op<=OP_MAX; op++) { + printf("Scanning op=%d\n", op); + for (level = 0; level <= 50; level++) { + scan_trans2(cli, op, level, fnum, dnum, fname); + } + + for (level = 0x100; level <= 0x130; level++) { + scan_trans2(cli, op, level, fnum, dnum, fname); + } + + for (level = 1000; level < 1050; level++) { + scan_trans2(cli, op, level, fnum, dnum, fname); + } + } + + torture_close_connection(cli); + + printf("trans2 scan finished\n"); + return True; +} + + + + +/**************************************************************************** +look for a partial hit +****************************************************************************/ +static void nttrans_check_hit(const char *format, int op, int level, NTSTATUS status) +{ + if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_LEVEL) || + NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_IMPLEMENTED) || + NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_SUPPORTED) || + NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL) || + NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_INFO_CLASS)) { + return; + } +#if VERBOSE + printf("possible %s hit op=%3d level=%5d status=%s\n", + format, op, level, nt_errstr(status)); +#endif +} + +/**************************************************************************** +check for existence of a nttrans call +****************************************************************************/ +static NTSTATUS try_nttrans(struct cli_state *cli, + int op, + uint8_t *param, uint8_t *data, + int32_t param_len, uint32_t data_len, + uint32_t *rparam_len, + uint32_t *rdata_len) +{ + uint8_t *rparam=NULL, *rdata=NULL; + NTSTATUS status; + + status = cli_trans(talloc_tos(), cli, SMBnttrans, + NULL, -1, /* name, fid */ + op, 0, + NULL, 0, 0, /* setup */ + param, param_len, 2, + data, data_len, CLI_BUFFER_SIZE, + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup */ + &rparam, 0, rparam_len, + &rdata, 0, rdata_len); + SAFE_FREE(rdata); + SAFE_FREE(rparam); + + return status; +} + + +static NTSTATUS try_nttrans_len(struct cli_state *cli, + const char *format, + int op, int level, + uint8_t *param, uint8_t *data, + int param_len, uint32_t *data_len, + uint32_t *rparam_len, uint32_t *rdata_len) +{ + NTSTATUS ret=NT_STATUS_OK; + + ret = try_nttrans(cli, op, param, data, param_len, + DATA_SIZE, rparam_len, rdata_len); +#if VERBOSE + printf("op=%d level=%d ret=%s\n", op, level, nt_errstr(ret)); +#endif + if (!NT_STATUS_IS_OK(ret)) return ret; + + *data_len = 0; + while (*data_len < DATA_SIZE) { + ret = try_nttrans(cli, op, param, data, param_len, + *data_len, rparam_len, rdata_len); + if (NT_STATUS_IS_OK(ret)) break; + *data_len += 2; + } + if (NT_STATUS_IS_OK(ret)) { + printf("found %s level=%d data_len=%d rparam_len=%d rdata_len=%d\n", + format, level, *data_len, *rparam_len, *rdata_len); + } else { + nttrans_check_hit(format, op, level, ret); + } + return ret; +} + +/**************************************************************************** +check for existence of a nttrans call +****************************************************************************/ +static bool scan_nttrans(struct cli_state *cli, int op, int level, + int fnum, int dnum, const char *fname) +{ + uint32_t data_len = 0; + uint32_t param_len = 0; + uint32_t rparam_len, rdata_len; + uint8_t *param = NULL; + uint8_t data[DATA_SIZE]; + NTSTATUS status; + const char *newfname; + const char *dname; + + memset(data, 0, sizeof(data)); + data_len = 4; + + /* try with a info level only */ + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 2); + if (param == NULL) return True; + + SSVAL(param, 0, level); + + param_len = talloc_get_size(param); + status = try_nttrans_len(cli, "void", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + if (NT_STATUS_IS_OK(status)) return True; + + /* try with a file descriptor */ + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 6); + if (param == NULL) return True; + + SSVAL(param, 0, fnum); + SSVAL(param, 2, level); + SSVAL(param, 4, 0); + + param_len = talloc_get_size(param); + status = try_nttrans_len(cli, "fnum", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + if (NT_STATUS_IS_OK(status)) return True; + + + /* try with a notify style */ + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 6); + if (param == NULL) return True; + + SSVAL(param, 0, dnum); + SSVAL(param, 2, dnum); + SSVAL(param, 4, level); + + param_len = talloc_get_size(param); + status = try_nttrans_len(cli, "notify", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + if (NT_STATUS_IS_OK(status)) return True; + + /* try with a file name */ + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 6); + if (param == NULL) return True; + + SSVAL(param, 0, level); + SSVAL(param, 2, 0); + SSVAL(param, 4, 0); + param = trans2_bytes_push_str(param, smbXcli_conn_use_unicode(cli->conn), + fname, strlen(fname)+1, NULL); + if (param == NULL) return True; + + param_len = talloc_get_size(param); + status = try_nttrans_len(cli, "fname", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + if (NT_STATUS_IS_OK(status)) return True; + + /* try with a new file name */ + newfname = "\\newfile.dat"; + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 6); + if (param == NULL) return True; + + SSVAL(param, 0, level); + SSVAL(param, 2, 0); + SSVAL(param, 4, 0); + param = trans2_bytes_push_str(param, smbXcli_conn_use_unicode(cli->conn), + newfname, strlen(newfname)+1, NULL); + if (param == NULL) return True; + + param_len = talloc_get_size(param); + status = try_nttrans_len(cli, "newfile", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + cli_unlink(cli, newfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_rmdir(cli, newfname); + if (NT_STATUS_IS_OK(status)) return True; + + /* try dfs style */ + dname = "\\testdir"; + cli_mkdir(cli, dname); + TALLOC_FREE(param); + param = talloc_array(talloc_tos(), uint8_t, 2); + if (param == NULL) return True; + + SSVAL(param, 0, level); + param = trans2_bytes_push_str(param, smbXcli_conn_use_unicode(cli->conn), + dname, strlen(dname)+1, NULL); + if (param == NULL) return True; + + param_len = talloc_get_size(param); + status = try_nttrans_len(cli, "dfs", op, level, param, data, param_len, &data_len, + &rparam_len, &rdata_len); + cli_rmdir(cli, dname); + if (NT_STATUS_IS_OK(status)) return True; + + return False; +} + + +bool torture_nttrans_scan(int dummy) +{ + static struct cli_state *cli; + int op, level; + const char *fname = "\\scanner.dat"; + uint16_t fnum, dnum; + + printf("starting nttrans scan test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, + DENY_NONE, &fnum); + cli_openx(cli, "\\", O_RDONLY, DENY_NONE, &dnum); + + for (op=OP_MIN; op<=OP_MAX; op++) { + printf("Scanning op=%d\n", op); + for (level = 0; level <= 50; level++) { + scan_nttrans(cli, op, level, fnum, dnum, fname); + } + + for (level = 0x100; level <= 0x130; level++) { + scan_nttrans(cli, op, level, fnum, dnum, fname); + } + + for (level = 1000; level < 1050; level++) { + scan_nttrans(cli, op, level, fnum, dnum, fname); + } + } + + torture_close_connection(cli); + + printf("nttrans scan finished\n"); + return True; +} diff --git a/source3/torture/test_addrchange.c b/source3/torture/test_addrchange.c new file mode 100644 index 0000000..9ccca1c --- /dev/null +++ b/source3/torture/test_addrchange.c @@ -0,0 +1,94 @@ +/* + Unix SMB/CIFS implementation. + test for the addrchange functionality + Copyright (C) Volker Lendecke 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "lib/addrchange.h" +#include "lib/util/tevent_ntstatus.h" +#include "proto.h" + +extern int torture_numops; + +bool run_addrchange(int dummy) +{ + struct addrchange_context *ctx; + struct tevent_context *ev; + NTSTATUS status; + int i; + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + d_fprintf(stderr, "tevent_context_init failed\n"); + return false; + } + + status = addrchange_context_create(talloc_tos(), &ctx); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "addrchange_context_create failed: %s\n", + nt_errstr(status)); + return false; + } + + for (i=0; i. +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "rpc_client/cli_pipe.h" +#include "librpc/gen_ndr/ndr_echo_c.h" + +static void rpccli_sleep_done(struct tevent_req *req) +{ + int *done = (int *)tevent_req_callback_data_void(req); + NTSTATUS status; + uint32_t result = UINT32_MAX; + + status = dcerpc_echo_TestSleep_recv(req, talloc_tos(), &result); + TALLOC_FREE(req); + printf("sleep returned %s, %d\n", nt_errstr(status), (int)result); + *done -= 1; +} + +static void cli_echo_done(struct tevent_req *req) +{ + int *done = (int *)tevent_req_callback_data_void(req); + NTSTATUS status; + + status = cli_echo_recv(req); + TALLOC_FREE(req); + printf("echo returned %s\n", nt_errstr(status)); + *done -= 1; +} + +static void write_andx_done(struct tevent_req *req) +{ + int *done = (int *)tevent_req_callback_data_void(req); + NTSTATUS status; + size_t written; + + status = cli_write_andx_recv(req, &written); + TALLOC_FREE(req); + printf("cli_write_andx returned %s\n", nt_errstr(status)); + *done -= 1; +} + +bool run_async_echo(int dummy) +{ + struct cli_state *cli = NULL; + struct rpc_pipe_client *p; + struct dcerpc_binding_handle *b; + struct tevent_context *ev; + struct tevent_req *req; + NTSTATUS status; + bool ret = false; + int i, num_reqs; + uint8_t buf[65536]; + + printf("Starting ASYNC_ECHO\n"); + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + printf("tevent_context_init failed\n"); + goto fail; + } + + if (!torture_open_connection(&cli, 0)) { + printf("torture_open_connection failed\n"); + goto fail; + } + status = cli_rpc_pipe_open_noauth(cli, &ndr_table_rpcecho, + &p); + if (!NT_STATUS_IS_OK(status)) { + printf("Could not open echo pipe: %s\n", nt_errstr(status)); + goto fail; + } + b = p->binding_handle; + + num_reqs = 0; + + req = dcerpc_echo_TestSleep_send(ev, ev, b, 15); + if (req == NULL) { + printf("rpccli_echo_TestSleep_send failed\n"); + goto fail; + } + tevent_req_set_callback(req, rpccli_sleep_done, &num_reqs); + num_reqs += 1; + + req = cli_echo_send(ev, ev, cli, 1, data_blob_const("hello", 5)); + if (req == NULL) { + printf("cli_echo_send failed\n"); + goto fail; + } + tevent_req_set_callback(req, cli_echo_done, &num_reqs); + num_reqs += 1; + + memset(buf, 0, sizeof(buf)); + + for (i=0; i<10; i++) { + req = cli_write_andx_send(ev, ev, cli, 4711, 0, buf, 0, + sizeof(buf)); + if (req == NULL) { + printf("cli_write_andx_send failed\n"); + goto fail; + } + tevent_req_set_callback(req, write_andx_done, &num_reqs); + num_reqs += 1; + + req = cli_echo_send(ev, ev, cli, 1, + data_blob_const("hello", 5)); + if (req == NULL) { + printf("cli_echo_send failed\n"); + goto fail; + } + tevent_req_set_callback(req, cli_echo_done, &num_reqs); + num_reqs += 1; + } + + while (num_reqs > 0) { + if (tevent_loop_once(ev) != 0) { + printf("tevent_loop_once failed\n"); + goto fail; + } + } + + TALLOC_FREE(p); + + ret = true; +fail: + if (cli != NULL) { + torture_close_connection(cli); + } + return ret; +} diff --git a/source3/torture/test_authinfo_structs.c b/source3/torture/test_authinfo_structs.c new file mode 100644 index 0000000..0b5cff7 --- /dev/null +++ b/source3/torture/test_authinfo_structs.c @@ -0,0 +1,218 @@ +/* + Unix SMB/CIFS implementation. + Test conversion form struct lsa_TrustDomainInfoAuthInfo to + struct trustAuthInOutBlob and back + Copyright (C) Sumit Bose 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "librpc/gen_ndr/lsa.h" +#include "libcli/lsarpc/util_lsarpc.h" + +static bool cmp_TrustDomainInfoBuffer(struct lsa_TrustDomainInfoBuffer a, + struct lsa_TrustDomainInfoBuffer b) +{ + if (a.last_update_time != b. last_update_time || + a.AuthType != b.AuthType || + a.data.size != b.data.size || + memcmp(a.data.data, b.data.data, a.data.size) !=0) { + return false; + } + + return true; +} + +static bool cmp_auth_info(struct lsa_TrustDomainInfoAuthInfo *a, + struct lsa_TrustDomainInfoAuthInfo *b) +{ + size_t c; + + if (a->incoming_count != b->incoming_count || + a->outgoing_count != b->outgoing_count) { + return false; + } + + for (c = 0; c < a->incoming_count; c++) { + if (!cmp_TrustDomainInfoBuffer(a->incoming_current_auth_info[c], + b->incoming_current_auth_info[c])) { + return false; + } + + if (a->incoming_previous_auth_info != NULL && + b->incoming_previous_auth_info != NULL) { + if (!cmp_TrustDomainInfoBuffer(a->incoming_previous_auth_info[c], + b->incoming_previous_auth_info[c])) { + return false; + } + } else if (a->incoming_previous_auth_info == NULL && + b->incoming_previous_auth_info == NULL) { + continue; + } else { + return false; + } + } + + for (c = 0; c < a->outgoing_count; c++) { + if (!cmp_TrustDomainInfoBuffer(a->outgoing_current_auth_info[c], + b->outgoing_current_auth_info[c])) { + return false; + } + + if (a->outgoing_previous_auth_info != NULL && + b->outgoing_previous_auth_info != NULL) { + if (!cmp_TrustDomainInfoBuffer(a->outgoing_previous_auth_info[c], + b->outgoing_previous_auth_info[c])) { + return false; + } + } else if (a->outgoing_previous_auth_info == NULL && + b->outgoing_previous_auth_info == NULL) { + continue; + } else { + return false; + } + } + + return true; +} + +static bool covert_and_compare(struct lsa_TrustDomainInfoAuthInfo *auth_info) +{ + NTSTATUS status; + TALLOC_CTX *tmp_ctx; + DATA_BLOB incoming; + DATA_BLOB outgoing; + struct lsa_TrustDomainInfoAuthInfo auth_info_out; + bool result = false; + + tmp_ctx = talloc_new(NULL); + if (tmp_ctx == NULL) { + return false; + } + + status = auth_info_2_auth_blob(tmp_ctx, auth_info, &incoming, &outgoing); + if (!NT_STATUS_IS_OK(status)) { + talloc_free(tmp_ctx); + return false; + } + + status = auth_blob_2_auth_info(tmp_ctx, incoming, outgoing, + &auth_info_out); + if (!NT_STATUS_IS_OK(status)) { + talloc_free(tmp_ctx); + return false; + } + + result = cmp_auth_info(auth_info, &auth_info_out); + talloc_free(tmp_ctx); + + return result; +} + +bool run_local_conv_auth_info(int dummy) +{ + struct lsa_TrustDomainInfoAuthInfo auth_info; + struct lsa_TrustDomainInfoBuffer ic[1]; + struct lsa_TrustDomainInfoBuffer ip[1]; + struct lsa_TrustDomainInfoBuffer oc[2]; + struct lsa_TrustDomainInfoBuffer op[2]; + uint32_t version = 3; + + ic[0].last_update_time = 12345; + ic[0].AuthType = TRUST_AUTH_TYPE_CLEAR; + ic[0].data.size = strlen("iPaSsWoRd"); + ic[0].data.data = discard_const_p(uint8_t, "iPaSsWoRd"); + + ip[0].last_update_time = 67890; + ip[0].AuthType = TRUST_AUTH_TYPE_CLEAR; + ip[0].data.size = strlen("OlDiPaSsWoRd"); + ip[0].data.data = discard_const_p(uint8_t, "OlDiPaSsWoRd"); + + oc[0].last_update_time = 24580; + oc[0].AuthType = TRUST_AUTH_TYPE_CLEAR; + oc[0].data.size = strlen("oPaSsWoRd"); + oc[0].data.data = discard_const_p(uint8_t, "oPaSsWoRd"); + oc[1].last_update_time = 24580; + oc[1].AuthType = TRUST_AUTH_TYPE_VERSION; + oc[1].data.size = 4; + oc[1].data.data = (uint8_t *) &version; + + op[0].last_update_time = 13579; + op[0].AuthType = TRUST_AUTH_TYPE_CLEAR; + op[0].data.size = strlen("OlDoPaSsWoRd"); + op[0].data.data = discard_const_p(uint8_t, "OlDoPaSsWoRd"); + op[1].last_update_time = 24580; + op[1].AuthType = TRUST_AUTH_TYPE_VERSION; + op[1].data.size = 4; + op[1].data.data = (uint8_t *) &version; + + auth_info.incoming_count = 0; + auth_info.incoming_current_auth_info = NULL; + auth_info.incoming_previous_auth_info = NULL; + auth_info.outgoing_count = 0; + auth_info.outgoing_current_auth_info = NULL; + auth_info.outgoing_previous_auth_info = NULL; + + if (!covert_and_compare(&auth_info)) { + return false; + } + + auth_info.incoming_count = 1; + auth_info.incoming_current_auth_info = ic; + auth_info.incoming_previous_auth_info = NULL; + auth_info.outgoing_count = 0; + auth_info.outgoing_current_auth_info = NULL; + auth_info.outgoing_previous_auth_info = NULL; + + if (!covert_and_compare(&auth_info)) { + return false; + } + + auth_info.incoming_count = 0; + auth_info.incoming_current_auth_info = NULL; + auth_info.incoming_previous_auth_info = NULL; + auth_info.outgoing_count = 2; + auth_info.outgoing_current_auth_info = oc; + auth_info.outgoing_previous_auth_info = NULL; + + if (!covert_and_compare(&auth_info)) { + return false; + } + + auth_info.incoming_count = 1; + auth_info.incoming_current_auth_info = ic; + auth_info.incoming_previous_auth_info = NULL; + auth_info.outgoing_count = 2; + auth_info.outgoing_current_auth_info = oc; + auth_info.outgoing_previous_auth_info = NULL; + + if (!covert_and_compare(&auth_info)) { + return false; + } + + auth_info.incoming_count = 1; + auth_info.incoming_current_auth_info = ic; + auth_info.incoming_previous_auth_info = ip; + auth_info.outgoing_count = 2; + auth_info.outgoing_current_auth_info = oc; + auth_info.outgoing_previous_auth_info = op; + + if (!covert_and_compare(&auth_info)) { + return false; + } + + return true; +} diff --git a/source3/torture/test_buffersize.c b/source3/torture/test_buffersize.c new file mode 100644 index 0000000..217b148 --- /dev/null +++ b/source3/torture/test_buffersize.c @@ -0,0 +1,55 @@ +/* + Unix SMB/CIFS implementation. + Test buffer sizes in cli_qpathinfo + Copyright (C) Volker Lendecke 2012 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "libcli/security/dom_sid.h" +#include "libcli/security/secdesc.h" +#include "libcli/security/security.h" +#include "trans2.h" +#include "source3/libsmb/clirap.h" + +bool run_qpathinfo_bufsize(int dummy) +{ + struct cli_state *cli = NULL; + bool ret = false; + int i; + + printf("Starting qpathinfo_bufsize\n"); + + if (!torture_open_connection(&cli, 0)) { + printf("torture_open_connection failed\n"); + goto fail; + } + + for (i=0; i<500; i++) { + uint8_t *rdata; + uint32_t num_rdata; + cli_qpathinfo(cli, cli, "\\", SMB_FILE_ALL_INFORMATION, + 0, i, &rdata, &num_rdata); + } + + ret = true; +fail: + if (cli != NULL) { + torture_close_connection(cli); + } + return ret; +} diff --git a/source3/torture/test_case_insensitive.c b/source3/torture/test_case_insensitive.c new file mode 100644 index 0000000..04e2dce --- /dev/null +++ b/source3/torture/test_case_insensitive.c @@ -0,0 +1,80 @@ +/* + Unix SMB/CIFS implementation. + reproducer for bug 8042 + Copyright (C) Volker Lendecke 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "system/filesys.h" +#include "libsmb/libsmb.h" + +/* + * Regression test file creates on case insensitive file systems (e.g. OS/X) + * https://bugzilla.samba.org/show_bug.cgi?id=8042 + */ + +bool run_case_insensitive_create(int dummy) +{ + struct cli_state *cli; + uint16_t fnum; + NTSTATUS status; + + printf("Starting case_insensitive_create\n"); + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + status = cli_mkdir(cli, "x"); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_mkdir failed: %s\n", nt_errstr(status)); + goto done; + } + status = cli_chkpath(cli, "X"); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_chkpath failed: %s\n", nt_errstr(status)); + goto rmdir; + } + status = cli_openx(cli, "x\\y", O_RDWR|O_CREAT, 0, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_openx failed: %s\n", nt_errstr(status)); + + if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("Bug 8042 reappeared!!\n"); + } + goto unlink; + } + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed: %s\n", nt_errstr(status)); + goto done; + } +unlink: + status = cli_unlink(cli, "x\\y", 0); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_unlink failed: %s\n", nt_errstr(status)); + goto done; + } +rmdir: + status = cli_rmdir(cli, "x"); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed: %s\n", nt_errstr(status)); + } +done: + torture_close_connection(cli); + return NT_STATUS_IS_OK(status); +} diff --git a/source3/torture/test_chain3.c b/source3/torture/test_chain3.c new file mode 100644 index 0000000..5320ef8 --- /dev/null +++ b/source3/torture/test_chain3.c @@ -0,0 +1,296 @@ +/* + Unix SMB/CIFS implementation. + Test smbd chain routines + + Copyright (C) Volker Lendecke 2012 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "system/filesys.h" +#include "async_smb.h" +#include "lib/util/tevent_ntstatus.h" +#include "libcli/security/security.h" +#include "libcli/smb/smbXcli_base.h" + +struct chain3_andx_state { + uint16_t fnum; + size_t written; + char str[6]; +}; + +static void chain3_andx_open_done(struct tevent_req *subreq); +static void chain3_andx_write_done(struct tevent_req *subreq); +static void chain3_andx_close_done(struct tevent_req *subreq); + +static struct tevent_req *chain3_andx_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *fname) +{ + struct tevent_req *req, *subreq; + struct tevent_req *smbreqs[3]; + struct chain3_andx_state *state; + NTSTATUS status; + + req = tevent_req_create(mem_ctx, &state, struct chain3_andx_state); + if (req == NULL) { + return NULL; + } + + strlcpy(state->str, "hello", sizeof(state->str)); + + subreq = cli_openx_create(state, ev, cli, fname, + O_CREAT|O_RDWR, 0, &smbreqs[0]); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, chain3_andx_open_done, req); + + subreq = cli_write_andx_create(state, ev, cli, 0, 0, + (const uint8_t *)state->str, 0, + strlen(state->str)+1, + smbreqs, 1, &smbreqs[1]); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, chain3_andx_write_done, req); + + subreq = cli_smb1_close_create(state, ev, cli, 0, &smbreqs[2]); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, chain3_andx_close_done, req); + + status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs)); + if (tevent_req_nterror(req, status)) { + return tevent_req_post(req, ev); + } + return req; +} + +static void chain3_andx_open_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct chain3_andx_state *state = tevent_req_data( + req, struct chain3_andx_state); + NTSTATUS status; + + status = cli_openx_recv(subreq, &state->fnum); + printf("cli_openx returned %s, fnum=%u\n", nt_errstr(status), + (unsigned)state->fnum); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } +} + +static void chain3_andx_write_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct chain3_andx_state *state = tevent_req_data( + req, struct chain3_andx_state); + NTSTATUS status; + + status = cli_write_andx_recv(subreq, &state->written); + printf("cli_write_andx returned %s, written=%u\n", nt_errstr(status), + (unsigned)state->written); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } +} + +static void chain3_andx_close_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + + status = cli_close_recv(subreq); + printf("cli_close returned %s\n", nt_errstr(status)); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + tevent_req_done(req); +} + +static NTSTATUS chain3_andx_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +struct chain3_state { + struct tevent_context *ev; + struct cli_state *cli; + const char *fname; + uint16_t fnum; +}; + +static void chain3_got_break(struct tevent_req *subreq); +static void chain3_ntcreate_done(struct tevent_req *subreq); +static void chain3_break_close_done(struct tevent_req *subreq); +static void chain3_andx_done(struct tevent_req *subreq); + +static struct tevent_req *chain3_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev) +{ + struct tevent_req *req, *subreq; + struct chain3_state *state; + + req = tevent_req_create(mem_ctx, &state, struct chain3_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->fname = "chain3.txt"; + + if (!torture_open_connection(&state->cli, 0)) { + tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL); + return tevent_req_post(req, ev); + } + + subreq = cli_smb_oplock_break_waiter_send( + state, state->ev, state->cli); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, chain3_got_break, req); + + subreq = cli_ntcreate_send( + state, state->ev, state->cli, state->fname, + REQUEST_OPLOCK|REQUEST_BATCH_OPLOCK, + GENERIC_READ_ACCESS|GENERIC_WRITE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0, + SMB2_IMPERSONATION_IMPERSONATION, 0); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, chain3_ntcreate_done, req); + return req; +} + +static void chain3_got_break(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct chain3_state *state = tevent_req_data( + req, struct chain3_state); + uint16_t fnum; + uint8_t level; + NTSTATUS status; + + status = cli_smb_oplock_break_waiter_recv(subreq, &fnum, &level); + TALLOC_FREE(subreq); + printf("cli_smb_oplock_break_waiter_recv returned %s\n", + nt_errstr(status)); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = cli_close_send(state, state->ev, state->cli, fnum, 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, chain3_break_close_done, req); +} + +static void chain3_break_close_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + + status = cli_close_recv(subreq); + TALLOC_FREE(subreq); + printf("cli_close_recv returned %s\n", nt_errstr(status)); + if (tevent_req_nterror(req, status)) { + return; + } +} + +static void chain3_ntcreate_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct chain3_state *state = tevent_req_data( + req, struct chain3_state); + NTSTATUS status; + + status = cli_ntcreate_recv(subreq, &state->fnum, NULL); + TALLOC_FREE(subreq); + printf("cli_ntcreate returned %s, fnum=%u\n", nt_errstr(status), + (unsigned)state->fnum); + if (tevent_req_nterror(req, status)) { + return; + } + + subreq = chain3_andx_send(state, state->ev, state->cli, state->fname); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, chain3_andx_done, req); +} + +static void chain3_andx_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + + status = chain3_andx_recv(subreq); + TALLOC_FREE(subreq); + printf("chain3_andx_recv returned %s\n", nt_errstr(status)); + if (tevent_req_nterror(req, status)) { + return; + } + tevent_req_done(req); +} + +static NTSTATUS chain3_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +bool run_chain3(int dummy) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct tevent_context *ev; + struct tevent_req *req; + NTSTATUS status = NT_STATUS_NO_MEMORY; + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + goto fail; + } + req = chain3_send(frame, ev); + if (req == NULL) { + goto fail; + } + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + goto fail; + } + status = chain3_recv(req); +fail: + TALLOC_FREE(frame); + printf("run_chain3 returns %s\n", nt_errstr(status)); + return NT_STATUS_IS_OK(status); +} diff --git a/source3/torture/test_cleanup.c b/source3/torture/test_cleanup.c new file mode 100644 index 0000000..2ff5cf6 --- /dev/null +++ b/source3/torture/test_cleanup.c @@ -0,0 +1,240 @@ +/* + Unix SMB/CIFS implementation. + Test cleanup behaviour + Copyright (C) Volker Lendecke 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "locking/proto.h" +#include "torture/proto.h" +#include "system/filesys.h" +#include "system/select.h" +#include "libsmb/libsmb.h" +#include "libcli/smb/smbXcli_base.h" +#include "libcli/security/security.h" +#include "librpc/gen_ndr/open_files.h" + +bool run_cleanup1(int dummy) +{ + struct cli_state *cli; + const char *fname = "\\cleanup1"; + uint16_t fnum; + NTSTATUS status; + + printf("CLEANUP1: Checking that a conflicting share mode is cleaned " + "up\n"); + + if (!torture_open_connection(&cli, 0)) { + return false; + } + status = cli_openx(cli, fname, O_RDWR|O_CREAT, DENY_ALL, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + status = smbXcli_conn_samba_suicide(cli->conn, 1); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_conn_samba_suicide failed: %s\n", + nt_errstr(status)); + return false; + } + + if (!torture_open_connection(&cli, 1)) { + return false; + } + status = cli_ntcreate( + cli, fname, 0, + FILE_GENERIC_READ|FILE_GENERIC_WRITE|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, FILE_DELETE_ON_CLOSE, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("2nd open of %s failed (%s)\n", fname, + nt_errstr(status)); + return false; + } + cli_close(cli, fnum); + + torture_close_connection(cli); + return NT_STATUS_IS_OK(status); +} + +bool run_cleanup2(int dummy) +{ + struct cli_state *cli1, *cli2, *cli3; + const char *fname = "\\cleanup2"; + uint16_t fnum1, fnum2, fnum3; + NTSTATUS status; + char buf; + + printf("CLEANUP2: Checking that a conflicting brlock is cleaned up\n"); + + if (!torture_open_connection(&cli1, 0)) { + return false; + } + status = cli_ntcreate( + cli1, fname, 0, FILE_GENERIC_READ|FILE_GENERIC_WRITE, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + status = cli_lock32(cli1, fnum1, 0, 1, 0, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("lock failed (%s)\n", nt_errstr(status)); + return false; + } + + if (!torture_open_connection(&cli3, 1)) { + return false; + } + status = cli_ntcreate( + cli3, fname, 0, FILE_GENERIC_READ|FILE_GENERIC_WRITE, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0, 0, &fnum3, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + status = cli_lock32(cli3, fnum3, 1, 1, 0, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("lock failed (%s)\n", nt_errstr(status)); + return false; + } + + status = cli_lock32(cli1, fnum1, 2, 1, 0, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("lock failed (%s)\n", nt_errstr(status)); + return false; + } + + /* + * Check the file is indeed locked + */ + if (!torture_open_connection(&cli2, 1)) { + return false; + } + status = cli_ntcreate( + cli2, fname, 0, FILE_GENERIC_READ|FILE_GENERIC_WRITE, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + buf = 'x'; + status = cli_smbwrite(cli2, fnum2, &buf, 0, 1, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) { + printf("write succeeded\n"); + return false; + } + + /* + * Kill the lock holder + */ + status = smbXcli_conn_samba_suicide(cli1->conn, 1); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_conn_samba_suicide failed: %s\n", + nt_errstr(status)); + return false; + } + + /* + * Give the suicidal smbd a bit of time to really pass away + */ + smb_msleep(1000); + + status = cli_smbwrite(cli2, fnum2, &buf, 0, 1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("write failed: %s\n", nt_errstr(status)); + return false; + } + return true; +} + +bool run_cleanup4(int dummy) +{ + struct cli_state *cli1, *cli2; + const char *fname = "\\cleanup4"; + uint16_t fnum1, fnum2; + NTSTATUS status; + + printf("CLEANUP4: Checking that a conflicting share mode is cleaned " + "up\n"); + + if (!torture_open_connection(&cli1, 0)) { + return false; + } + if (!torture_open_connection(&cli2, 0)) { + return false; + } + + status = cli_ntcreate( + cli1, fname, 0, + FILE_GENERIC_READ|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("creating file failed: %s\n", + nt_errstr(status)); + return false; + } + + status = cli_ntcreate( + cli2, fname, 0, + FILE_GENERIC_READ|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("opening file 1st time failed: %s\n", + nt_errstr(status)); + return false; + } + + status = smbXcli_conn_samba_suicide(cli1->conn, 1); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_conn_samba_suicide failed: %s\n", + nt_errstr(status)); + return false; + } + + /* + * The next open will conflict with both opens above. The first open + * above will be correctly cleaned up. A bug in smbd iterating over + * the share mode array made it skip the share conflict check for the + * second open. Trigger this bug. + */ + + status = cli_ntcreate( + cli2, fname, 0, + FILE_GENERIC_WRITE|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) { + printf("opening file 2nd time returned: %s\n", + nt_errstr(status)); + return false; + } + + return true; +} diff --git a/source3/torture/test_ctdbd_conn.c b/source3/torture/test_ctdbd_conn.c new file mode 100644 index 0000000..124a334 --- /dev/null +++ b/source3/torture/test_ctdbd_conn.c @@ -0,0 +1,312 @@ +/* + * Unix SMB/CIFS implementation. + * Test async ctdb_req_send/recv + * Copyright (C) Volker Lendecke 2020 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "torture/proto.h" +#include "ctdbd_conn.h" +#include "lib/cluster_support.h" +#include "ctdb/include/ctdb_protocol.h" +#include "lib/util/tevent_unix.h" + +extern int torture_nprocs; +extern int torture_numops; + +struct ctdb_echo_state { + struct ctdb_req_control_old req; + struct iovec iov[2]; + TDB_DATA echodata; +}; + +static void ctdb_echo_done(struct tevent_req *subreq); + +static struct tevent_req *ctdb_echo_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct ctdbd_connection *conn, + uint32_t delay) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct ctdb_echo_state *state = NULL; + struct ctdb_req_header *hdr = NULL; + uint32_t datalen; + + req = tevent_req_create( + mem_ctx, &state, struct ctdb_echo_state); + if (req == NULL) { + return NULL; + } + + hdr = &state->req.hdr; + ctdbd_prep_hdr_next_reqid(conn, hdr); + hdr->operation = CTDB_REQ_CONTROL; + state->req.opcode = CTDB_CONTROL_ECHO_DATA; + + state->iov[0] = (struct iovec) { + .iov_base = &state->req, + .iov_len = offsetof(struct ctdb_req_control_old, data), + }; + + datalen = generate_random() % 1024; + + state->echodata.dptr = talloc_array(state, uint8_t, datalen+8); + if (tevent_req_nomem(state->echodata.dptr, req)) { + return tevent_req_post(req, ev); + } + state->echodata.dsize = talloc_get_size(state->echodata.dptr); + generate_random_buffer( + state->echodata.dptr, state->echodata.dsize); + + memcpy(state->echodata.dptr, &delay, sizeof(delay)); + memcpy(state->echodata.dptr+4, &datalen, sizeof(datalen)); + + state->req.datalen = state->echodata.dsize; + + state->iov[1] = (struct iovec) { + .iov_base = state->echodata.dptr, + .iov_len = state->echodata.dsize, + }; + + hdr->length = + offsetof(struct ctdb_req_control_old, data) + + state->req.datalen; + + subreq = ctdbd_req_send( + state, ev, conn, state->iov, ARRAY_SIZE(state->iov)); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, ctdb_echo_done, req); + + return req; +} + +static void ctdb_echo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct ctdb_echo_state *state = tevent_req_data( + req, struct ctdb_echo_state); + struct ctdb_req_header *hdr = NULL; + struct ctdb_reply_control_old *reply = NULL; + int cmp, ret; + + ret = ctdbd_req_recv(subreq, state, &hdr); + TALLOC_FREE(subreq); + if (tevent_req_error(req, ret)) { + printf("ctdbd_req_recv(%"PRIu32") returned %d (%s)\n", + state->req.hdr.reqid, + ret, + strerror(ret)); + return; + } + if (hdr->operation != CTDB_REPLY_CONTROL) { + printf("Expected CTDB_REPLY_CONTROL, got %"PRIu32"\n", + hdr->operation); + tevent_req_error(req, EIO); + return; + } + reply = (struct ctdb_reply_control_old *)hdr; + if (reply->status != 0) { + printf("reply->status = %"PRIi32"\n", reply->status); + tevent_req_error(req, EIO); + return; + } + if (reply->datalen != state->req.datalen) { + printf("state->echodata.dsize=%zu datalen=%"PRIu32"\n", + state->echodata.dsize, + reply->datalen); + tevent_req_error(req, EIO); + return; + } + cmp = memcmp(reply->data, + state->echodata.dptr, + state->echodata.dsize); + if (cmp != 0) { + printf("data mismatch\n"); + tevent_req_error(req, EIO); + return; + } + TALLOC_FREE(reply); + tevent_req_done(req); +} + +static int ctdb_echo_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_unix(req); +} + +struct ctdb_ping_flood_state { + struct tevent_context *ev; + struct ctdbd_connection *conn; + size_t num_running; + bool done; +}; + +static void ctdb_ping_flood_next(struct tevent_req *subreq); +static void ctdb_ping_flood_done(struct tevent_req *subreq); + +static struct tevent_req *ctdb_ping_flood_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct ctdbd_connection *conn, + size_t num_parallel, + unsigned usecs) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct ctdb_ping_flood_state *state = NULL; + size_t i; + + req = tevent_req_create( + mem_ctx, &state, struct ctdb_ping_flood_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->conn = conn; + + for (i=0; iev, + state->conn, + generate_random() % 10); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, ctdb_ping_flood_next, req); + } + state->num_running = num_parallel; + + subreq = tevent_wakeup_send( + state, + ev, + tevent_timeval_current_ofs(0, usecs)); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, ctdb_ping_flood_done, req); + + return req; +} + +static void ctdb_ping_flood_next(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct ctdb_ping_flood_state *state = tevent_req_data( + req, struct ctdb_ping_flood_state); + int ret; + + ret = ctdb_echo_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_error(req, ret)) { + return; + } + state->num_running -= 1; + + if (state->done) { + if (state->num_running == 0) { + tevent_req_done(req); + } + return; + } + + subreq = ctdb_echo_send( + state, + state->ev, + state->conn, + generate_random() % 10); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, ctdb_ping_flood_next, req); + state->num_running += 1; +} + +static void ctdb_ping_flood_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct ctdb_ping_flood_state *state = tevent_req_data( + req, struct ctdb_ping_flood_state); + bool ok; + + ok = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (!ok) { + tevent_req_oom(req); + return; + } + state->done = true; +} + +static int ctdb_ping_flood_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_unix(req); +} + +bool run_ctdbd_conn1(int dummy) +{ + struct ctdbd_connection *conn = NULL; + struct tevent_context *ev = NULL; + struct tevent_req *req = NULL; + int ret; + bool ok; + bool result = false; + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + printf("samba_tevent_context_init failed\n"); + goto done; + } + + ret = ctdbd_init_async_connection( + ev, lp_ctdbd_socket(), 0, &conn); + if (ret != 0) { + printf("ctdbd_init_async_connection failed: %s\n", + strerror(ret)); + goto done; + } + + req = ctdb_ping_flood_send( + ev, ev, conn, torture_nprocs, torture_numops * 1000); + if (req == NULL) { + printf("ctdb_ping_flood_send failed\n"); + goto done; + } + + ok = tevent_req_poll_unix(req, ev, &ret); + if (!ok) { + printf("tevent_req_poll_unix failed: %s\n", + strerror(ret)); + goto done; + } + + ret = ctdb_ping_flood_recv(req); + TALLOC_FREE(req); + if (ret != 0) { + printf("ctdb_ping_flood failed: %s\n", strerror(ret)); + goto done; + } + + result = true; +done: + TALLOC_FREE(conn); + return result; +} diff --git a/source3/torture/test_dbwrap_ctdb.c b/source3/torture/test_dbwrap_ctdb.c new file mode 100644 index 0000000..e3a7c6a --- /dev/null +++ b/source3/torture/test_dbwrap_ctdb.c @@ -0,0 +1,163 @@ +/* + * Unix SMB/CIFS implementation. + * Test dbwrap_ctdb API + * Copyright (C) Volker Lendecke 2012 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "torture/proto.h" +#include "system/filesys.h" +#include "lib/dbwrap/dbwrap.h" +#include "lib/dbwrap/dbwrap_ctdb.h" +#include "messages.h" +#include "lib/messages_ctdb.h" +#include "lib/global_contexts.h" + +bool run_local_dbwrap_ctdb1(int dummy) +{ + struct db_context *db = NULL; + int res; + bool ret = false; + NTSTATUS status; + uint32_t val; + struct messaging_context *msg_ctx; + + msg_ctx = global_messaging_context(); + + db = db_open_ctdb( + talloc_tos(), + msg_ctx, + "torture.tdb", + 0, + TDB_DEFAULT, + O_RDWR|O_CREAT, + 0755, + DBWRAP_LOCK_ORDER_1, + DBWRAP_FLAG_NONE); + if (db == NULL) { + perror("db_open_ctdb failed"); + goto fail; + } + + res = dbwrap_transaction_start(db); + if (res != 0) { + fprintf(stderr, "dbwrap_transaction_start failed"); + goto fail; + } + res = dbwrap_transaction_cancel(db); + if (res != 0) { + fprintf(stderr, "dbwrap_transaction_cancel failed"); + goto fail; + } + + res = dbwrap_transaction_start(db); + if (res != 0) { + fprintf(stderr, "dbwrap_transaction_start failed"); + goto fail; + } + + status = dbwrap_store_uint32_bystring(db, "foo", 1); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "store_uint32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + status = dbwrap_fetch_uint32_bystring(db, "foo", &val); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "fetch_uint32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (val != 1) { + fprintf(stderr, "fetch_uint32 gave %u, expected 1", + (unsigned)val); + goto fail; + } + + status = dbwrap_store_uint32_bystring(db, "bar", 5); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "store_uint32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + status = dbwrap_fetch_uint32_bystring(db, "bar", &val); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "fetch_uint32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (val != 5) { + fprintf(stderr, "fetch_uint32 gave %u, expected 5", + (unsigned)val); + goto fail; + } + + status = dbwrap_store_uint32_bystring(db, "foo", 2); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "store_uint32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + status = dbwrap_fetch_uint32_bystring(db, "foo", &val); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "fetch_uint32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (val != 2) { + fprintf(stderr, "fetch_uint32 gave %u, expected 2", + (unsigned)val); + goto fail; + } + + res = dbwrap_transaction_commit(db); + if (res != 0) { + fprintf(stderr, "dbwrap_transaction_commit failed"); + goto fail; + } + + /* + * check that the values have reached the disk + */ + status = dbwrap_fetch_uint32_bystring(db, "foo", &val); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "fetch_uint32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (val != 2) { + fprintf(stderr, "fetch_uint32 gave %u, expected 1", + (unsigned)val); + goto fail; + } + + status = dbwrap_fetch_uint32_bystring(db, "bar", &val); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "fetch_uint32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (val != 5) { + fprintf(stderr, "fetch_uint32 gave %u, expected 1", + (unsigned)val); + goto fail; + } + + ret = true; +fail: + TALLOC_FREE(db); + return ret; +} diff --git a/source3/torture/test_dbwrap_do_locked.c b/source3/torture/test_dbwrap_do_locked.c new file mode 100644 index 0000000..93648ce --- /dev/null +++ b/source3/torture/test_dbwrap_do_locked.c @@ -0,0 +1,161 @@ +/* + * Unix SMB/CIFS implementation. + * Test dbwrap_watch API + * Copyright (C) Volker Lendecke 2017 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "torture/proto.h" +#include "system/filesys.h" +#include "lib/dbwrap/dbwrap.h" +#include "lib/dbwrap/dbwrap_open.h" +#include "lib/dbwrap/dbwrap_watch.h" +#include "lib/util/util_tdb.h" +#include "source3/include/util_tdb.h" +#include "lib/global_contexts.h" + +struct do_locked1_state { + TDB_DATA value; + NTSTATUS status; +}; + +static void do_locked1_cb( + struct db_record *rec, + TDB_DATA value, + void *private_data) +{ + struct do_locked1_state *state = + (struct do_locked1_state *)private_data; + + state->status = dbwrap_record_store(rec, state->value, 0); +} + +static void do_locked1_check(TDB_DATA key, TDB_DATA value, + void *private_data) +{ + struct do_locked1_state *state = + (struct do_locked1_state *)private_data; + int ret; + + ret = tdb_data_cmp(value, state->value); + if (ret != 0) { + state->status = NT_STATUS_DATA_ERROR; + return; + } + + state->status = NT_STATUS_OK; +} + +static void do_locked1_del( + struct db_record *rec, + TDB_DATA value, + void *private_data) +{ + struct do_locked1_state *state = + (struct do_locked1_state *)private_data; + + state->status = dbwrap_record_delete(rec); +} + +bool run_dbwrap_do_locked1(int dummy) +{ + struct tevent_context *ev; + struct messaging_context *msg; + struct db_context *backend; + struct db_context *db; + const char *dbname = "test_do_locked.tdb"; + const char *keystr = "key"; + TDB_DATA key = string_term_tdb_data(keystr); + const char *valuestr = "value"; + TDB_DATA value = string_term_tdb_data(valuestr); + struct do_locked1_state state = { .value = value }; + int ret = false; + NTSTATUS status; + + ev = global_event_context(); + if (ev == NULL) { + fprintf(stderr, "global_event_context() failed\n"); + return false; + } + msg = global_messaging_context(); + if (msg == NULL) { + fprintf(stderr, "global_messaging_context() failed\n"); + return false; + } + + backend = db_open(talloc_tos(), dbname, 0, + TDB_CLEAR_IF_FIRST, O_CREAT|O_RDWR, 0644, + DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE); + if (backend == NULL) { + fprintf(stderr, "db_open failed: %s\n", strerror(errno)); + return false; + } + + db = db_open_watched(talloc_tos(), &backend, msg); + if (db == NULL) { + fprintf(stderr, "db_open_watched failed: %s\n", + strerror(errno)); + return false; + } + + status = dbwrap_do_locked(db, key, do_locked1_cb, &state); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "dbwrap_do_locked failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (!NT_STATUS_IS_OK(state.status)) { + fprintf(stderr, "store returned %s\n", + nt_errstr(state.status)); + goto fail; + } + + status = dbwrap_parse_record(db, key, do_locked1_check, &state); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "dbwrap_parse_record failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (!NT_STATUS_IS_OK(state.status)) { + fprintf(stderr, "data compare returned %s\n", + nt_errstr(status)); + goto fail; + } + + status = dbwrap_do_locked(db, key, do_locked1_del, &state); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "dbwrap_do_locked failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (!NT_STATUS_IS_OK(state.status)) { + fprintf(stderr, "delete returned %s\n", nt_errstr(status)); + goto fail; + } + + status = dbwrap_parse_record(db, key, do_locked1_check, &state); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) { + fprintf(stderr, "parse_record returned %s, " + "expected NOT_FOUND\n", nt_errstr(status)); + goto fail; + } + + ret = true; +fail: + TALLOC_FREE(db); + unlink(dbname); + return ret; +} diff --git a/source3/torture/test_dbwrap_watch.c b/source3/torture/test_dbwrap_watch.c new file mode 100644 index 0000000..480b2c5 --- /dev/null +++ b/source3/torture/test_dbwrap_watch.c @@ -0,0 +1,467 @@ +/* + Unix SMB/CIFS implementation. + Test dbwrap_watch API + Copyright (C) Volker Lendecke 2012 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "system/filesys.h" +#include "lib/dbwrap/dbwrap.h" +#include "lib/dbwrap/dbwrap_open.h" +#include "lib/dbwrap/dbwrap_watch.h" +#include "lib/util/util_tdb.h" + +static bool test_dbwrap_watch_init( + TALLOC_CTX *mem_ctx, + const char *dbname, + struct tevent_context **pev, + struct messaging_context **pmsg, + struct db_context **pbackend, + struct db_context **pdb) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct db_context *backend = NULL; + struct db_context *db = NULL; + + ev = samba_tevent_context_init(mem_ctx); + if (ev == NULL) { + fprintf(stderr, "tevent_context_init failed\n"); + goto fail; + } + + msg = messaging_init(ev, ev); + if (msg == NULL) { + fprintf(stderr, "messaging_init failed\n"); + goto fail; + } + + backend = db_open( + msg, + dbname, + 0, + TDB_CLEAR_IF_FIRST, + O_CREAT|O_RDWR, + 0644, + DBWRAP_LOCK_ORDER_1, + DBWRAP_FLAG_NONE); + if (backend == NULL) { + fprintf(stderr, "db_open failed: %s\n", strerror(errno)); + goto fail; + } + + { + struct db_context *backend_copy = backend; + + db = db_open_watched(ev, &backend_copy, msg); + if (db == NULL) { + fprintf(stderr, "db_open_watched failed\n"); + goto fail; + } + } + + if (pev != NULL) { + *pev = ev; + } + if (pmsg != NULL) { + *pmsg = msg; + } + if (pbackend != NULL) { + *pbackend = backend; + } + if (pdb != NULL) { + *pdb = db; + } + return true; + +fail: + TALLOC_FREE(backend); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return false; +} + +bool run_dbwrap_watch1(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct db_context *backend = NULL; + struct db_context *db = NULL; + const char *keystr = "key"; + TDB_DATA key = string_term_tdb_data(keystr); + struct db_record *rec = NULL; + struct tevent_req *req = NULL; + NTSTATUS status; + bool ret = false; + + ret = test_dbwrap_watch_init( + talloc_tos(), "test_watch.tdb", &ev, &msg, &backend, &db); + if (!ret) { + goto fail; + } + + rec = dbwrap_fetch_locked(db, db, key); + if (rec == NULL) { + fprintf(stderr, "dbwrap_fetch_locked failed\n"); + goto fail; + } + req = dbwrap_watched_watch_send(talloc_tos(), ev, rec, + 0, /* resume_instance */ + (struct server_id){0}); + if (req == NULL) { + fprintf(stderr, "dbwrap_record_watch_send failed\n"); + goto fail; + } + TALLOC_FREE(rec); + + status = dbwrap_store_int32_bystring(db, "different_key", 1); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "dbwrap_store_int32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + + status = dbwrap_store_int32_bystring(db, keystr, 1); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "dbwrap_store_int32 failed: %s\n", + nt_errstr(status)); + goto fail; + } + + if (!tevent_req_poll(req, ev)) { + fprintf(stderr, "tevent_req_poll failed\n"); + goto fail; + } + + status = dbwrap_watched_watch_recv(req, NULL, NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "dbwrap_record_watch_recv failed: %s\n", + nt_errstr(status)); + goto fail; + } + + (void)unlink("test_watch.tdb"); + ret = true; +fail: + TALLOC_FREE(req); + TALLOC_FREE(rec); + TALLOC_FREE(db); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} + +/* + * Make sure dbwrap_parse_record does not return NT_STATUS_OK on + * invalid data + */ + +bool run_dbwrap_watch2(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct db_context *backend = NULL; + struct db_context *db = NULL; + const char *keystr = "key"; + TDB_DATA key = string_term_tdb_data(keystr); + NTSTATUS status; + bool ret = false; + + ret = test_dbwrap_watch_init( + talloc_tos(), "test_watch.tdb", &ev, &msg, &backend, &db); + if (!ret) { + goto fail; + } + + /* + * Store invalid data (from the dbwrap_watch point of view) + * directly into the backend database + */ + status = dbwrap_store_uint32_bystring(backend, keystr, UINT32_MAX); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "dbwrap_store_uint32_bystring failed: %s\n", + nt_errstr(status)); + goto fail; + } + + status = dbwrap_parse_record(db, key, NULL, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) { + fprintf(stderr, "dbwrap_parse_record returned %s, expected " + "NT_STATUS_NOT_FOUND\n", nt_errstr(status)); + goto fail; + } + + (void)unlink("test_watch.tdb"); + ret = true; +fail: + TALLOC_FREE(db); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} + +/* + * Test autocleanup of dead watchers + */ + +bool run_dbwrap_watch3(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct db_context *backend = NULL; + struct db_context *db = NULL; + const char *keystr = "key"; + TDB_DATA key = string_term_tdb_data(keystr); + NTSTATUS status; + bool ret = false; + pid_t child, waited; + int wstatus, exit_status; + + BlockSignals(true, SIGCHLD); + + child = fork(); + if (child == -1) { + fprintf(stderr, + "fork failed: %s\n", + strerror(errno)); + goto fail; + } + + ret = test_dbwrap_watch_init( + talloc_tos(), "test_watch.tdb", &ev, &msg, &backend, &db); + if (!ret) { + goto fail; + } + + if (child == 0) { + struct db_record *rec = dbwrap_fetch_locked(db, db, key); + struct tevent_req *req = NULL; + + if (rec == NULL) { + fprintf(stderr, "dbwrap_fetch_locked failed\n"); + exit(1); + } + + req = dbwrap_watched_watch_send( + db, ev, rec, 0, (struct server_id) { 0 }); + if (req == NULL) { + fprintf(stderr, "dbwrap_watched_watch_send failed\n"); + exit(2); + } + + exit(0); + } + + waited = waitpid(child, &wstatus, 0); + if (waited == -1) { + fprintf(stderr, "waitpid failed: %s\n", strerror(errno)); + goto fail; + } + if (!WIFEXITED(wstatus)) { + fprintf(stderr, "child did not exit normally\n"); + goto fail; + } + + exit_status = WEXITSTATUS(wstatus); + if (exit_status != 0) { + fprintf(stderr, "exit status is %d\n", exit_status); + goto fail; + } + + status = dbwrap_store_uint32_bystring(db, keystr, 1); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) { + fprintf(stderr, + "dbwrap_store_uint32 returned %s\n", + nt_errstr(status)); + goto fail; + } + + (void)unlink("test_watch.tdb"); + ret = true; +fail: + TALLOC_FREE(db); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} + +/* + * Test that we can't add two watchers in the same + * fetch_lock/do_locked round + */ + +struct dbwrap_watch4_state { + TALLOC_CTX *mem_ctx; + struct tevent_context *ev; + struct db_context *db; + TDB_DATA key; + + NTSTATUS status; + + struct tevent_req *req1; + NTSTATUS status1; + + struct tevent_req *req2; + NTSTATUS status2; +}; + +static void dbwrap_watch4_done1(struct tevent_req *subreq); +static void dbwrap_watch4_done2(struct tevent_req *subreq); + +static void dbwrap_watch4_fn(struct db_record *rec, + TDB_DATA value, + void *private_data) +{ + struct dbwrap_watch4_state *state = private_data; + bool ok; + + state->req1 = dbwrap_watched_watch_send( + state->mem_ctx, state->ev, rec, 0, (struct server_id) { .pid=0 }); + if (state->req1 == NULL) { + goto nomem; + } + tevent_req_set_callback(state->req1, dbwrap_watch4_done1, state); + state->status1 = NT_STATUS_EVENT_PENDING; + + ok = tevent_req_set_endtime( + state->req1, state->ev, timeval_current_ofs(1, 0)); + if (!ok) { + goto nomem; + } + + state->req2 = dbwrap_watched_watch_send( + state->mem_ctx, state->ev, rec, 0, (struct server_id) { .pid=0 }); + if (state->req2 == NULL) { + goto nomem; + } + tevent_req_set_callback(state->req2, dbwrap_watch4_done2, state); + state->status2 = NT_STATUS_EVENT_PENDING; + + ok = tevent_req_set_endtime( + state->req2, state->ev, timeval_current_ofs(1, 0)); + if (!ok) { + goto nomem; + } + + state->status = NT_STATUS_OK; + return; + + nomem: + state->status = NT_STATUS_NO_MEMORY; +} + +static void dbwrap_watch4_done1(struct tevent_req *subreq) +{ + struct dbwrap_watch4_state *state = tevent_req_callback_data_void(subreq); + state->status1 = dbwrap_watched_watch_recv(subreq, NULL, NULL, NULL); + TALLOC_FREE(subreq); + printf("req1 finished: %s\n", nt_errstr(state->status1)); + state->req1 = NULL; +} + +static void dbwrap_watch4_done2(struct tevent_req *subreq) +{ + struct dbwrap_watch4_state *state = tevent_req_callback_data_void(subreq); + state->status2 = dbwrap_watched_watch_recv(subreq, NULL, NULL, NULL); + TALLOC_FREE(subreq); + printf("req2 finished: %s\n", nt_errstr(state->status2)); + state->req2 = NULL; +} + +bool run_dbwrap_watch4(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct db_context *backend = NULL; + struct db_context *db = NULL; + const char *keystr = "key"; + TDB_DATA key = string_term_tdb_data(keystr); + struct dbwrap_watch4_state state = { 0 }; + NTSTATUS status; + bool ret = false; + bool ok; + + ok = test_dbwrap_watch_init( + talloc_tos(), "test_watch.tdb", &ev, &msg, &backend, &db); + if (!ok) { + goto fail; + } + + state = (struct dbwrap_watch4_state) { + .mem_ctx = talloc_tos(), + .ev = ev, + .db = db, + .key = key, + }; + + status = dbwrap_do_locked(db, key, dbwrap_watch4_fn, &state); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, + "dbwrap_do_locked failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (!NT_STATUS_IS_OK(state.status)) { + fprintf(stderr, + "dbwrap_watch4_fn failed: %s\n", + nt_errstr(status)); + goto fail; + } + + status = dbwrap_store(db, key, key, 0); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, + "dbwrap_store failed: %s\n", + nt_errstr(status)); + goto fail; + } + + while (NT_STATUS_EQUAL(state.status1, NT_STATUS_EVENT_PENDING) || + NT_STATUS_EQUAL(state.status2, NT_STATUS_EVENT_PENDING)) { + int res = tevent_loop_once(ev); + if (res != 0) { + fprintf(stderr, + "tevent_loop_once failed: %s\n", + strerror(errno)); + goto fail; + } + } + + if (!NT_STATUS_IS_OK(state.status1)) { + fprintf(stderr, + "req1 returned %s\n", + nt_errstr(state.status1)); + goto fail; + } + + if (!NT_STATUS_EQUAL(state.status2, NT_STATUS_REQUEST_NOT_ACCEPTED)) { + fprintf(stderr, + "req2 returned %s\n", + nt_errstr(state.status2)); + goto fail; + } + + (void)unlink("test_watch.tdb"); + ret = true; +fail: + TALLOC_FREE(state.req2); + TALLOC_FREE(state.req1); + TALLOC_FREE(db); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} diff --git a/source3/torture/test_g_lock.c b/source3/torture/test_g_lock.c new file mode 100644 index 0000000..fee9127 --- /dev/null +++ b/source3/torture/test_g_lock.c @@ -0,0 +1,1403 @@ +/* + * Unix SMB/CIFS implementation. + * Test g_lock API + * Copyright (C) Volker Lendecke 2017 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "torture/proto.h" +#include "system/filesys.h" +#include "g_lock.h" +#include "messages.h" +#include "lib/util/server_id.h" +#include "lib/util/sys_rw.h" +#include "lib/util/util_tdb.h" +#include "lib/util/tevent_ntstatus.h" +#include "lib/global_contexts.h" + +static bool get_g_lock_ctx(TALLOC_CTX *mem_ctx, + struct tevent_context **ev, + struct messaging_context **msg, + struct g_lock_ctx **ctx) +{ + *ev = global_event_context(); + if (*ev == NULL) { + fprintf(stderr, "tevent_context_init failed\n"); + return false; + } + *msg = global_messaging_context(); + if (*msg == NULL) { + fprintf(stderr, "messaging_init failed\n"); + TALLOC_FREE(*ev); + return false; + } + *ctx = g_lock_ctx_init(*ev, *msg); + if (*ctx == NULL) { + fprintf(stderr, "g_lock_ctx_init failed\n"); + TALLOC_FREE(*msg); + TALLOC_FREE(*ev); + return false; + } + + return true; +} + +bool run_g_lock1(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct g_lock_ctx *ctx = NULL; + const char *lockname = "lock1"; + NTSTATUS status; + bool ret = false; + bool ok; + + ok = get_g_lock_ctx(talloc_tos(), &ev, &msg, &ctx); + if (!ok) { + goto fail; + } + + status = g_lock_lock(ctx, string_term_tdb_data(lockname), G_LOCK_WRITE, + (struct timeval) { .tv_sec = 1 }, + NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_lock failed: %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_lock(ctx, string_term_tdb_data(lockname), G_LOCK_WRITE, + (struct timeval) { .tv_sec = 1 }, + NULL, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_WAS_LOCKED)) { + fprintf(stderr, "Double lock got %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_unlock(ctx, string_term_tdb_data(lockname)); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_unlock failed: %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_unlock(ctx, string_term_tdb_data(lockname)); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) { + fprintf(stderr, "g_lock_unlock returned: %s\n", + nt_errstr(status)); + goto fail; + } + + ret = true; +fail: + TALLOC_FREE(ctx); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} + +struct lock2_parser_state { + uint8_t *rdata; + bool ok; +}; + +static void lock2_parser(struct server_id exclusive, + size_t num_shared, + const struct server_id *shared, + const uint8_t *data, + size_t datalen, + void *private_data) +{ + struct lock2_parser_state *state = private_data; + + if (datalen != sizeof(uint8_t)) { + return; + } + *state->rdata = *data; + state->ok = true; +} + +/* + * Test g_lock_write_data + */ + +bool run_g_lock2(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct g_lock_ctx *ctx = NULL; + const char *lockname = "lock2"; + uint8_t data = 42; + uint8_t rdata; + struct lock2_parser_state state = { .rdata = &rdata }; + NTSTATUS status; + bool ret = false; + bool ok; + + ok = get_g_lock_ctx(talloc_tos(), &ev, &msg, &ctx); + if (!ok) { + goto fail; + } + + status = g_lock_write_data(ctx, string_term_tdb_data(lockname), + &data, sizeof(data)); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_LOCKED)) { + fprintf(stderr, "unlocked g_lock_write_data returned %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_lock(ctx, string_term_tdb_data(lockname), G_LOCK_WRITE, + (struct timeval) { .tv_sec = 1 }, + NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_lock returned %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_write_data(ctx, string_term_tdb_data(lockname), + &data, sizeof(data)); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_write_data failed: %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_unlock(ctx, string_term_tdb_data(lockname)); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_unlock failed: %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_dump(ctx, string_term_tdb_data(lockname), + lock2_parser, &state); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_dump failed: %s\n", + nt_errstr(status)); + goto fail; + } + + if (!state.ok) { + fprintf(stderr, "Could not parse data\n"); + goto fail; + } + if (rdata != data) { + fprintf(stderr, "Returned %"PRIu8", expected %"PRIu8"\n", + rdata, data); + goto fail; + } + + ret = true; +fail: + TALLOC_FREE(ctx); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} + +struct lock3_parser_state { + struct server_id self; + enum g_lock_type lock_type; + bool ok; +}; + +static void lock3_parser(struct server_id exclusive, + size_t num_shared, + const struct server_id *shared, + const uint8_t *data, + size_t datalen, + void *private_data) +{ + struct lock3_parser_state *state = private_data; + size_t num_locks = num_shared + ((exclusive.pid != 0) ? 1 : 0); + const struct server_id *pid; + + if (datalen != 0) { + fprintf(stderr, "datalen=%zu\n", datalen); + return; + } + if (num_locks != 1) { + fprintf(stderr, "num_locks=%zu\n", num_locks); + return; + } + + if (state->lock_type == G_LOCK_WRITE) { + if (exclusive.pid == 0) { + fprintf(stderr, "Found READ, expected WRITE\n"); + return; + } + } else { + if (exclusive.pid != 0) { + fprintf(stderr, "Found WRITE, expected READ\n"); + return; + } + } + + pid = (exclusive.pid != 0) ? &exclusive : &shared[0]; + + if (!server_id_equal(pid, &state->self)) { + struct server_id_buf tmp1, tmp2; + fprintf(stderr, "found pid %s, expected %s\n", + server_id_str_buf(*pid, &tmp1), + server_id_str_buf(state->self, &tmp2)); + return; + } + + state->ok = true; +} + +/* + * Test lock upgrade/downgrade + */ + +bool run_g_lock3(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct g_lock_ctx *ctx = NULL; + const char *lockname = "lock3"; + struct lock3_parser_state state; + NTSTATUS status; + bool ret = false; + bool ok; + + ok = get_g_lock_ctx(talloc_tos(), &ev, &msg, &ctx); + if (!ok) { + goto fail; + } + + state.self = messaging_server_id(msg); + + status = g_lock_lock(ctx, string_term_tdb_data(lockname), G_LOCK_READ, + (struct timeval) { .tv_sec = 1 }, + NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_lock returned %s\n", + nt_errstr(status)); + goto fail; + } + + state.lock_type = G_LOCK_READ; + state.ok = false; + + status = g_lock_dump(ctx, string_term_tdb_data(lockname), + lock3_parser, &state); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) { + fprintf(stderr, "g_lock_dump returned %s\n", + nt_errstr(status)); + goto fail; + } + if (!state.ok) { + goto fail; + } + + status = g_lock_lock(ctx, string_term_tdb_data(lockname), G_LOCK_UPGRADE, + (struct timeval) { .tv_sec = 1 }, + NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_lock returned %s\n", + nt_errstr(status)); + goto fail; + } + + state.lock_type = G_LOCK_WRITE; + state.ok = false; + + status = g_lock_dump(ctx, string_term_tdb_data(lockname), + lock3_parser, &state); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) { + fprintf(stderr, "g_lock_dump returned %s\n", + nt_errstr(status)); + goto fail; + } + if (!state.ok) { + goto fail; + } + + + ret = true; +fail: + TALLOC_FREE(ctx); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} + +static bool lock4_child(const char *lockname, + enum g_lock_type lock_type, + int ready_pipe, + int exit_pipe) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct g_lock_ctx *ctx = NULL; + NTSTATUS status; + ssize_t n; + bool ok; + + ok = get_g_lock_ctx(talloc_tos(), &ev, &msg, &ctx); + if (!ok) { + return false; + } + + status = g_lock_lock( + ctx, + string_term_tdb_data(lockname), + lock_type, + (struct timeval) { .tv_sec = 1 }, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "child: g_lock_lock returned %s\n", + nt_errstr(status)); + return false; + } + + n = sys_write(ready_pipe, &ok, sizeof(ok)); + if (n != sizeof(ok)) { + fprintf(stderr, "child: write failed\n"); + return false; + } + + if (ok) { + n = sys_read(exit_pipe, &ok, sizeof(ok)); + if (n != 0) { + fprintf(stderr, "child: read failed\n"); + return false; + } + } + + return true; +} + +static void lock4_done(struct tevent_req *subreq) +{ + int *done = tevent_req_callback_data_void(subreq); + NTSTATUS status; + + status = g_lock_lock_recv(subreq); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_lock_recv returned %s\n", + nt_errstr(status)); + *done = -1; + return; + } + *done = 1; +} + +static void lock4_waited(struct tevent_req *subreq) +{ + int *exit_pipe = tevent_req_callback_data_void(subreq); + pid_t child; + int status; + bool ok; + + printf("waited\n"); + + ok = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (!ok) { + fprintf(stderr, "tevent_wakeup_recv failed\n"); + } + close(*exit_pipe); + + child = wait(&status); + + printf("child %d exited with %d\n", (int)child, status); +} + +struct lock4_check_state { + struct server_id me; + bool ok; +}; + +static void lock4_check(struct server_id exclusive, + size_t num_shared, + const struct server_id *shared, + const uint8_t *data, + size_t datalen, + void *private_data) +{ + struct lock4_check_state *state = private_data; + size_t num_locks = num_shared + ((exclusive.pid != 0) ? 1 : 0); + + if (num_locks != 1) { + fprintf(stderr, "num_locks=%zu\n", num_locks); + return; + } + + if (exclusive.pid == 0) { + fprintf(stderr, "Wrong lock type, not WRITE\n"); + return; + } + + if (!server_id_equal(&state->me, &exclusive)) { + struct server_id_buf buf1, buf2; + fprintf(stderr, "me=%s, locker=%s\n", + server_id_str_buf(state->me, &buf1), + server_id_str_buf(exclusive, &buf2)); + return; + } + + state->ok = true; +} + +/* + * Test a lock conflict: Contend with a WRITE lock + */ + +bool run_g_lock4(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct g_lock_ctx *ctx = NULL; + const char *lockname = "lock4"; + TDB_DATA key = string_term_tdb_data(lockname); + pid_t child; + int ready_pipe[2]; + int exit_pipe[2]; + NTSTATUS status; + bool ret = false; + struct tevent_req *req; + bool ok; + int done; + + if ((pipe(ready_pipe) != 0) || (pipe(exit_pipe) != 0)) { + perror("pipe failed"); + return false; + } + + child = fork(); + + ok = get_g_lock_ctx(talloc_tos(), &ev, &msg, &ctx); + if (!ok) { + goto fail; + } + + if (child == -1) { + perror("fork failed"); + return false; + } + + if (child == 0) { + close(ready_pipe[0]); + close(exit_pipe[1]); + ok = lock4_child( + lockname, G_LOCK_WRITE, ready_pipe[1], exit_pipe[0]); + exit(ok ? 0 : 1); + } + + close(ready_pipe[1]); + close(exit_pipe[0]); + + if (sys_read(ready_pipe[0], &ok, sizeof(ok)) != sizeof(ok)) { + perror("read failed"); + return false; + } + + if (!ok) { + fprintf(stderr, "child returned error\n"); + return false; + } + + status = g_lock_lock(ctx, key, G_LOCK_WRITE, + (struct timeval) { .tv_usec = 1 }, + NULL, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) { + fprintf(stderr, "g_lock_lock returned %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_lock(ctx, key, G_LOCK_READ, + (struct timeval) { .tv_usec = 1 }, + NULL, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) { + fprintf(stderr, "g_lock_lock returned %s\n", + nt_errstr(status)); + goto fail; + } + + req = g_lock_lock_send(ev, ev, ctx, key, G_LOCK_WRITE, NULL, NULL); + if (req == NULL) { + fprintf(stderr, "g_lock_lock send failed\n"); + goto fail; + } + tevent_req_set_callback(req, lock4_done, &done); + + req = tevent_wakeup_send(ev, ev, timeval_current_ofs(1, 0)); + if (req == NULL) { + fprintf(stderr, "tevent_wakeup_send failed\n"); + goto fail; + } + tevent_req_set_callback(req, lock4_waited, &exit_pipe[1]); + + done = 0; + + while (done == 0) { + int tevent_ret = tevent_loop_once(ev); + if (tevent_ret != 0) { + perror("tevent_loop_once failed"); + goto fail; + } + } + + { + struct lock4_check_state state = { + .me = messaging_server_id(msg) + }; + + status = g_lock_dump(ctx, key, lock4_check, &state); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_dump failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (!state.ok) { + fprintf(stderr, "lock4_check failed\n"); + goto fail; + } + } + + ret = true; +fail: + TALLOC_FREE(ctx); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} + +/* + * Test a lock conflict: Contend with a READ lock + */ + +bool run_g_lock4a(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct g_lock_ctx *ctx = NULL; + const char *lockname = "lock4a"; + TDB_DATA key = string_term_tdb_data(lockname); + pid_t child; + int ready_pipe[2]; + int exit_pipe[2]; + NTSTATUS status; + bool ret = false; + struct tevent_req *req; + bool ok; + int done; + + if ((pipe(ready_pipe) != 0) || (pipe(exit_pipe) != 0)) { + perror("pipe failed"); + return false; + } + + child = fork(); + + ok = get_g_lock_ctx(talloc_tos(), &ev, &msg, &ctx); + if (!ok) { + goto fail; + } + + if (child == -1) { + perror("fork failed"); + return false; + } + + if (child == 0) { + close(ready_pipe[0]); + close(exit_pipe[1]); + ok = lock4_child( + lockname, G_LOCK_READ, ready_pipe[1], exit_pipe[0]); + exit(ok ? 0 : 1); + } + + close(ready_pipe[1]); + close(exit_pipe[0]); + + if (sys_read(ready_pipe[0], &ok, sizeof(ok)) != sizeof(ok)) { + perror("read failed"); + return false; + } + + if (!ok) { + fprintf(stderr, "child returned error\n"); + return false; + } + + status = g_lock_lock(ctx, key, G_LOCK_WRITE, + (struct timeval) { .tv_usec = 1 }, + NULL, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) { + fprintf(stderr, "g_lock_lock returned %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_lock(ctx, key, G_LOCK_READ, + (struct timeval) { .tv_usec = 1 }, + NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_lock returned %s\n", + nt_errstr(status)); + goto fail; + } + + status = g_lock_unlock(ctx, key); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, + "g_lock_unlock returned %s\n", + nt_errstr(status)); + goto fail; + } + + req = g_lock_lock_send(ev, ev, ctx, key, G_LOCK_WRITE, NULL, NULL); + if (req == NULL) { + fprintf(stderr, "g_lock_lock send failed\n"); + goto fail; + } + tevent_req_set_callback(req, lock4_done, &done); + + req = tevent_wakeup_send(ev, ev, timeval_current_ofs(1, 0)); + if (req == NULL) { + fprintf(stderr, "tevent_wakeup_send failed\n"); + goto fail; + } + tevent_req_set_callback(req, lock4_waited, &exit_pipe[1]); + + done = 0; + + while (done == 0) { + int tevent_ret = tevent_loop_once(ev); + if (tevent_ret != 0) { + perror("tevent_loop_once failed"); + goto fail; + } + } + + { + struct lock4_check_state state = { + .me = messaging_server_id(msg) + }; + + status = g_lock_dump(ctx, key, lock4_check, &state); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_dump failed: %s\n", + nt_errstr(status)); + goto fail; + } + if (!state.ok) { + fprintf(stderr, "lock4_check failed\n"); + goto fail; + } + } + + ret = true; +fail: + TALLOC_FREE(ctx); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} + +struct lock5_parser_state { + size_t num_locks; +}; + +static void lock5_parser(struct server_id exclusive, + size_t num_shared, + const struct server_id *shared, + const uint8_t *data, + size_t datalen, + void *private_data) +{ + struct lock5_parser_state *state = private_data; + state->num_locks = num_shared + ((exclusive.pid != 0) ? 1 : 0); +} + +/* + * Test heuristic cleanup + */ + +bool run_g_lock5(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct g_lock_ctx *ctx = NULL; + const char *lockname = "lock5"; + pid_t child; + int exit_pipe[2], ready_pipe[2]; + NTSTATUS status; + size_t i, nprocs; + int ret; + bool ok; + ssize_t nread; + char c; + + nprocs = 5; + + if ((pipe(exit_pipe) != 0) || (pipe(ready_pipe) != 0)) { + perror("pipe failed"); + return false; + } + + ok = get_g_lock_ctx(talloc_tos(), &ev, &msg, &ctx); + if (!ok) { + fprintf(stderr, "get_g_lock_ctx failed"); + return false; + } + + for (i=0; inum_locks = num_shared + ((exclusive.pid != 0) ? 1 : 0); +} + +/* + * Test cleanup with contention and stale locks + */ + +bool run_g_lock6(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg = NULL; + struct g_lock_ctx *ctx = NULL; + TDB_DATA lockname = string_term_tdb_data("lock6"); + pid_t child; + int exit_pipe[2], ready_pipe[2]; + NTSTATUS status; + size_t i, nprocs; + int ret; + bool ok; + ssize_t nread; + char c; + + if ((pipe(exit_pipe) != 0) || (pipe(ready_pipe) != 0)) { + perror("pipe failed"); + return false; + } + + ok = get_g_lock_ctx(talloc_tos(), &ev, &msg, &ctx); + if (!ok) { + fprintf(stderr, "get_g_lock_ctx failed"); + return false; + } + + /* + * Wipe all stale locks -- in clustered mode there's no + * CLEAR_IF_FIRST + */ + status = g_lock_lock(ctx, lockname, G_LOCK_WRITE, + (struct timeval) { .tv_sec = 1 }, + NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_lock failed: %s\n", + nt_errstr(status)); + return false; + } + status = g_lock_unlock(ctx, lockname); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "g_lock_unlock failed: %s\n", + nt_errstr(status)); + return false; + } + + nprocs = 2; + for (i=0; i 1.0) { + printf("%8u locks/sec\r", + (unsigned)(2*count/end_timer())); + fflush(stdout); + start_timer(); + count=0; + } + } + + ret = true; +fail: + TALLOC_FREE(ctx); + TALLOC_FREE(msg); + TALLOC_FREE(ev); + return ret; +} diff --git a/source3/torture/test_hidenewfiles.c b/source3/torture/test_hidenewfiles.c new file mode 100644 index 0000000..6d6811c --- /dev/null +++ b/source3/torture/test_hidenewfiles.c @@ -0,0 +1,234 @@ +/* + * Unix SMB/CIFS implementation. + * Test "hide new files timeout" + * Copyright (C) Volker Lendecke 2018 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "libcli/security/security.h" + +static NTSTATUS servertime( + struct cli_state *cli, const char *fname, struct timeval *tv) +{ + struct smb_create_returns cr; + NTSTATUS status; + uint16_t fnum; + + status = cli_ntcreate( + cli, + fname, + 0, + FILE_GENERIC_WRITE|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + 0, + FILE_CREATE, + FILE_DELETE_ON_CLOSE, + 0, + &fnum, + &cr); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_ntcreate failed: %s\n", nt_errstr(status)); + return status; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_close failed: %s\n", nt_errstr(status)); + return status; + } + + nttime_to_timeval(tv, cr.creation_time); + + return NT_STATUS_OK; +} + +struct have_file_state { + bool found; + const char *fname; +}; + +static NTSTATUS have_file_fn(struct file_info *f, + const char *mask, + void *private_data) +{ + struct have_file_state *state = private_data; + state->found |= strequal(f->name, state->fname); + return NT_STATUS_OK; +} + +static bool have_file(struct cli_state *cli, const char *fname) +{ + struct have_file_state state = { .fname = fname }; + NTSTATUS status; + + status = cli_list( + cli, + "*", + FILE_ATTRIBUTE_DIRECTORY| + FILE_ATTRIBUTE_SYSTEM| + FILE_ATTRIBUTE_HIDDEN, + have_file_fn, + &state); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_list failed: %s\n", nt_errstr(status)); + return false; + } + + return state.found; +} + +bool run_hidenewfiles(int dummy) +{ + const char *tsname = "timestamp.txt"; + const char *fname = "new_hidden.txt"; + struct cli_state *cli; + struct smb_create_returns cr; + struct timeval create_time; + uint16_t fnum; + NTSTATUS status; + bool ret = false; + bool gotit = false; + bool ok; + + /* what is configured in smb.conf */ + unsigned hideunreadable_seconds = 5; + + ok = torture_open_connection_flags(&cli, 0, 0); + if (!ok) { + return false; + } + + cli_unlink(cli, tsname, FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate( + cli, + fname, + 0, + FILE_GENERIC_WRITE|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + 0, + FILE_CREATE, + 0, + 0, + &fnum, + &cr); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_ntcreate failed: %s\n", nt_errstr(status)); + return false; + } + nttime_to_timeval(&create_time, cr.last_write_time); + + while (!gotit) { + struct timeval now; + double age; + + gotit = have_file(cli, fname); + + status = servertime(cli, tsname, &now); + if (!NT_STATUS_IS_OK(status)) { + d_printf("servertime failed: %s\n", + nt_errstr(status)); + goto fail; + } + age = timeval_elapsed2(&create_time, &now); + + if ((age < hideunreadable_seconds) && gotit) { + d_printf("Found file at age of %f\n", age); + goto fail; + } + if ((age > (hideunreadable_seconds*10)) && !gotit) { + d_printf("Did not find file after %f seconds\n", age); + goto fail; + } + if (gotit) { + break; + } + + smb_msleep(1000); + } + + ret = true; +fail: + cli_nt_delete_on_close(cli, fnum, true); + cli_close(cli, fnum); + + return ret; +} + +bool run_hidenewfiles_showdirs(int dummy) +{ + const char *dname = "dir"; + const char *fname = "dir/x.txt"; + struct cli_state *cli; + struct smb_create_returns cr; + struct timeval create_time; + uint16_t fnum = UINT16_MAX; + NTSTATUS status; + bool ret = false; + bool gotit = false; + bool ok; + + ok = torture_open_connection_flags(&cli, 0, 0); + if (!ok) { + return false; + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN); + cli_rmdir(cli, dname); + + status = cli_mkdir(cli, dname); + if (!NT_STATUS_IS_OK(status)) { + d_printf("mkdir(%s) failed: %s\n", dname, nt_errstr(status)); + goto fail; + } + + status = cli_ntcreate( + cli, + fname, + 0, + FILE_GENERIC_WRITE|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + 0, + FILE_CREATE, + 0, + 0, + &fnum, + &cr); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_ntcreate failed: %s\n", nt_errstr(status)); + goto fail; + } + nttime_to_timeval(&create_time, cr.last_write_time); + + gotit = have_file(cli, dname); + if (!gotit) { + d_printf("%s was hidden\n", dname); + goto fail; + } + + ret = true; +fail: + if (fnum != UINT16_MAX) { + cli_nt_delete_on_close(cli, fnum, true); + cli_close(cli, fnum); + } + cli_rmdir(cli, dname); + + return ret; +} diff --git a/source3/torture/test_idmap_cache.c b/source3/torture/test_idmap_cache.c new file mode 100644 index 0000000..b9cba3b --- /dev/null +++ b/source3/torture/test_idmap_cache.c @@ -0,0 +1,122 @@ +/* + * Unix SMB/CIFS implementation. + * Test dbwrap_watch API + * Copyright (C) Volker Lendecke 2017 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "torture/proto.h" +#include "lib/idmap_cache.h" +#include "librpc/gen_ndr/idmap.h" +#include "libcli/security/dom_sid.h" + +bool run_local_idmap_cache1(int dummy) +{ + struct dom_sid sid, found_sid; + struct unixid xid, found_xid; + bool ret = false; + bool expired = false; + + xid = (struct unixid) { .id = 1234, .type = ID_TYPE_UID }; + dom_sid_parse("S-1-5-21-2864185242-3846410404-2398417794-1235", &sid); + idmap_cache_set_sid2unixid(&sid, &xid); + + ret = idmap_cache_find_sid2unixid(&sid, &found_xid, &expired); + if (!ret) { + fprintf(stderr, "idmap_cache_find_sid2unixid failed\n"); + goto done; + } + if (expired) { + fprintf(stderr, + "idmap_cache_find_sid2unixid returned an expired " + "value\n"); + goto done; + } + if ((xid.type != found_xid.type) || (xid.id != found_xid.id)) { + fprintf(stderr, + "idmap_cache_find_sid2unixid returned wrong " + "values\n"); + goto done; + } + + ret = idmap_cache_find_xid2sid(&xid, &found_sid, &expired); + if (!ret) { + fprintf(stderr, "idmap_cache_find_xid2sid failed\n"); + goto done; + } + if (expired) { + fprintf(stderr, + "idmap_cache_find_xid2sid returned an expired " + "value\n"); + goto done; + } + if (!dom_sid_equal(&sid, &found_sid)) { + fprintf(stderr, + "idmap_cache_find_xid2sid returned wrong sid\n"); + goto done; + } + + xid.type = ID_TYPE_GID; + + ret = idmap_cache_find_xid2sid(&xid, &found_sid, &expired); + if (ret) { + fprintf(stderr, + "idmap_cache_find_xid2sid found a GID where it " + "should not\n"); + goto done; + } + + idmap_cache_del_sid(&sid); + + xid.type = ID_TYPE_UID; + ret = idmap_cache_find_xid2sid(&xid, &found_sid, &expired); + if (ret) { + fprintf(stderr, + "idmap_cache_find_xid2sid found a UID where it " + "should not\n"); + goto done; + } + + /* + * Test that negative mappings can also be cached + */ + sid = (struct dom_sid) {0}; + xid = (struct unixid) { .id = 1234, .type = ID_TYPE_UID }; + idmap_cache_set_sid2unixid(&sid, &xid); + + ret = idmap_cache_find_xid2sid(&xid, &found_sid, &expired); + if (!ret) { + fprintf(stderr, + "idmap_cache_find_xid2sid failed to find " + "negative mapping\n"); + goto done; + } + if (expired) { + fprintf(stderr, + "idmap_cache_find_xid2sid returned an expired " + "value\n"); + goto done; + } + if (!dom_sid_equal(&sid, &found_sid)) { + fprintf(stderr, + "idmap_cache_find_xid2sid returned wrong sid\n"); + goto done; + } + + ret = true; +done: + return ret; +} diff --git a/source3/torture/test_idmap_tdb_common.c b/source3/torture/test_idmap_tdb_common.c new file mode 100644 index 0000000..825ee3e --- /dev/null +++ b/source3/torture/test_idmap_tdb_common.c @@ -0,0 +1,1047 @@ +/* + Unix SMB/CIFS implementation. + IDMAP TDB common code tester + + Copyright (C) Christian Ambach 2012 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "system/filesys.h" +#include "torture/proto.h" +#include "idmap.h" +#include "winbindd/idmap_rw.h" +#include "winbindd/idmap_tdb_common.h" +#include "winbindd/winbindd.h" +#include "winbindd/winbindd_proto.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_open.h" +#include "../libcli/security/dom_sid.h" + +#define HWM_GROUP "GROUP HWM" +#define HWM_USER "USER HWM" + +#define LOW_ID 100 +#define HIGH_ID 199 + +#define DOM_SID1 "S-1-5-21-1234-5678-9012" +#define DOM_SID2 "S-1-5-21-0123-5678-9012" +#define DOM_SID3 "S-1-5-21-0012-5678-9012" +#define DOM_SID4 "S-1-5-21-0001-5678-9012" +#define DOM_SID5 "S-1-5-21-2345-5678-9012" +#define DOM_SID6 "S-1-5-21-3456-5678-9012" + +/* overwrite some winbind internal functions */ +struct winbindd_domain *find_domain_from_name(const char *domain_name) +{ + return NULL; +} + +bool get_global_winbindd_state_offline(void) { + return false; +} + +bool winbindd_use_idmap_cache(void) { + return false; +} + +static bool open_db(struct idmap_tdb_common_context *ctx) +{ + NTSTATUS status; + char *db_path; + + if(ctx->db) { + /* already open */ + return true; + } + + db_path = talloc_asprintf(talloc_tos(), "%s/idmap_test.tdb", + lp_private_dir()); + if(!db_path) { + DEBUG(0, ("Out of memory!\n")); + return false; + } + + ctx->db = db_open(ctx, db_path, 0, TDB_DEFAULT, + O_RDWR | O_CREAT, 0600, + DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE); + + if(!ctx->db) { + DEBUG(0, ("Failed to open database: %s\n", strerror(errno))); + return false; + } + + if(dbwrap_transaction_start(ctx->db) != 0) { + DEBUG(0, ("Failed to start transaction!\n")); + return false; + } + + status = dbwrap_store_uint32_bystring(ctx->db, ctx->hwmkey_uid, + LOW_ID); + if(!NT_STATUS_IS_OK(status)) { + dbwrap_transaction_cancel(ctx->db); + return false; + } + + status = dbwrap_store_uint32_bystring(ctx->db, ctx->hwmkey_gid, + LOW_ID); + if(!NT_STATUS_IS_OK(status)) { + dbwrap_transaction_cancel(ctx->db); + return false; + } + + if(dbwrap_transaction_commit(ctx->db) != 0) { + DEBUG(0, ("Failed to commit transaction!\n")); + return false; + } + + return true; +} + +static NTSTATUS idmap_test_tdb_db_init(struct idmap_domain *dom) +{ + struct idmap_tdb_common_context *ret; + + DBG_DEBUG("called for domain '%s'\n", dom->name); + + ret = talloc_zero(dom, struct idmap_tdb_common_context); + if (ret == NULL) { + return NT_STATUS_NO_MEMORY; + } + ret->rw_ops = talloc_zero(ret, struct idmap_rw_ops); + if (ret->rw_ops == NULL) { + TALLOC_FREE(ret); + return NT_STATUS_NO_MEMORY; + } + + ret->max_id = HIGH_ID; + ret->hwmkey_uid = HWM_USER; + ret->hwmkey_gid = HWM_GROUP; + + ret->rw_ops->get_new_id = idmap_tdb_common_get_new_id; + ret->rw_ops->set_mapping = idmap_tdb_common_set_mapping; + + if (!open_db(ret)) { + TALLOC_FREE(ret); + return NT_STATUS_INTERNAL_ERROR; + }; + + dom->private_data = ret; + + return NT_STATUS_OK; +} + +static struct idmap_domain *createdomain(TALLOC_CTX *memctx) +{ + struct idmap_domain *dom; + struct idmap_methods *m; + + dom = talloc_zero(memctx, struct idmap_domain); + dom->name = "*"; + dom->low_id = LOW_ID; + dom->high_id = HIGH_ID; + dom->read_only = false; + m = talloc_zero(dom, struct idmap_methods); + *m = (struct idmap_methods) { + .init = idmap_test_tdb_db_init, + .sids_to_unixids = idmap_tdb_common_sids_to_unixids, + .unixids_to_sids = idmap_tdb_common_unixids_to_sids, + .allocate_id = idmap_tdb_common_get_new_id, + }; + dom->methods = m; + + return dom; +} + +static bool test_getnewid1(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct unixid id; + + id.type = ID_TYPE_UID; + + status = idmap_tdb_common_get_new_id(dom, &id); + + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_getnewid1: Could not allocate id!\n")); + return false; + } + + if(id.id == 0) { + DEBUG(0, ("test_getnewid1: Allocate returned " + "empty id!\n")); + return false; + } + + if(id.id > HIGH_ID || id.id < LOW_ID) { + DEBUG(0, ("test_getnewid1: Allocate returned " + "out of range id!\n")); + return false; + } + + DEBUG(0, ("test_getnewid1: PASSED!\n")); + + return true; +} + +static bool test_getnewid2(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct unixid id; + int i, left; + + id.type = ID_TYPE_UID; + + status = idmap_tdb_common_get_new_id(dom, &id); + + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_getnewid2: Could not allocate id!\n")); + return false; + } + + if(id.id == 0) { + DEBUG(0, ("test_getnewid2: Allocate returned " + "empty id!\n")); + return false; + } + + if(id.id > HIGH_ID || id.id < LOW_ID) { + DEBUG(0, ("test_getnewid2: Allocate returned " + "out of range id!\n")); + return false; + } + + /* how many ids are left? */ + + left = HIGH_ID - id.id; + + /* consume them all */ + for(i = 0; i HIGH_ID) { + DEBUG(0, ("test_getnewid2: Allocate returned " + "out of range id (%d)!\n", id.id)); + return false; + } + } + + /* one more must fail */ + status = idmap_tdb_common_get_new_id(dom, &id); + + if(NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_getnewid2: Could allocate id (%d) from " + "depleted pool!\n", id.id)); + return false; + } + + DEBUG(0, ("test_getnewid2: PASSED!\n")); + + return true; +} + +static bool test_setmap1(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map map; + + ZERO_STRUCT(map); + + /* test for correct return code with invalid data */ + + status = idmap_tdb_common_set_mapping(dom, NULL); + if(!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { + DEBUG(0, ("test_setmap1: bad parameter handling!\n")); + return false; + } + + status = idmap_tdb_common_set_mapping(dom, &map); + if(!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { + DEBUG(0, ("test_setmap1: bad parameter handling!\n")); + return false; + } + + map.sid = dom_sid_parse_talloc(memctx, DOM_SID1 "-100"); + + map.xid.type = ID_TYPE_NOT_SPECIFIED; + map.xid.id = 4711; + + status = idmap_tdb_common_set_mapping(dom, &map); + if(!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { + DEBUG(0, ("test_setmap1: bad parameter handling!\n")); + return false; + } + + /* now the good ones */ + map.xid.type = ID_TYPE_UID; + map.xid.id = 0; + + status = idmap_tdb_common_get_new_id(dom, &(map.xid)); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_setmap1: get_new_uid failed!\n")); + return false; + } + + status = idmap_tdb_common_set_mapping(dom, &map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_setmap1: setting UID mapping failed!\n")); + return false; + } + + /* try to set the same mapping again as group (must fail) */ + + map.xid.type = ID_TYPE_GID; + status = idmap_tdb_common_set_mapping(dom, &map); + if(NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_setmap1: could create map for " + "group and user!\n")); + return false; + } + + /* now a group with a different SID*/ + map.xid.id = 0; + + map.sid = dom_sid_parse_talloc(memctx, DOM_SID1 "-101"); + + status = idmap_tdb_common_get_new_id(dom, &(map.xid)); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_setmap1: get_new_gid failed!\n")); + return false; + } + + status = idmap_tdb_common_set_mapping(dom, &map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_setmap1: setting GID mapping failed!\n")); + return false; + } + DEBUG(0, ("test_setmap1: PASSED!\n")); + + return true; +} + +static bool test_sid2unixid1(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status1, status2, status3; + struct id_map map; + + /* check for correct dealing with bad parameters */ + status1 = idmap_tdb_common_sid_to_unixid(NULL, &map); + status2 = idmap_tdb_common_sid_to_unixid(dom, NULL); + status3 = idmap_tdb_common_sid_to_unixid(NULL, NULL); + + if(!NT_STATUS_EQUAL(NT_STATUS_INVALID_PARAMETER, status1) || + !NT_STATUS_EQUAL(NT_STATUS_INVALID_PARAMETER, status2) || + !NT_STATUS_EQUAL(NT_STATUS_INVALID_PARAMETER, status3)) { + DEBUG(0, ("test_setmap1: bad parameter handling!\n")); + return false; + } + + DEBUG(0, ("test_unixid2sid1: PASSED!\n")); + + return true; +} + +static bool test_sid2unixid2(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map uid_map, gid_map, test_map; + bool doagain = true; + + ZERO_STRUCT(uid_map); + ZERO_STRUCT(gid_map); + + /* create two mappings for a UID and GID */ + +again: + + uid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID2 "-1000"); + uid_map.xid.type = ID_TYPE_UID; + + gid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID2 "-1001"); + gid_map.xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_new_mapping(dom, &uid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sid2unixid2: could not create uid map!\n")); + return false; + } + + status = idmap_tdb_common_new_mapping(dom, &gid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sid2unixid2: could not create gid map!\n")); + return false; + } + + /* now read them back */ + ZERO_STRUCT(test_map); + test_map.sid = uid_map.sid; + + status = idmap_tdb_common_sid_to_unixid(dom, &test_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sid2unixid2: sid2unixid failed for uid!\n")); + return false; + } + + if(test_map.xid.id!=uid_map.xid.id) { + DEBUG(0, ("test_sid2unixid2: sid2unixid returned wrong uid!\n")); + return false; + } + + test_map.sid = gid_map.sid; + + status = idmap_tdb_common_sid_to_unixid(dom, &test_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sid2unixid2: sid2unixid failed for gid!\n")); + return false; + } + + if(test_map.xid.id!=gid_map.xid.id) { + DEBUG(0, ("test_sid2unixid2: sid2unixid returned wrong gid!\n")); + return false; + } + + /* + * Go through the same tests again once to see if trying to recreate + * a mapping that was already created will work or not + */ + if(doagain) { + doagain = false; + goto again; + } + + DEBUG(0, ("test_sid2unixid2: PASSED!\n")); + + return true; +} + +static bool test_sids2unixids1(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map uid_map, gid_map, **test_maps; + + ZERO_STRUCT(uid_map); + ZERO_STRUCT(gid_map); + + /* create two mappings for a UID and GID */ + + uid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID4 "-1000"); + uid_map.xid.type = ID_TYPE_UID; + + gid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID4 "-1001"); + gid_map.xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_new_mapping(dom, &uid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sids2unixids1: could not create uid map!\n")); + return false; + } + + status = idmap_tdb_common_new_mapping(dom, &gid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sids2unixids1: could not create gid map!\n")); + return false; + } + + /* now read them back */ + test_maps = talloc_zero_array(memctx, struct id_map*, 3); + + test_maps[0] = talloc(test_maps, struct id_map); + test_maps[1] = talloc(test_maps, struct id_map); + test_maps[2] = NULL; + + test_maps[0]->sid = talloc(test_maps, struct dom_sid); + test_maps[1]->sid = talloc(test_maps, struct dom_sid); + sid_copy(test_maps[0]->sid, uid_map.sid); + sid_copy(test_maps[1]->sid, gid_map.sid); + + status = idmap_tdb_common_sids_to_unixids(dom, test_maps); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sids2sunixids1: sids2unixids failed!\n")); + talloc_free(test_maps); + return false; + } + + if(test_maps[0]->xid.id!=uid_map.xid.id || + test_maps[1]->xid.id!=gid_map.xid.id ) { + DEBUG(0, ("test_sids2unixids1: sid2unixid returned wrong xid!\n")); + talloc_free(test_maps); + return false; + } + + DEBUG(0, ("test_sids2unixids1: PASSED!\n")); + + talloc_free(test_maps); + + return true; +} + +static bool test_sids2unixids2(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map **test_maps; + struct unixid save; + + test_maps = talloc_zero_array(memctx, struct id_map*, 3); + + test_maps[0] = talloc(test_maps, struct id_map); + test_maps[1] = talloc(test_maps, struct id_map); + test_maps[2] = NULL; + + /* ask for two new mappings for a UID and GID */ + test_maps[0]->sid = dom_sid_parse_talloc(test_maps, DOM_SID4 "-1003"); + test_maps[0]->xid.type = ID_TYPE_UID; + test_maps[1]->sid = dom_sid_parse_talloc(test_maps, DOM_SID4 "-1004"); + test_maps[1]->xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_sids_to_unixids(dom, test_maps); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sids2sunixids2: sids2unixids " + "failed (%s)!\n", nt_errstr(status))); + talloc_free(test_maps); + return false; + } + + if(test_maps[0]->xid.id == 0 || test_maps[1]->xid.id == 0) { + DEBUG(0, ("test_sids2sunixids2: sids2unixids " + "returned zero ids!\n")); + talloc_free(test_maps); + return false; + } + + save = test_maps[1]->xid; + + /* ask for a known and a new mapping at the same time */ + talloc_free(test_maps); + test_maps = talloc_zero_array(memctx, struct id_map*, 3); + test_maps[0] = talloc(test_maps, struct id_map); + test_maps[1] = talloc(test_maps, struct id_map); + test_maps[2] = NULL; + + test_maps[0]->sid = dom_sid_parse_talloc(test_maps, DOM_SID4 "-1004"); + test_maps[0]->xid.type = ID_TYPE_GID; + test_maps[1]->sid = dom_sid_parse_talloc(test_maps, DOM_SID4 "-1005"); + test_maps[1]->xid.type = ID_TYPE_UID; + + status = idmap_tdb_common_sids_to_unixids(dom, test_maps); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sids2sunixids2: sids2unixids (2) " + "failed (%s)!\n", nt_errstr(status))); + talloc_free(test_maps); + return false; + } + + if(test_maps[0]->xid.type != save.type || + test_maps[0]->xid.id != save.id) { + DEBUG(0, ("test_sids2sunixids2: second lookup returned " + "different value!\n")); + talloc_free(test_maps); + return false; + } + + if(test_maps[1]->xid.id == 0) { + DEBUG(0, ("test_sids2sunixids2: sids2unixids " + "returned zero id for mixed mapping request!\n")); + talloc_free(test_maps); + return false; + } + + DEBUG(0, ("test_sids2unixids2: PASSED!\n")); + + talloc_free(test_maps); + + return true; +} + +static bool test_sids2unixids3(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map **test_maps; + bool retval = true; + + /* + * check the mapping states: + * NONE_MAPPED, SOME_UNMAPPED, OK (all mapped) + * + * use the ids created by test_sids2unixids1 + * need to make dom read-only + */ + + dom->read_only = true; + + test_maps = talloc_zero_array(memctx, struct id_map*, 3); + + test_maps[0] = talloc(test_maps, struct id_map); + test_maps[1] = talloc(test_maps, struct id_map); + test_maps[2] = NULL; + + /* NONE_MAPPED first */ + test_maps[0]->sid = talloc(test_maps, struct dom_sid); + test_maps[1]->sid = talloc(test_maps, struct dom_sid); + test_maps[0]->sid = dom_sid_parse_talloc(test_maps, + "S-1-5-21-1-2-3-4"); + test_maps[0]->xid.type = ID_TYPE_UID; + + test_maps[1]->sid = dom_sid_parse_talloc(test_maps, + "S-1-5-21-1-2-3-5"); + test_maps[1]->xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_sids_to_unixids(dom, test_maps); + if(!NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED)) { + DEBUG(0, ("test_sids2unixids3: incorrect status " + "(%s), expected NT_STATUS_NONE_MAPPED!\n", + nt_errstr(status))); + retval = false; + goto out; + } + + /* SOME_UNMAPPED */ + test_maps[0]->sid = talloc(test_maps, struct dom_sid); + test_maps[1]->sid = talloc(test_maps, struct dom_sid); + test_maps[0]->sid = dom_sid_parse_talloc(test_maps, + DOM_SID4 "-1000"); + test_maps[0]->xid.type = ID_TYPE_UID; + test_maps[1]->sid = dom_sid_parse_talloc(test_maps, + "S-1-5-21-1-2-3-5"); + test_maps[1]->xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_sids_to_unixids(dom, test_maps); + if(!NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) { + DEBUG(0, ("test_sids2unixids3: incorrect status " + "(%s), expected STATUS_SOME_UNMAPPED!\n", + nt_errstr(status))); + retval = false; + goto out; + } + + /* OK */ + test_maps[0]->sid = talloc(test_maps, struct dom_sid); + test_maps[1]->sid = talloc(test_maps, struct dom_sid); + test_maps[0]->sid = dom_sid_parse_talloc(test_maps, + DOM_SID4 "-1001"); + test_maps[1]->sid = dom_sid_parse_talloc(test_maps, + DOM_SID4 "-1000"); + + status = idmap_tdb_common_sids_to_unixids(dom, test_maps); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_sids2unixids3: incorrect status " + "(%s), expected NT_STATUS_OK!\n", + nt_errstr(status))); + retval = false; + goto out; + } + + DEBUG(0, ("test_sids2unixids3: PASSED!\n")); + +out: + talloc_free(test_maps); + dom->read_only = false; + return retval; +} + +static bool test_unixid2sid1(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status1, status2, status3; + struct id_map map; + + /* check for correct dealing with bad parameters */ + status1 = idmap_tdb_common_unixid_to_sid(NULL, &map); + status2 = idmap_tdb_common_unixid_to_sid(dom, NULL); + status3 = idmap_tdb_common_unixid_to_sid(NULL, NULL); + + if(!NT_STATUS_EQUAL(NT_STATUS_INVALID_PARAMETER, status1) || + !NT_STATUS_EQUAL(NT_STATUS_INVALID_PARAMETER, status2) || + !NT_STATUS_EQUAL(NT_STATUS_INVALID_PARAMETER, status3)) { + DEBUG(0, ("test_setmap1: bad parameter handling!\n")); + return false; + } + + DEBUG(0, ("test_unixid2sid1: PASSED!\n")); + + return true; +} + +static bool test_unixid2sid2(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map *map; + bool retval = true; + + /* ask for mapping that is outside of the range */ + map = talloc(memctx, struct id_map); + map->sid = talloc(map, struct dom_sid); + + map->xid.type = ID_TYPE_UID; + map->xid.id = HIGH_ID + 1; + + status = idmap_tdb_common_unixid_to_sid(dom, map); + if(NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixid2sid2: unixid2sid returned " + "out-of-range result\n")); + retval = false; + goto out; + } + + DEBUG(0, ("test_unixid2sid2: PASSED!\n")); +out: + talloc_free(map); + return retval; + +} + +static bool test_unixid2sid3(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map uid_map, gid_map, test_map; + struct dom_sid testsid; + + ZERO_STRUCT(uid_map); + ZERO_STRUCT(gid_map); + + /* create two mappings for a UID and GID */ + uid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID3 "-1000"); + uid_map.xid.type = ID_TYPE_UID; + + gid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID3 "-1001"); + gid_map.xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_new_mapping(dom, &uid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixid2sid3: could not create uid map!\n")); + return false; + } + + status = idmap_tdb_common_new_mapping(dom, &gid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixid2sid3: could not create gid map!\n")); + return false; + } + + /* now read them back */ + ZERO_STRUCT(test_map); + test_map.xid.id = uid_map.xid.id; + test_map.xid.type = ID_TYPE_UID; + test_map.sid = &testsid; + + status = idmap_tdb_common_unixid_to_sid(dom, &test_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixid2sid3: unixid2sid failed for uid!\n")); + return false; + } + + if(test_map.xid.type!=uid_map.xid.type) { + DEBUG(0, ("test_unixid2sid3: unixid2sid returned wrong type!\n")); + return false; + } + + if(!dom_sid_equal(test_map.sid, uid_map.sid)) { + DEBUG(0, ("test_unixid2sid3: unixid2sid returned wrong SID!\n")); + return false; + } + + ZERO_STRUCT(test_map); + test_map.xid.id = gid_map.xid.id; + test_map.xid.type = ID_TYPE_GID; + test_map.sid = &testsid; + + status = idmap_tdb_common_unixid_to_sid(dom, &test_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixid2sid3: unixid2sid failed for gid!\n")); + return false; + } + + if(test_map.xid.type!=gid_map.xid.type) { + DEBUG(0, ("test_unixid2sid3: unixid2sid returned wrong type!\n")); + return false; + } + + if(!dom_sid_equal(test_map.sid,gid_map.sid)) { + DEBUG(0, ("test_unixid2sid3: unixid2sid returned wrong SID!\n")); + return false; + } + + DEBUG(0, ("test_unixid2sid3: PASSED!\n")); + + return true; +} + +static bool test_unixids2sids1(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map uid_map, gid_map, **test_maps; + + ZERO_STRUCT(uid_map); + ZERO_STRUCT(gid_map); + + /* create two mappings for a UID and GID */ + + uid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID5 "-1000"); + uid_map.xid.type = ID_TYPE_UID; + + gid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID5 "-1001"); + gid_map.xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_new_mapping(dom, &uid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixids2sids1: could not create uid map!\n")); + return false; + } + + status = idmap_tdb_common_new_mapping(dom, &gid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixids2sids1: could not create gid map!\n")); + return false; + } + + /* now read them back */ + test_maps = talloc_zero_array(memctx, struct id_map*, 3); + + test_maps[0] = talloc(test_maps, struct id_map); + test_maps[1] = talloc(test_maps, struct id_map); + test_maps[2] = NULL; + + test_maps[0]->sid = talloc(test_maps, struct dom_sid); + test_maps[1]->sid = talloc(test_maps, struct dom_sid); + test_maps[0]->xid.id = uid_map.xid.id; + test_maps[0]->xid.type = ID_TYPE_UID; + test_maps[1]->xid.id = gid_map.xid.id; + test_maps[1]->xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_unixids_to_sids(dom, test_maps); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixids2sids1: unixids2sids failed!\n")); + talloc_free(test_maps); + return false; + } + + if(!dom_sid_equal(test_maps[0]->sid, uid_map.sid) || + !dom_sid_equal(test_maps[1]->sid, gid_map.sid) ) { + DEBUG(0, ("test_unixids2sids1: unixids2sids returned wrong sid!\n")); + talloc_free(test_maps); + return false; + } + + DEBUG(0, ("test_unixids2sids1: PASSED!\n")); + + talloc_free(test_maps); + + return true; +} + +static bool test_unixids2sids2(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map **test_maps; + bool retval = true; + + test_maps = talloc_zero_array(memctx, struct id_map*, 3); + + test_maps[0] = talloc(test_maps, struct id_map); + test_maps[1] = talloc(test_maps, struct id_map); + test_maps[2] = NULL; + + /* ask for two unknown mappings for a UID and GID */ + test_maps[0]->sid = talloc(test_maps, struct dom_sid); + test_maps[1]->sid = talloc(test_maps, struct dom_sid); + test_maps[0]->xid.id = HIGH_ID - 1; + test_maps[0]->xid.type = ID_TYPE_UID; + test_maps[1]->xid.id = HIGH_ID - 1; + test_maps[1]->xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_unixids_to_sids(dom, test_maps); + if(NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixids2sids2: unixids2sids succeeded " + "unexpectedly!\n")); + retval = false; + goto out; + } + + DEBUG(0, ("test_unixids2sids2: PASSED!\n")); + +out: + talloc_free(test_maps); + + return retval;; +} + +static bool test_unixids2sids3(TALLOC_CTX *memctx, struct idmap_domain *dom) +{ + NTSTATUS status; + struct id_map uid_map, gid_map, **test_maps; + bool retval = true; + + ZERO_STRUCT(uid_map); + ZERO_STRUCT(gid_map); + + /* create two mappings for a UID and GID */ + uid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID6 "-1000"); + uid_map.xid.type = ID_TYPE_UID; + + gid_map.sid = dom_sid_parse_talloc(memctx, DOM_SID6 "-1001"); + gid_map.xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_new_mapping(dom, &uid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixids2sids3: could not create uid map!\n")); + return false; + } + + status = idmap_tdb_common_new_mapping(dom, &gid_map); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixids2sids3: could not create gid map!\n")); + return false; + } + + /* + * check the mapping states: + * NONE_MAPPED, SOME_UNMAPPED, OK (all mapped) + */ + test_maps = talloc_zero_array(memctx, struct id_map*, 3); + + test_maps[0] = talloc(test_maps, struct id_map); + test_maps[1] = talloc(test_maps, struct id_map); + test_maps[2] = NULL; + + /* NONE_MAPPED first */ + test_maps[0]->sid = talloc(test_maps, struct dom_sid); + test_maps[1]->sid = talloc(test_maps, struct dom_sid); + + test_maps[0]->xid.id = HIGH_ID - 1; + test_maps[0]->xid.type = ID_TYPE_UID; + + test_maps[1]->xid.id = HIGH_ID - 1; + test_maps[1]->xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_unixids_to_sids(dom, test_maps); + if(!NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED)) { + DEBUG(0, ("test_unixids2sids3: incorrect status " + "(%s), expected NT_STATUS_NONE_MAPPED!\n", + nt_errstr(status))); + retval = false; + goto out; + } + + /* SOME_UNMAPPED */ + test_maps[0]->sid = talloc(test_maps, struct dom_sid); + test_maps[1]->sid = talloc(test_maps, struct dom_sid); + test_maps[0]->xid = uid_map.xid; + test_maps[1]->xid.id = HIGH_ID - 1; + test_maps[1]->xid.type = ID_TYPE_GID; + + status = idmap_tdb_common_unixids_to_sids(dom, test_maps); + if(!NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) { + DEBUG(0, ("test_unixids2sids3: incorrect status " + "(%s), expected STATUS_SOME_UNMAPPED!\n", + nt_errstr(status))); + retval = false; + goto out; + } + + /* OK */ + test_maps[0]->sid = talloc(test_maps, struct dom_sid); + test_maps[1]->sid = talloc(test_maps, struct dom_sid); + test_maps[0]->xid = uid_map.xid; + test_maps[1]->xid = gid_map.xid; + + status = idmap_tdb_common_unixids_to_sids(dom, test_maps); + if(!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("test_unixids2sids3: incorrect status " + "(%s), expected NT_STATUS_OK!\n", + nt_errstr(status))); + retval = false; + goto out; + } + + DEBUG(0, ("test_unixids2sids3: PASSED!\n")); + +out: + talloc_free(test_maps); + return retval; +} + +#define CHECKRESULT(r) if(!r) {TALLOC_FREE(stack); return r;} + +bool run_idmap_tdb_common_test(int dummy) +{ + bool result; + struct idmap_domain *dom; + TALLOC_CTX *stack = talloc_stackframe(); + TALLOC_CTX *memctx = talloc_new(stack); + NTSTATUS status; + + dom = createdomain(memctx); + if (dom == NULL) { + TALLOC_FREE(stack); + return false; + } + + status = dom->methods->init(dom); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(stack); + return false; + } + + /* test a single allocation from pool (no mapping) */ + result = test_getnewid1(memctx, dom); + CHECKRESULT(result); + + /* test idmap_tdb_common_set_mapping */ + result = test_setmap1(memctx, dom); + CHECKRESULT(result); + + /* test idmap_tdb_common_sid_to_unixid */ + result = test_sid2unixid1(memctx, dom); + CHECKRESULT(result); + result = test_sid2unixid2(memctx, dom); + CHECKRESULT(result); + + /* test idmap_tdb_common_sids_to_unixids */ + result = test_sids2unixids1(memctx, dom); + CHECKRESULT(result); + result = test_sids2unixids2(memctx, dom); + CHECKRESULT(result); + result = test_sids2unixids3(memctx, dom); + CHECKRESULT(result); + + /* test idmap_tdb_common_unixid_to_sid */ + result = test_unixid2sid1(memctx, dom); + CHECKRESULT(result); + result = test_unixid2sid2(memctx, dom); + CHECKRESULT(result); + result = test_unixid2sid3(memctx, dom); + CHECKRESULT(result); + + /* test idmap_tdb_common_unixids_to_sids */ + result = test_unixids2sids1(memctx, dom); + CHECKRESULT(result); + result = test_unixids2sids2(memctx, dom); + CHECKRESULT(result); + result = test_unixids2sids3(memctx, dom); + CHECKRESULT(result); + + /* test filling up the range */ + result = test_getnewid2(memctx, dom); + CHECKRESULT(result); + + talloc_free(stack); + + return true; +} diff --git a/source3/torture/test_matching.c b/source3/torture/test_matching.c new file mode 100644 index 0000000..647b758 --- /dev/null +++ b/source3/torture/test_matching.c @@ -0,0 +1,276 @@ +/* + Unix SMB/CIFS implementation. + Samba utility tests + Copyright (C) Stefan Metzmacher 2021 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "lib/util_matching.h" +#include "proto.h" + +bool run_str_match_mswild(int dummy) +{ + const char *namelist = "/abc*.txt/xyz*.dat/a0123456789Z/"; + name_compare_entry *name_entries = NULL; + struct samba_path_matching *pmcs = NULL; + struct samba_path_matching *pmci = NULL; + const struct str_match_mswild_name { + const char *name; + ssize_t case_sensitive_idx; + ssize_t case_insensitive_idx; + } names[] = {{ + .name = "/dir/abc123.txt", + .case_sensitive_idx = 0, + .case_insensitive_idx = 0, + },{ + .name = "/dir/AbC123.TxT", + .case_sensitive_idx = -1, + .case_insensitive_idx = 0, + },{ + .name = "/dir/xyz123.dat", + .case_sensitive_idx = 1, + .case_insensitive_idx = 1, + },{ + .name = "/dir/XyZ123.DaT", + .case_sensitive_idx = -1, + .case_insensitive_idx = 1, + },{ + .name = "/dir/aaa123.jpg", + .case_sensitive_idx = -1, + .case_insensitive_idx = -1, + },{ + .name = "/dir/a0123456789Z", + .case_sensitive_idx = 2, + .case_insensitive_idx = 2, + },{ + .name = "/dir/A0123456789z", + .case_sensitive_idx = -1, + .case_insensitive_idx = 2, + }}; + NTSTATUS status; + size_t i; + bool ret = true; + + d_fprintf(stderr, "namelist: %s\n", namelist); + + set_namearray(&name_entries, namelist); + SMB_ASSERT(name_entries != NULL); + + status = samba_path_matching_mswild_create(talloc_tos(), + true, /* case_sensitive */ + namelist, + &pmcs); + SMB_ASSERT(NT_STATUS_IS_OK(status)); + status = samba_path_matching_mswild_create(talloc_tos(), + false, /* case_sensitive */ + namelist, + &pmci); + SMB_ASSERT(NT_STATUS_IS_OK(status)); + + + for (i = 0; i < ARRAY_SIZE(names); i++) { + const struct str_match_mswild_name *n = &names[i]; + bool case_sensitive_match; + bool case_insensitive_match; + ssize_t cs_match_idx = -1; + ssize_t ci_match_idx = -1; + ssize_t replace_start = -1; + ssize_t replace_end = -1; + bool ok = true; + + case_sensitive_match = is_in_path(n->name, + name_entries, + true); + if (n->case_sensitive_idx != -1) { + ok &= case_sensitive_match; + } else { + ok &= !case_sensitive_match; + } + status = samba_path_matching_check_last_component(pmcs, + n->name, + &cs_match_idx, + &replace_start, + &replace_end); + SMB_ASSERT(NT_STATUS_IS_OK(status)); + SMB_ASSERT(replace_start == -1); + SMB_ASSERT(replace_end == -1); + if (n->case_sensitive_idx != cs_match_idx) { + ok = false; + } + case_insensitive_match = is_in_path(n->name, + name_entries, + false); + if (n->case_insensitive_idx != -1) { + ok &= case_insensitive_match; + } else { + ok &= !case_insensitive_match; + } + status = samba_path_matching_check_last_component(pmci, + n->name, + &ci_match_idx, + &replace_start, + &replace_end); + SMB_ASSERT(NT_STATUS_IS_OK(status)); + SMB_ASSERT(replace_start == -1); + SMB_ASSERT(replace_end == -1); + if (n->case_insensitive_idx != ci_match_idx) { + ok = false; + } + + d_fprintf(stderr, "name[%s] " + "case_sensitive[TIDX=%zd;MATCH=%u;MIDX=%zd] " + "case_insensitive[TIDX=%zd;MATCH=%u;MIDX=%zd] " + "%s\n", + n->name, + n->case_sensitive_idx, + case_sensitive_match, + cs_match_idx, + n->case_insensitive_idx, + case_insensitive_match, + ci_match_idx, + ok ? "OK" : "FAIL"); + + ret &= ok; + } + + return ret; +} + +bool run_str_match_regex_sub1(int dummy) +{ + const char *invalidlist1 = "/Re7599Ex[0-9].*\\.txt/"; + const char *invalidlist2 = "/Re7599Ex\\([0-9]\\).*\\.\\(txt\\)/"; + const char *invalidlist3 = "/Re7599Ex\\([0-9]).*\\.txt/"; + const char *invalidlist4 = "/Re7599Ex[0-9.*\\.txt/"; + const char *namelist = "/Re7599Ex\\([0-9]\\).*\\.txt/test\\(.*\\).txt/^test\\([0-9]*\\).dat/"; + struct samba_path_matching *pm = NULL; + const struct str_match_regex_sub1 { + const char *name; + ssize_t match_idx; + ssize_t sub_start; + ssize_t sub_end; + } names[] = {{ + .name = "/dir/Re7599Ex567.txt", + .match_idx = 0, + .sub_start = 13, + .sub_end = 14, + },{ + .name = "/dir/rE7599eX567.txt", + .match_idx = -1, + .sub_start = -1, + .sub_end = -1, + },{ + .name = "/dir/Re7599Ex.txt", + .match_idx = -1, + .sub_start = -1, + .sub_end = -1, + },{ + .name = "/dir/testabc123.txt", + .match_idx = 1, + .sub_start = 9, + .sub_end = 15, + },{ + .name = "/dir/testabc123.tXt", + .match_idx = -1, + .sub_start = -1, + .sub_end = -1, + },{ + .name = "/dir/test123.dat", + .match_idx = 2, + .sub_start = 9, + .sub_end = 12, + },{ + .name = "/dir/tEst123.dat", + .match_idx = -1, + .sub_start = -1, + .sub_end = -1, + }}; + NTSTATUS status; + size_t i; + bool ret = true; + + d_fprintf(stderr, "invalidlist1: %s\n", invalidlist1); + status = samba_path_matching_regex_sub1_create(talloc_tos(), + invalidlist1, + &pm); + SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)); + d_fprintf(stderr, "invalidlist2: %s\n", invalidlist2); + status = samba_path_matching_regex_sub1_create(talloc_tos(), + invalidlist2, + &pm); + SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)); + d_fprintf(stderr, "invalidlist3: %s\n", invalidlist3); + status = samba_path_matching_regex_sub1_create(talloc_tos(), + invalidlist3, + &pm); + SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)); + d_fprintf(stderr, "invalidlist4: %s\n", invalidlist4); + status = samba_path_matching_regex_sub1_create(talloc_tos(), + invalidlist4, + &pm); + SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)); + + d_fprintf(stderr, "namelist: %s\n", namelist); + status = samba_path_matching_regex_sub1_create(talloc_tos(), + namelist, + &pm); + SMB_ASSERT(NT_STATUS_IS_OK(status)); + + for (i = 0; i < ARRAY_SIZE(names); i++) { + const struct str_match_regex_sub1 *n = &names[i]; + ssize_t match_idx = -1; + ssize_t replace_start = -1; + ssize_t replace_end = -1; + bool ok = true; + + status = samba_path_matching_check_last_component(pm, + n->name, + &match_idx, + &replace_start, + &replace_end); + SMB_ASSERT(NT_STATUS_IS_OK(status)); + if (match_idx == -1) { + SMB_ASSERT(replace_start == -1); + SMB_ASSERT(replace_end == -1); + } + if (n->match_idx != match_idx) { + ok = false; + } + if (n->sub_start != replace_start) { + ok = false; + } + if (n->sub_end != replace_end) { + ok = false; + } + + d_fprintf(stderr, "name[%s] " + "T[IDX=%zd;START=%zd;END=%zd] " + "M[[IDX=%zd;START=%zd;END=%zd] " + "%s\n", + n->name, + n->match_idx, + n->sub_start, + n->sub_end, + match_idx, + replace_start, + replace_end, + ok ? "OK" : "FAIL"); + + ret &= ok; + } + + return ret; +} diff --git a/source3/torture/test_messaging_fd_passing.c b/source3/torture/test_messaging_fd_passing.c new file mode 100644 index 0000000..5030b66 --- /dev/null +++ b/source3/torture/test_messaging_fd_passing.c @@ -0,0 +1,397 @@ +/* + Unix SMB/CIFS implementation. + Test for fd passing with messaging + + Copyright (C) Michael Adam 2014 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "lib/util/tevent_unix.h" +#include "messages.h" + +/** + * test fdpass1: + * + * Try to pass an fd to the sending process - fails. + */ +bool run_messaging_fdpass1(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg_ctx = NULL; + bool retval = false; + int pipe_fds[2]; + int pass_fds[1] = { 0 }; + int ret; + NTSTATUS status; + struct server_id dst; + TALLOC_CTX *frame = talloc_stackframe(); + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + fprintf(stderr, "tevent_context_init failed\n"); + goto fail; + } + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + fprintf(stderr, "messaging_init failed\n"); + goto fail; + } + + dst = messaging_server_id(msg_ctx); + + ret = pipe(pipe_fds); + if (ret != 0) { + perror("pipe failed"); + goto fail; + } + + pass_fds[0] = pipe_fds[0]; + + status = messaging_send_iov(msg_ctx, dst, MSG_PING, NULL, 0, + pass_fds, 1); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) { + fprintf(stderr, + "messaging_send_iov gave: %s\n", nt_errstr(status)); + goto fail; + } + + retval = true; + +fail: + TALLOC_FREE(frame); + return retval; +} + +/** + * test fdpass2: + * + * - parent: create a child + * - parent: create a two pipes in the parent: up and down + * - parent: pass the up pipe's reading end and the down pipe's writing + * end to the child and close them + * - parent: write a number into the up pipe's writing end + * - child: read number from the passed reading fd (up) + * - child: write the read number to the passed writing fd (down) + * - parent: read number from the down pipe's reading end and compare with + * original number + */ + +#define MSG_TORTURE_FDPASS2 0xF002 + +static bool fdpass2_filter(struct messaging_rec *rec, void *private_data) +{ + if (rec->msg_type != MSG_TORTURE_FDPASS2) { + return false; + } + + if (rec->num_fds != 2) { + return false; + } + + return true; +} + +static bool fdpass2_child(int ready_fd) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg_ctx = NULL; + TALLOC_CTX *frame = talloc_stackframe(); + bool retval = false; + uint8_t c = 1; + struct tevent_req *subreq; + int ret; + ssize_t bytes; + int up_fd, down_fd; + struct messaging_rec *rec; + bool ok; + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + fprintf(stderr, "child: tevent_context_init failed\n"); + goto done; + } + + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + fprintf(stderr, "child: messaging_init failed\n"); + goto done; + } + + /* Tell the parent we are ready to receive messages. */ + bytes = write(ready_fd, &c, 1); + if (bytes != 1) { + perror("child: failed to write to ready_fd"); + goto done; + } + + subreq = messaging_filtered_read_send(frame, /* TALLOC_CTX */ + ev, msg_ctx, + fdpass2_filter, NULL); + if (subreq == NULL) { + fprintf(stderr, "child: messaging_filtered_read_send failed\n"); + goto done; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + fprintf(stderr, "child: tevent_req_poll failed\n"); + goto done; + } + + ret = messaging_filtered_read_recv(subreq, frame, &rec); + TALLOC_FREE(subreq); + if (ret != 0) { + fprintf(stderr, "child: messaging_filtered_read_recv failed\n"); + goto done; + } + + SMB_ASSERT(rec->num_fds == 2); + + /* Tell the parent we are done. */ + bytes = write(ready_fd, &c, 1); + if (bytes != 1) { + perror("child: failed to write to ready_fd"); + goto done; + } + + up_fd = rec->fds[0]; + down_fd = rec->fds[1]; + + bytes = read(up_fd, &c, 1); + if (bytes != 1) { + perror("child: read from up_fd failed"); + goto done; + } + + bytes = write(down_fd, &c, 1); + if (bytes != 1) { + perror("child: write to down_fd failed"); + } + + printf("child: done\n"); + + retval = true; + +done: + TALLOC_FREE(frame); + return retval; +} + +struct child_done_state { + int fd; + bool done; +}; + +static void child_done_cb(struct tevent_context *ev, + struct tevent_fd *fde, + uint16_t flags, + void *private_data) +{ + struct child_done_state *state = + (struct child_done_state *)private_data; + char c = 0; + ssize_t bytes; + + bytes = read(state->fd, &c, 1); + if (bytes != 1) { + perror("parent: read from ready_fd failed"); + } + + state->done = true; +} + +static bool fdpass2_parent(pid_t child_pid, int ready_fd, size_t payload_size) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg_ctx = NULL; + bool retval = false; + int up_pipe[2]; + int down_pipe[2]; + int pass_fds[2] = { 0 }; + int ret; + NTSTATUS status; + struct server_id dst; + TALLOC_CTX *frame = talloc_stackframe(); + uint8_t c1 = 1, c2, c; + ssize_t bytes; + struct iovec iov; + DATA_BLOB blob; + struct tevent_fd *child_done_fde; + struct child_done_state child_state; + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + fprintf(stderr, "parent: tevent_context_init failed\n"); + goto done; + } + + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + fprintf(stderr, "parent: messaging_init failed\n"); + goto done; + } + + /* wait util the child is ready to receive messages */ + bytes = read(ready_fd, &c, 1); + if (bytes != 1) { + perror("parent: read from ready_fd failed"); + goto done; + } + + ret = pipe(up_pipe); + if (ret != 0) { + perror("parent: pipe failed for up_pipe"); + goto done; + } + + ret = pipe(down_pipe); + if (ret != 0) { + perror("parent: pipe failed for down_pipe"); + goto done; + } + + child_state.fd = ready_fd; + child_state.done = false; + + child_done_fde = tevent_add_fd(ev, ev, ready_fd, TEVENT_FD_READ, + child_done_cb, &child_state); + if (child_done_fde == NULL) { + fprintf(stderr, + "parent: failed tevent_add_fd for child done\n"); + goto done; + } + + pass_fds[0] = up_pipe[0]; + pass_fds[1] = down_pipe[1]; + + dst = messaging_server_id(msg_ctx); + dst.pid = child_pid; + + /* + * Send a certain payload with the fds, to test to test + * that fd-passing works when we have fragmentation and + * re-assembly of the datagrams. + * + * Fragmentation/queuing is triggered by a certain payload + * size. Payloads below that size use the fast path. + */ + blob = data_blob_talloc_zero(frame, payload_size); + iov.iov_base = blob.data; + iov.iov_len = blob.length; + + status = messaging_send_iov(msg_ctx, dst, MSG_TORTURE_FDPASS2, &iov, 1, + pass_fds, 2); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "parent: messaging_send_iov failed: %s\n", + nt_errstr(status)); + goto done; + } + + printf("parent: waiting for child to confirm\n"); + + while (!child_state.done) { + ret = tevent_loop_once(ev); + if (ret != 0) { + fprintf(stderr, "parent: tevent_loop_once failed\n"); + goto done; + } + } + + printf("parent: child confirmed\n"); + + close(up_pipe[0]); + close(down_pipe[1]); + + bytes = write(up_pipe[1], &c1, 1); + if (bytes != 1) { + perror("parent: write to up pipe failed"); + goto done; + } + + bytes = read(down_pipe[0], &c2, 1); + if (bytes != 1) { + perror("parent: read from down pipe failed"); + goto done; + } + + if (c1 != c2) { + fprintf(stderr, "parent: c1[%d] != c2[%d]\n", c1, c2); + goto done; + } + + ret = waitpid(child_pid, NULL, 0); + if (ret == -1) { + perror("parent: waitpid failed"); + goto done; + } + + retval = true; + +done: + TALLOC_FREE(frame); + return retval; +} + +static bool run_messaging_fdpass2_int(int dummy, size_t payload_size) +{ + bool retval = false; + pid_t child_pid; + int ready_pipe[2]; + int ret; + + ret = pipe(ready_pipe); + if (ret != 0) { + perror("parent: pipe failed for ready_pipe"); + return retval; + } + + child_pid = fork(); + if (child_pid == -1) { + perror("fork failed"); + } else if (child_pid == 0) { + close(ready_pipe[0]); + retval = fdpass2_child(ready_pipe[1]); + } else { + close(ready_pipe[1]); + retval = fdpass2_parent(child_pid, ready_pipe[0], payload_size); + } + + return retval; +} + +bool run_messaging_fdpass2(int dummy) +{ + return run_messaging_fdpass2_int(dummy, 1000*1000); +} + +/** + * Variant of the FDPASS2 test that tests the non-queuing fast path + * with a small payload. + */ +bool run_messaging_fdpass2a(int dummy) +{ + return run_messaging_fdpass2_int(dummy, 1); +} + +/** + * Variant of the FDPASS2 test that tests the non-queuing fast path + * without a payload. + */ +bool run_messaging_fdpass2b(int dummy) +{ + return run_messaging_fdpass2_int(dummy, 0); +} diff --git a/source3/torture/test_messaging_read.c b/source3/torture/test_messaging_read.c new file mode 100644 index 0000000..555f084 --- /dev/null +++ b/source3/torture/test_messaging_read.c @@ -0,0 +1,706 @@ +/* + Unix SMB/CIFS implementation. + Test for a messaging_read bug + Copyright (C) Volker Lendecke 2014 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "lib/util/tevent_unix.h" +#include "messages.h" + +struct msg_count_state { + struct tevent_context *ev; + struct messaging_context *msg_ctx; + uint32_t msg_type; + unsigned *count; +}; + +static void msg_count_done(struct tevent_req *subreq); + +static struct tevent_req *msg_count_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct messaging_context *msg_ctx, + uint32_t msg_type, + unsigned *count) +{ + struct tevent_req *req, *subreq; + struct msg_count_state *state; + + req = tevent_req_create(mem_ctx, &state, struct msg_count_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->msg_ctx = msg_ctx; + state->msg_type = msg_type; + state->count = count; + + subreq = messaging_read_send(state, state->ev, state->msg_ctx, + state->msg_type); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, msg_count_done, req); + return req; +} + +static void msg_count_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct msg_count_state *state = tevent_req_data( + req, struct msg_count_state); + int ret; + + ret = messaging_read_recv(subreq, NULL, NULL); + TALLOC_FREE(subreq); + if (tevent_req_error(req, ret)) { + return; + } + *state->count += 1; + + subreq = messaging_read_send(state, state->ev, state->msg_ctx, + state->msg_type); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, msg_count_done, req); +} + +bool run_messaging_read1(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg_ctx = NULL; + struct tevent_req *req1 = NULL; + unsigned count1 = 0; + struct tevent_req *req2 = NULL; + unsigned count2 = 0; + NTSTATUS status; + bool retval = false; + int i; + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + fprintf(stderr, "tevent_context_init failed\n"); + goto fail; + } + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + fprintf(stderr, "messaging_init failed\n"); + goto fail; + } + + req1 = msg_count_send(ev, ev, msg_ctx, MSG_SMB_NOTIFY, &count1); + if (req1 == NULL) { + fprintf(stderr, "msg_count_send failed\n"); + goto fail; + } + req2 = msg_count_send(ev, ev, msg_ctx, MSG_SMB_NOTIFY, &count2); + if (req1 == NULL) { + fprintf(stderr, "msg_count_send failed\n"); + goto fail; + } + status = messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx), + MSG_SMB_NOTIFY, NULL, 0); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "messaging_send_buf failed: %s\n", + nt_errstr(status)); + goto fail; + } + + for (i=0; i<2; i++) { + if (tevent_loop_once(ev) != 0) { + fprintf(stderr, "tevent_loop_once failed\n"); + goto fail; + } + } + + printf("%u/%u\n", count1, count2); + + if ((count1 != 1) || (count2 != 0)) { + fprintf(stderr, "Got %u/%u msgs, expected 1/0\n", + count1, count2); + goto fail; + } + + retval = true; +fail: + TALLOC_FREE(req1); + TALLOC_FREE(req2); + TALLOC_FREE(msg_ctx); + TALLOC_FREE(ev); + return retval; +} + +struct msg_free_state { + struct tevent_req **to_free; +}; + +static void msg_free_done(struct tevent_req *subreq); + +static struct tevent_req *msg_free_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct messaging_context *msg_ctx, + uint32_t msg_type, + struct tevent_req **to_free) +{ + struct tevent_req *req, *subreq; + struct msg_free_state *state; + + req = tevent_req_create(mem_ctx, &state, struct msg_free_state); + if (req == NULL) { + return NULL; + } + state->to_free = to_free; + + subreq = messaging_read_send(state, ev, msg_ctx, msg_type); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, msg_free_done, req); + return req; +} + +static void msg_free_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct msg_free_state *state = tevent_req_data( + req, struct msg_free_state); + int ret; + + ret = messaging_read_recv(subreq, NULL, NULL); + TALLOC_FREE(subreq); + if (tevent_req_error(req, ret)) { + return; + } + TALLOC_FREE(*state->to_free); + tevent_req_done(req); +} + +bool run_messaging_read2(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg_ctx = NULL; + struct tevent_req *req1 = NULL; + struct tevent_req *req2 = NULL; + unsigned count = 0; + NTSTATUS status; + bool retval = false; + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + fprintf(stderr, "tevent_context_init failed\n"); + goto fail; + } + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + fprintf(stderr, "messaging_init failed\n"); + goto fail; + } + + req1 = msg_free_send(ev, ev, msg_ctx, MSG_SMB_NOTIFY, &req2); + if (req1 == NULL) { + fprintf(stderr, "msg_count_send failed\n"); + goto fail; + } + req2 = msg_count_send(ev, ev, msg_ctx, MSG_SMB_NOTIFY, &count); + if (req1 == NULL) { + fprintf(stderr, "msg_count_send failed\n"); + goto fail; + } + status = messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx), + MSG_SMB_NOTIFY, NULL, 0); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "messaging_send_buf failed: %s\n", + nt_errstr(status)); + goto fail; + } + + if (!tevent_req_poll(req1, ev) != 0) { + fprintf(stderr, "tevent_req_poll failed\n"); + goto fail; + } + + if (count != 0) { + fprintf(stderr, "Got %u msgs, expected none\n", count); + goto fail; + } + + retval = true; +fail: + TALLOC_FREE(req1); + TALLOC_FREE(msg_ctx); + TALLOC_FREE(ev); + return retval; +} + +struct msg_pingpong_state { + struct messaging_context *msg_ctx; +}; + +static void msg_pingpong_done(struct tevent_req *subreq); + +static struct tevent_req *msg_pingpong_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct server_id dst) +{ + struct tevent_req *req, *subreq; + struct msg_pingpong_state *state; + NTSTATUS status; + + req = tevent_req_create(mem_ctx, &state, struct msg_pingpong_state); + if (req == NULL) { + return NULL; + } + + if (!tevent_req_set_endtime(req, ev, timeval_current_ofs(10, 0))) { + return tevent_req_post(req, ev); + } + + state->msg_ctx = messaging_init(state, ev); + if (tevent_req_nomem(state->msg_ctx, req)) { + return tevent_req_post(req, ev); + } + + status = messaging_send_buf(state->msg_ctx, dst, MSG_PING, NULL, 0); + if (!NT_STATUS_IS_OK(status)) { + DBG_DEBUG("messaging_send_buf failed: %s\n", nt_errstr(status)); + tevent_req_error(req, map_errno_from_nt_status(status)); + return tevent_req_post(req, ev); + } + + subreq = messaging_read_send(state, ev, state->msg_ctx, MSG_PONG); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, msg_pingpong_done, req); + return req; +} + +static void msg_pingpong_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + int ret; + + ret = messaging_read_recv(subreq, NULL, NULL); + TALLOC_FREE(subreq); + if (ret != 0) { + tevent_req_error(req, ret); + return; + } + tevent_req_done(req); +} + +static int msg_pingpong_recv(struct tevent_req *req) +{ + int err; + + if (tevent_req_is_unix_error(req, &err)) { + return err; + } + return 0; +} + +static int msg_pingpong(struct server_id dst) +{ + struct tevent_context *ev; + struct tevent_req *req; + int ret = ENOMEM; + + ev = tevent_context_init(talloc_tos()); + if (ev == NULL) { + goto fail; + } + req = msg_pingpong_send(ev, ev, dst); + if (req == NULL) { + goto fail; + } + if (!tevent_req_poll(req, ev)) { + ret = errno; + goto fail; + } + ret = msg_pingpong_recv(req); +fail: + TALLOC_FREE(ev); + return ret; +} + +static void ping_responder_exit(struct tevent_context *ev, + struct tevent_fd *fde, + uint16_t flags, + void *private_data) +{ + bool *done = private_data; + + printf("Child: received write on exit-pipe\n"); + + *done = true; +} + +static void ping_responder(int ready_pipe, int exit_pipe) +{ + struct tevent_context *ev; + struct messaging_context *msg_ctx; + struct tevent_fd *exit_handler; + char c = 0; + bool done = false; + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + fprintf(stderr, "child tevent_context_init failed\n"); + exit(1); + } + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + fprintf(stderr, "child messaging_init failed\n"); + exit(1); + } + exit_handler = tevent_add_fd(ev, ev, exit_pipe, TEVENT_FD_READ, + ping_responder_exit, &done); + if (exit_handler == NULL) { + fprintf(stderr, "child tevent_add_fd failed\n"); + exit(1); + } + + if (write(ready_pipe, &c, 1) != 1) { + fprintf(stderr, "child messaging_init failed\n"); + exit(1); + } + + while (!done) { + int ret; + ret = tevent_loop_once(ev); + if (ret != 0) { + fprintf(stderr, "child tevent_loop_once failed\n"); + exit(1); + } + } + + printf("Child: done, exiting...\n"); + + TALLOC_FREE(msg_ctx); + TALLOC_FREE(ev); +} + +bool run_messaging_read3(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg_ctx = NULL; + bool retval = false; + pid_t child; + int ready_pipe[2]; + int exit_pipe[2]; + int i, ret; + char c; + struct server_id dst; + ssize_t written; + + if ((pipe(ready_pipe) != 0) || (pipe(exit_pipe) != 0)) { + perror("pipe failed"); + return false; + } + + child = fork(); + if (child == -1) { + perror("fork failed"); + return false; + } + + if (child == 0) { + close(ready_pipe[0]); + close(exit_pipe[1]); + ping_responder(ready_pipe[1], exit_pipe[0]); + exit(0); + } + close(ready_pipe[1]); + close(exit_pipe[0]); + + if (read(ready_pipe[0], &c, 1) != 1) { + perror("read failed"); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + fprintf(stderr, "tevent_context_init failed\n"); + goto fail; + } + + dst = (struct server_id){ .pid = child, .vnn = NONCLUSTER_VNN, }; + + for (i=0; i<100; i++) { + ret = msg_pingpong(dst); + if (ret != 0){ + fprintf(stderr, "msg_pingpong failed\n"); + goto fail; + } + } + + printf("Parent: telling child to exit\n"); + + written = write(exit_pipe[1], &c, 1); + if (written != 1) { + perror("write to exit_pipe failed"); + goto fail; + } + + ret = waitpid(child, NULL, 0); + if (ret == -1) { + perror("waitpid failed"); + goto fail; + } + + printf("Parent: child exited. Done\n"); + + retval = true; +fail: + TALLOC_FREE(msg_ctx); + TALLOC_FREE(ev); + return retval; +} + +/** + * read4: + * + * test transferring a big payload. + */ + +#define MSG_TORTURE_READ4 0xF104 + +static bool read4_child(int ready_fd) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg_ctx = NULL; + TALLOC_CTX *frame = talloc_stackframe(); + bool retval = false; + uint8_t c = 1; + struct tevent_req *subreq; + int ret; + ssize_t bytes; + struct messaging_rec *rec; + bool ok; + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + fprintf(stderr, "child: tevent_context_init failed\n"); + goto done; + } + + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + fprintf(stderr, "child: messaging_init failed\n"); + goto done; + } + + printf("child: telling parent we're ready to receive messages\n"); + + /* Tell the parent we are ready to receive messages. */ + bytes = write(ready_fd, &c, 1); + if (bytes != 1) { + perror("child: failed to write to ready_fd"); + goto done; + } + + printf("child: waiting for messages\n"); + + subreq = messaging_read_send(frame, /* TALLOC_CTX */ + ev, msg_ctx, + MSG_TORTURE_READ4); + if (subreq == NULL) { + fprintf(stderr, "child: messaging_read_send failed\n"); + goto done; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + fprintf(stderr, "child: tevent_req_poll failed\n"); + goto done; + } + + printf("child: receiving message\n"); + + ret = messaging_read_recv(subreq, frame, &rec); + TALLOC_FREE(subreq); + if (ret != 0) { + fprintf(stderr, "child: messaging_read_recv failed\n"); + goto done; + } + + printf("child: received message\n"); + + /* Tell the parent we are done. */ + bytes = write(ready_fd, &c, 1); + if (bytes != 1) { + perror("child: failed to write to ready_fd"); + goto done; + } + + printf("child: done\n"); + + retval = true; + +done: + TALLOC_FREE(frame); + return retval; +} + +struct child_done_state { + int fd; + bool done; +}; + +static void child_done_cb(struct tevent_context *ev, + struct tevent_fd *fde, + uint16_t flags, + void *private_data) +{ + struct child_done_state *state = + (struct child_done_state *)private_data; + char c = 0; + ssize_t bytes; + + bytes = read(state->fd, &c, 1); + if (bytes != 1) { + perror("parent: read from ready_fd failed"); + } + + state->done = true; +} + +static bool read4_parent(pid_t child_pid, int ready_fd) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg_ctx = NULL; + bool retval = false; + int ret; + NTSTATUS status; + struct server_id dst; + TALLOC_CTX *frame = talloc_stackframe(); + uint8_t c; + ssize_t bytes; + struct iovec iov; + DATA_BLOB blob; + struct tevent_fd *child_done_fde; + struct child_done_state child_state; + + /* wait until the child is ready to receive messages */ + bytes = read(ready_fd, &c, 1); + if (bytes != 1) { + perror("parent: read from ready_fd failed"); + goto done; + } + + printf("parent: child is ready to receive messages\n"); + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + fprintf(stderr, "parent: tevent_context_init failed\n"); + goto done; + } + + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + fprintf(stderr, "parent: messaging_init failed\n"); + goto done; + } + + child_state.fd = ready_fd; + child_state.done = false; + + child_done_fde = tevent_add_fd(ev, ev, ready_fd, TEVENT_FD_READ, + child_done_cb, &child_state); + if (child_done_fde == NULL) { + fprintf(stderr, + "parent: failed tevent_add_fd for child done\n"); + goto done; + } + + /* + * Send a 1M payload with the message. + */ + blob = data_blob_talloc_zero(frame, 1000*1000); + iov.iov_base = blob.data; + iov.iov_len = blob.length; + + dst = messaging_server_id(msg_ctx); + dst.pid = child_pid; + + printf("parent: sending message to child\n"); + + status = messaging_send_iov(msg_ctx, dst, MSG_TORTURE_READ4, &iov, 1, + NULL, 0); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "parent: messaging_send_iov failed: %s\n", + nt_errstr(status)); + goto done; + } + + printf("parent: waiting for child to confirm\n"); + + while (!child_state.done) { + ret = tevent_loop_once(ev); + if (ret != 0) { + fprintf(stderr, "parent: tevent_loop_once failed\n"); + goto done; + } + } + + printf("parent: child confirmed\n"); + + ret = waitpid(child_pid, NULL, 0); + if (ret == -1) { + perror("parent: waitpid failed"); + goto done; + } + + printf("parent: done\n"); + + retval = true; + +done: + TALLOC_FREE(frame); + return retval; +} + +bool run_messaging_read4(int dummy) +{ + bool retval = false; + pid_t child_pid; + int ready_pipe[2]; + int ret; + + ret = pipe(ready_pipe); + if (ret != 0) { + perror("parent: pipe failed for ready_pipe"); + return retval; + } + + child_pid = fork(); + if (child_pid == -1) { + perror("fork failed"); + } else if (child_pid == 0) { + close(ready_pipe[0]); + retval = read4_child(ready_pipe[1]); + } else { + close(ready_pipe[1]); + retval = read4_parent(child_pid, ready_pipe[0]); + } + + return retval; +} diff --git a/source3/torture/test_messaging_send_all.c b/source3/torture/test_messaging_send_all.c new file mode 100644 index 0000000..8512fa4 --- /dev/null +++ b/source3/torture/test_messaging_send_all.c @@ -0,0 +1,279 @@ +/* + * Unix SMB/CIFS implementation. + * Test for a messaging_send_all bug + * Copyright (C) Volker Lendecke 2017 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "torture/proto.h" +#include "lib/util/tevent_unix.h" +#include "messages.h" +#include "lib/async_req/async_sock.h" +#include "lib/util/sys_rw.h" + +static pid_t fork_responder(struct messaging_context *msg_ctx, + int exit_pipe[2]) +{ + struct tevent_context *ev = messaging_tevent_context(msg_ctx); + struct tevent_req *req; + pid_t child_pid; + int ready_pipe[2]; + char c = 0; + bool ok; + int ret, err; + NTSTATUS status; + ssize_t nwritten; + + ret = pipe(ready_pipe); + if (ret == -1) { + perror("pipe failed"); + return -1; + } + + child_pid = fork(); + if (child_pid == -1) { + perror("fork failed"); + close(ready_pipe[0]); + close(ready_pipe[1]); + return -1; + } + + if (child_pid != 0) { + ssize_t nread; + close(ready_pipe[1]); + nread = read(ready_pipe[0], &c, 1); + close(ready_pipe[0]); + if (nread != 1) { + perror("read failed"); + return -1; + } + return child_pid; + } + + close(ready_pipe[0]); + close(exit_pipe[1]); + + status = messaging_reinit(msg_ctx); + if (!NT_STATUS_IS_OK(status)) { + fprintf(stderr, "messaging_reinit failed: %s\n", + nt_errstr(status)); + close(ready_pipe[1]); + exit(1); + } + + nwritten = sys_write(ready_pipe[1], &c, 1); + if (nwritten != 1) { + fprintf(stderr, "write failed: %s\n", strerror(errno)); + exit(1); + } + + close(ready_pipe[1]); + + req = wait_for_read_send(ev, ev, exit_pipe[0], false); + if (req == NULL) { + fprintf(stderr, "wait_for_read_send failed\n"); + exit(1); + } + + ok = tevent_req_poll_unix(req, ev, &err); + if (!ok) { + fprintf(stderr, "tevent_req_poll_unix failed: %s\n", + strerror(err)); + exit(1); + } + + exit(0); +} + +struct messaging_send_all_state { + struct tevent_context *ev; + struct messaging_context *msg; + pid_t *senders; + size_t num_received; +}; + +static void collect_pong_received(struct tevent_req *subreq); + +static struct tevent_req *collect_pong_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct messaging_context *msg, + const pid_t *senders, + size_t num_senders) +{ + struct tevent_req *req, *subreq; + struct messaging_send_all_state *state; + + req = tevent_req_create(mem_ctx, &state, + struct messaging_send_all_state); + if (req == NULL) { + return NULL; + } + state->senders = talloc_memdup( + state, senders, num_senders * sizeof(pid_t)); + if (tevent_req_nomem(state->senders, req)) { + return tevent_req_post(req, ev); + } + state->ev = ev; + state->msg = msg; + + subreq = messaging_read_send(state, state->ev, state->msg, MSG_PONG); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, collect_pong_received, req); + return req; +} + +static void collect_pong_received(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct messaging_send_all_state *state = tevent_req_data( + req, struct messaging_send_all_state); + size_t num_senders = talloc_array_length(state->senders); + size_t i; + struct messaging_rec *rec; + int ret; + + ret = messaging_read_recv(subreq, state, &rec); + TALLOC_FREE(subreq); + if (tevent_req_error(req, ret)) { + return; + } + + /* + * We need to make sure we don't receive our own broadcast! + */ + + if (rec->src.pid == (uint64_t)getpid()) { + fprintf(stderr, "Received my own broadcast!\n"); + tevent_req_error(req, EMULTIHOP); + return; + } + + for (i=0; isenders[i] == (pid_t)rec->src.pid) { + printf("got message from %"PRIu64"\n", rec->src.pid); + state->senders[i] = 0; + state->num_received += 1; + break; + } + } + + if (state->num_received == num_senders) { + printf("done\n"); + tevent_req_done(req); + return; + } + + subreq = messaging_read_send(state, state->ev, state->msg, MSG_PONG); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, collect_pong_received, req); +} + +static int collect_pong_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_unix(req); +} + +extern int torture_nprocs; + +bool run_messaging_send_all(int dummy) +{ + struct tevent_context *ev = NULL; + struct messaging_context *msg_ctx = NULL; + int exit_pipe[2]; + pid_t children[MAX(5, torture_nprocs)]; + struct tevent_req *req; + size_t i; + bool ok; + int ret, err; + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + fprintf(stderr, "tevent_context_init failed\n"); + return false; + } + msg_ctx = messaging_init(ev, ev); + if (msg_ctx == NULL) { + fprintf(stderr, "messaging_init failed\n"); + return false; + } + ret = pipe(exit_pipe); + if (ret != 0) { + perror("parent: pipe failed for exit_pipe"); + return false; + } + + for (i=0; i. + */ + +#include "includes.h" +#include "torture/proto.h" +#include "lib/namemap_cache.h" +#include "libcli/security/dom_sid.h" +#include "lib/gencache.h" + +static const struct dom_sid domsid = { + 1, 4, {0,0,0,0,0,5}, {21, 123, 456, 789} +}; + +static void namemap_cache1_fn1(const char *domain, + const char *name, + enum lsa_SidType type, + bool expired, + void *private_data) +{ + bool *p_ok = private_data; + bool ok; + + ok = strequal(domain, "nt authority"); + ok &= strequal(name, "network"); + ok &= (type == SID_NAME_WKN_GRP); + + *p_ok = ok; +} + +static void namemap_cache1_fn2(const struct dom_sid *sid, + enum lsa_SidType type, + bool expired, + void *private_data) +{ + bool *p_ok = private_data; + bool ok; + + ok = dom_sid_equal(sid, &global_sid_Network); + ok &= (type == SID_NAME_WKN_GRP); + + *p_ok = ok; +} + +static void namemap_cache1_fn3(const char *domain, + const char *name, + enum lsa_SidType type, + bool expired, + void *private_data) +{ + bool *p_ok = private_data; + bool ok; + + ok = strequal(domain, ""); + ok &= strequal(name, "everyone"); + ok &= (type == SID_NAME_WKN_GRP); + + *p_ok = ok; +} + +static void namemap_cache1_fn4(const struct dom_sid *sid, + enum lsa_SidType type, + bool expired, + void *private_data) +{ + bool *p_ok = private_data; + bool ok; + + ok = dom_sid_equal(sid, &global_sid_World); + ok &= (type == SID_NAME_WKN_GRP); + + *p_ok = ok; +} + +static void namemap_cache1_fn5(const char *domain, + const char *name, + enum lsa_SidType type, + bool expired, + void *private_data) +{ + bool *p_ok = private_data; + bool ok; + + ok = strequal(domain, "samba-dom"); + ok &= strequal(name, ""); + ok &= (type == SID_NAME_DOMAIN); + + *p_ok = ok; +} + +static void namemap_cache1_fn6(const struct dom_sid *sid, + enum lsa_SidType type, + bool expired, + void *private_data) +{ + bool *p_ok = private_data; + bool ok; + + ok = dom_sid_equal(sid, &domsid); + ok &= (type == SID_NAME_DOMAIN); + + *p_ok = ok; +} + +bool run_local_namemap_cache1(int dummy) +{ + bool found; + bool ok; + + ok = gencache_set("SID2NAME/S-1-5-2", "invalid", time(NULL)+60); + if (!ok) { + fprintf(stderr, "gencache_set failed\n"); + return false; + } + + ok = namemap_cache_find_sid(&global_sid_Network, namemap_cache1_fn1, + &found); + if (ok) { + fprintf(stderr, "namemap_cache_find_sid parsed valid value\n"); + return false; + } + + ok = namemap_cache_set_sid2name(&global_sid_Network, + "NT Authority", "Network", + SID_NAME_WKN_GRP, + time(NULL) + 60); + if (!ok) { + fprintf(stderr, "namemap_cache_set_sid2name failed\n"); + return false; + } + + ok = namemap_cache_find_sid(&global_sid_Network, namemap_cache1_fn1, + &found); + if (!ok) { + fprintf(stderr, "namecache_find_sid failed\n"); + return false; + } + if (!found) { + fprintf(stderr, "wrong values found\n"); + return false; + } + + ok = namemap_cache_set_name2sid("NT Authority", "Network", + &global_sid_Network, + SID_NAME_WKN_GRP, + time(NULL) + 60); + if (!ok) { + fprintf(stderr, "namemap_cache_set_name2sid failed\n"); + return false; + } + + ok = namemap_cache_find_name("nt authority", "network", + namemap_cache1_fn2, &found); + if (!ok) { + fprintf(stderr, "namecache_find_name failed\n"); + return false; + } + if (!found) { + fprintf(stderr, "wrong values found\n"); + return false; + } + + ok = namemap_cache_find_name("foo", "bar", namemap_cache1_fn2, &found); + if (ok) { + fprintf(stderr, + "namemap_cache_find_name succeeded unexpectedly\n"); + return false; + } + + /* + * Test "" domain name + */ + + ok = namemap_cache_set_sid2name(&global_sid_World, "", "Everyone", + SID_NAME_WKN_GRP, + time(NULL) + 60); + if (!ok) { + fprintf(stderr, "namemap_cache_set_sid2name failed\n"); + return false; + } + + ok = namemap_cache_find_sid(&global_sid_World, namemap_cache1_fn3, + &found); + if (!ok) { + fprintf(stderr, "namecache_find_sid failed\n"); + return false; + } + if (!found) { + fprintf(stderr, "wrong values found\n"); + return false; + } + + ok = namemap_cache_set_name2sid("", "Everyone", + &global_sid_World, SID_NAME_WKN_GRP, + time(NULL) + 60); + if (!ok) { + fprintf(stderr, "namemap_cache_set failed\n"); + return false; + } + + ok = namemap_cache_find_name("", "everyone", + namemap_cache1_fn4, &found); + if (!ok) { + fprintf(stderr, "namecache_find_name failed\n"); + return false; + } + if (!found) { + fprintf(stderr, "wrong values found\n"); + return false; + } + + /* + * Test domain only + */ + + ok = namemap_cache_set_sid2name(&domsid, "SAMBA-DOM", "", + SID_NAME_DOMAIN, + time(NULL) + 60); + if (!ok) { + fprintf(stderr, "namemap_cache_set failed\n"); + return false; + } + + ok = namemap_cache_find_sid(&domsid, namemap_cache1_fn5, + &found); + if (!ok) { + fprintf(stderr, "namecache_find_sid failed\n"); + return false; + } + if (!found) { + fprintf(stderr, "wrong values found\n"); + return false; + } + + ok = namemap_cache_set_name2sid("SAMBA-DOM", "", + &domsid, SID_NAME_DOMAIN, + time(NULL) + 60); + if (!ok) { + fprintf(stderr, "namemap_cache_set failed\n"); + return false; + } + + ok = namemap_cache_find_name("samba-dom", "", + namemap_cache1_fn6, &found); + if (!ok) { + fprintf(stderr, "namecache_find_name failed\n"); + return false; + } + if (!found) { + fprintf(stderr, "wrong values found\n"); + return false; + } + + return true; +} diff --git a/source3/torture/test_notify.c b/source3/torture/test_notify.c new file mode 100644 index 0000000..b265845 --- /dev/null +++ b/source3/torture/test_notify.c @@ -0,0 +1,731 @@ +/* + Unix SMB/CIFS implementation. + Scalability test for notifies + Copyright (C) Volker Lendecke 2012 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "lib/util/tevent_ntstatus.h" +#include "libcli/security/security.h" +#include "lib/tevent_barrier.h" + +extern int torture_nprocs, torture_numops; + +struct wait_for_one_notify_state { + struct tevent_context *ev; + struct cli_state *cli; + uint16_t dnum; + uint32_t filter; + bool recursive; + unsigned *num_notifies; +}; + +static void wait_for_one_notify_opened(struct tevent_req *subreq); +static void wait_for_one_notify_chkpath_done(struct tevent_req *subreq); +static void wait_for_one_notify_done(struct tevent_req *subreq); +static void wait_for_one_notify_closed(struct tevent_req *subreq); + +static struct tevent_req *wait_for_one_notify_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *path, + uint32_t filter, + bool recursive, + unsigned *num_notifies) +{ + struct tevent_req *req, *subreq; + struct wait_for_one_notify_state *state; + + req = tevent_req_create(mem_ctx, &state, + struct wait_for_one_notify_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + state->filter = filter; + state->recursive = recursive; + state->num_notifies = num_notifies; + + subreq = cli_ntcreate_send( + state, state->ev, state->cli, path, 0, + MAXIMUM_ALLOWED_ACCESS, + 0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, FILE_DIRECTORY_FILE, + SMB2_IMPERSONATION_IMPERSONATION, 0); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, wait_for_one_notify_opened, req); + return req; +} + +static void wait_for_one_notify_opened(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wait_for_one_notify_state *state = tevent_req_data( + req, struct wait_for_one_notify_state); + NTSTATUS status; + + status = cli_ntcreate_recv(subreq, &state->dnum, NULL); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = cli_notify_send(state, state->ev, state->cli, state->dnum, + 0xffff, state->filter, state->recursive); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wait_for_one_notify_done, req); + + /* + * To make sure the notify received at the server, we do another no-op + * that is replied to. + */ + subreq = cli_chkpath_send(state, state->ev, state->cli, "\\"); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wait_for_one_notify_chkpath_done, req); +} + +static void wait_for_one_notify_chkpath_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wait_for_one_notify_state *state = tevent_req_data( + req, struct wait_for_one_notify_state); + NTSTATUS status; + + status = cli_chkpath_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + *state->num_notifies += 1; +} + +static void wait_for_one_notify_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wait_for_one_notify_state *state = tevent_req_data( + req, struct wait_for_one_notify_state); + uint32_t num_changes; + struct notify_change *changes; + NTSTATUS status; + + status = cli_notify_recv(subreq, state, &num_changes, &changes); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = cli_close_send(state, state->ev, state->cli, state->dnum, 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wait_for_one_notify_closed, req); +} + +static void wait_for_one_notify_closed(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wait_for_one_notify_state *state = tevent_req_data( + req, struct wait_for_one_notify_state); + NTSTATUS status; + + status = cli_close_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + *state->num_notifies -= 1; + tevent_req_done(req); +} + +static NTSTATUS wait_for_one_notify_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static void notify_bench2_done(struct tevent_req *req); + +bool run_notify_bench2(int dummy) +{ + struct cli_state *cli; + struct cli_state **clis; + struct tevent_context *ev; + unsigned num_notifies = 0; + NTSTATUS status; + int i; + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + printf("starting notify bench 2 test\n"); + + cli_rmdir(cli, "\\notify.dir\\subdir"); + cli_rmdir(cli, "\\notify.dir"); + + status = cli_mkdir(cli, "\\notify.dir"); + if (!NT_STATUS_IS_OK(status)) { + printf("mkdir failed : %s\n", nt_errstr(status)); + return false; + } + + clis = talloc_array(talloc_tos(), struct cli_state *, torture_nprocs); + if (clis == NULL) { + printf("talloc failed\n"); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + printf("tevent_context_create failed\n"); + return false; + } + + for (i=0; i 0) { + int ret; + ret = tevent_loop_once(ev); + if (ret != 0) { + printf("tevent_loop_once failed: %s\n", + strerror(errno)); + return false; + } + } + + return true; +} + +static void notify_bench2_done(struct tevent_req *req) +{ + NTSTATUS status; + + status = wait_for_one_notify_recv(req); + TALLOC_FREE(req); + if (!NT_STATUS_IS_OK(status)) { + printf("wait_for_one_notify returned %s\n", + nt_errstr(status)); + } +} + +/* + * This test creates a subdirectory. It then waits on a barrier before the + * notify is sent. Then it creates the notify. It then waits for another + * barrier, so that all of the notifies have gone through. It then creates + * another subdirectory, which will trigger notifications to be sent. When the + * notifies have been received, it waits once more before everything is + * cleaned up. + */ + +struct notify_bench3_state { + struct tevent_context *ev; + struct cli_state *cli; + const char *dir; + uint16_t dnum; + const char *subdir_path; + uint16_t subdir_dnum; + int wait_timeout; + struct tevent_barrier *small; + struct tevent_barrier *large; +}; + +static void notify_bench3_mkdir1_done(struct tevent_req *subreq); +static void notify_bench3_before_notify(struct tevent_req *subreq); +static void notify_bench3_chkpath_done(struct tevent_req *subreq); +static void notify_bench3_before_mkdir2(struct tevent_req *subreq); +static void notify_bench3_notify_done(struct tevent_req *subreq); +static void notify_bench3_notifies_done(struct tevent_req *subreq); +static void notify_bench3_mksubdir_done(struct tevent_req *subreq); +static void notify_bench3_before_close_subdir(struct tevent_req *subreq); +static void notify_bench3_close_subdir_done(struct tevent_req *subreq); +static void notify_bench3_deleted_subdir(struct tevent_req *subreq); +static void notify_bench3_deleted_subdirs(struct tevent_req *subreq); +static void notify_bench3_del_on_close_set(struct tevent_req *subreq); +static void notify_bench3_closed(struct tevent_req *subreq); + +static struct tevent_req *notify_bench3_send( + TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct cli_state *cli, + const char *dir, const char *subdir_path, + struct tevent_barrier *small, struct tevent_barrier *large) +{ + struct tevent_req *req, *subreq; + struct notify_bench3_state *state; + + req = tevent_req_create(mem_ctx, &state, struct notify_bench3_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + state->dir = dir; + state->subdir_path = subdir_path; + state->small = small; + state->large = large; + + subreq = cli_ntcreate_send( + state, state->ev, state->cli, state->dir, 0, + MAXIMUM_ALLOWED_ACCESS, 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN_IF, FILE_DIRECTORY_FILE, + SMB2_IMPERSONATION_IMPERSONATION, 0); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, notify_bench3_mkdir1_done, req); + return req; +} + +static void notify_bench3_mkdir1_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + NTSTATUS status; + + status = cli_ntcreate_recv(subreq, &state->dnum, NULL); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = tevent_barrier_wait_send(state, state->ev, state->small); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_before_notify, req); +} + +static void notify_bench3_before_notify(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + int ret; + + ret = tevent_barrier_wait_recv(subreq); + TALLOC_FREE(subreq); + if (ret != 0) { + tevent_req_nterror(req, map_nt_error_from_unix(ret)); + return; + } + subreq = cli_notify_send(state, state->ev, state->cli, state->dnum, + 0xffff, FILE_NOTIFY_CHANGE_ALL, true); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_notify_done, req); + + /* + * To make sure the notify received at the server, we do another no-op + * that is replied to. + */ + subreq = cli_chkpath_send(state, state->ev, state->cli, "\\"); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_chkpath_done, req); +} + +static void notify_bench3_notify_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + uint32_t num_changes; + struct notify_change *changes; + NTSTATUS status; + + status = cli_notify_recv(subreq, state, &num_changes, &changes); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = tevent_barrier_wait_send(state, state->ev, state->large); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_notifies_done, req); +} + +static void notify_bench3_notifies_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + int ret; + + ret = tevent_barrier_wait_recv(subreq); + TALLOC_FREE(subreq); + if (ret != 0) { + tevent_req_nterror(req, map_nt_error_from_unix(ret)); + return; + } +} + +static void notify_bench3_chkpath_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + NTSTATUS status; + + status = cli_chkpath_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + if (state->subdir_path == NULL) { + return; + } + subreq = tevent_barrier_wait_send(state, state->ev, state->small); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_before_mkdir2, req); +} + +static void notify_bench3_before_mkdir2(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + int ret; + + ret = tevent_barrier_wait_recv(subreq); + TALLOC_FREE(subreq); + if (ret != 0) { + tevent_req_nterror(req, map_nt_error_from_unix(ret)); + return; + } + subreq = cli_ntcreate_send( + state, state->ev, state->cli, state->subdir_path, 0, + MAXIMUM_ALLOWED_ACCESS, 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_CREATE, + FILE_DIRECTORY_FILE, + SMB2_IMPERSONATION_IMPERSONATION, 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_mksubdir_done, req); +} + +static void notify_bench3_mksubdir_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + NTSTATUS status; + + status = cli_ntcreate_recv(subreq, &state->subdir_dnum, NULL); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = tevent_barrier_wait_send(state, state->ev, state->large); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_before_close_subdir, + req); +} + +static void notify_bench3_before_close_subdir(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + int ret; + + ret = tevent_barrier_wait_recv(subreq); + TALLOC_FREE(subreq); + if (ret != 0) { + tevent_req_nterror(req, map_nt_error_from_unix(ret)); + return; + } + subreq = cli_close_send(state, + state->ev, + state->cli, + state->subdir_dnum, + 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_close_subdir_done, req); +} + +static void notify_bench3_close_subdir_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + NTSTATUS status; + + status = cli_close_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = cli_rmdir_send(state, state->ev, state->cli, + state->subdir_path); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_deleted_subdir, req); +} + +static void notify_bench3_deleted_subdir(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + NTSTATUS status; + + status = cli_rmdir_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = tevent_barrier_wait_send(state, state->ev, state->small); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_deleted_subdirs, req); +} + +static void notify_bench3_deleted_subdirs(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + int ret; + + ret = tevent_barrier_wait_recv(subreq); + TALLOC_FREE(subreq); + if (ret != 0) { + tevent_req_nterror(req, map_nt_error_from_unix(ret)); + return; + } + subreq = cli_nt_delete_on_close_send(state, state->ev, state->cli, + state->dnum, true); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_del_on_close_set, req); +} + +static void notify_bench3_del_on_close_set(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_bench3_state *state = tevent_req_data( + req, struct notify_bench3_state); + NTSTATUS status; + + status = cli_nt_delete_on_close_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + + subreq = cli_close_send(state, state->ev, state->cli, state->dnum, 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_bench3_closed, req); +} + +static void notify_bench3_closed(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + + status = cli_close_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + tevent_req_done(req); +} + +static NTSTATUS notify_bench3_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static void notify_bench3_done(struct tevent_req *req) +{ + unsigned *num_done = (unsigned *)tevent_req_callback_data_void(req); + NTSTATUS status; + + status = notify_bench3_recv(req); + TALLOC_FREE(req); + if (!NT_STATUS_IS_OK(status)) { + d_printf("notify_bench3 returned %s\n", nt_errstr(status)); + } + *num_done += 1; +} + +static void notify_bench3_barrier_cb(void *private_data) +{ + struct timeval *ts = (struct timeval *)private_data; + struct timeval now; + + GetTimeOfDay(&now); + printf("barrier triggered: %f\n", timeval_elapsed2(ts, &now)); + GetTimeOfDay(ts); +} + +bool run_notify_bench3(int dummy) +{ + struct cli_state **clis; + struct tevent_context *ev; + struct tevent_barrier *small; + struct tevent_barrier *large; + int i; + unsigned num_done = 0; + struct timeval ts, now; + + clis = talloc_array(talloc_tos(), struct cli_state *, torture_nprocs); + if (clis == NULL) { + printf("talloc failed\n"); + return false; + } + + GetTimeOfDay(&ts); + + small = tevent_barrier_init( + talloc_tos(), torture_nprocs * torture_numops, + notify_bench3_barrier_cb, &ts); + if (small == NULL) { + return false; + } + + large = tevent_barrier_init( + talloc_tos(), 2 * torture_nprocs * torture_numops, + notify_bench3_barrier_cb, &ts); + if (large == NULL) { + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + printf("tevent_context_create failed\n"); + return false; + } + + for (i=0; i. +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "libcli/security/security.h" +#include "lib/util/tevent_ntstatus.h" +#include "libsmb/libsmb.h" + +extern char *test_filename; + +struct notify_online_state { + struct tevent_context *ev; + struct cli_state *cli; + uint16_t dnum; + const char *fname; + uint16_t fnum; + bool got_notify; +}; + +static void notify_online_opened_dir(struct tevent_req *subreq); +static void notify_online_notify_callback(struct tevent_req *subreq); +static void notify_online_opened_file(struct tevent_req *subreq); +static void notify_online_sent_read(struct tevent_req *subreq); +static void notify_online_sent_closefile(struct tevent_req *subreq); +static void notify_online_waited(struct tevent_req *subreq); +static void notify_online_sent_closedir(struct tevent_req *subreq); + +static struct tevent_req *notify_online_send( + TALLOC_CTX *mem_ctx, struct tevent_context *ev, + struct cli_state *cli, const char *dname, const char *fname) +{ + struct tevent_req *req, *subreq; + struct notify_online_state *state; + + req = tevent_req_create(mem_ctx, &state, struct notify_online_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + state->fname = fname; + + subreq = cli_ntcreate_send( + state, ev, cli, dname, EXTENDED_RESPONSE_REQUIRED, + SEC_FILE_READ_DATA, 0, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + FILE_OPEN, 0, SMB2_IMPERSONATION_IMPERSONATION, 0); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, notify_online_opened_dir, req); + return req; +} + +static void notify_online_opened_dir(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_online_state *state = tevent_req_data( + req, struct notify_online_state); + NTSTATUS status; + + status = cli_ntcreate_recv(subreq, &state->dnum, NULL); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = cli_notify_send(state, state->ev, state->cli, state->dnum, + 128, FILE_NOTIFY_CHANGE_ATTRIBUTES, false); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_online_notify_callback, req); + + subreq = cli_ntcreate_send( + state, state->ev, state->cli, state->fname, 0, + GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, FILE_NON_DIRECTORY_FILE, + SMB2_IMPERSONATION_IMPERSONATION, 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_online_opened_file, req); +} + +static void notify_online_notify_callback(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_online_state *state = tevent_req_data( + req, struct notify_online_state); + NTSTATUS status; + uint32_t num_changes; + struct notify_change *changes; + + status = cli_notify_recv(subreq, state, &num_changes, &changes); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + if ((num_changes == 1) + && (changes[0].action == NOTIFY_ACTION_MODIFIED) + && (strcmp(changes[0].name, state->fname) == 0)) { + state->got_notify = true; + } + tevent_req_done(req); +} + +static void notify_online_opened_file(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_online_state *state = tevent_req_data( + req, struct notify_online_state); + NTSTATUS status; + + status = cli_ntcreate_recv(subreq, &state->fnum, NULL); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = cli_read_andx_send( + state, state->ev, state->cli, state->fnum, 0, 1); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_online_sent_read, req); +} + +static void notify_online_sent_read(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_online_state *state = tevent_req_data( + req, struct notify_online_state); + NTSTATUS status; + ssize_t received; + uint8_t *buf; + + status = cli_read_andx_recv(subreq, &received, &buf); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = cli_close_send(state, state->ev, state->cli, state->fnum, 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_online_sent_closefile, req); +} + +static void notify_online_sent_closefile(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_online_state *state = tevent_req_data( + req, struct notify_online_state); + NTSTATUS status; + + status = cli_close_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + subreq = tevent_wakeup_send( + state, state->ev, timeval_current_ofs(10, 0)); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_online_waited, req); +} + +static void notify_online_waited(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct notify_online_state *state = tevent_req_data( + req, struct notify_online_state); + + tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + subreq = cli_close_send(state, state->ev, state->cli, state->dnum, 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, notify_online_sent_closedir, req); +} + +static void notify_online_sent_closedir(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + + status = cli_close_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } +} + +static NTSTATUS notify_online_recv(struct tevent_req *req, bool *got_notify) +{ + struct notify_online_state *state = tevent_req_data( + req, struct notify_online_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + return status; + } + *got_notify = state->got_notify; + return NT_STATUS_OK; +} + +static NTSTATUS notify_online(struct cli_state *cli, + const char *dirname, const char *filename, + bool *got_notify) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct tevent_context *ev; + struct tevent_req *req; + NTSTATUS status = NT_STATUS_NO_MEMORY; + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + goto fail; + } + req = notify_online_send(frame, ev, cli, dirname, filename); + if (req == NULL) { + goto fail; + } + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + goto fail; + } + status = notify_online_recv(req, got_notify); + fail: + TALLOC_FREE(frame); + return status; +} + +bool run_notify_online(int dummy) +{ + struct cli_state *cli; + NTSTATUS status; + char *p; + const char *dir; + const char *file; + bool got_notify = false; + + printf("Starting NOTIFY_ONLINE\n"); + + if (test_filename == NULL) { + fprintf(stderr, "<-f filename> missing\n"); + return false; + } + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + p = strrchr(test_filename, '/'); + if (p != NULL) { + dir = SMB_STRNDUP(test_filename, p-test_filename); + file = SMB_STRDUP(p+1); + } else { + dir = ""; + file = test_filename; + } + + status = notify_online(cli, dir, file, &got_notify); + d_printf("notify_online returned %s (%d)\n", nt_errstr(status), + (int)got_notify); + torture_close_connection(cli); + return NT_STATUS_IS_OK(status) && got_notify; +} diff --git a/source3/torture/test_nttrans_create.c b/source3/torture/test_nttrans_create.c new file mode 100644 index 0000000..5e7ce7e --- /dev/null +++ b/source3/torture/test_nttrans_create.c @@ -0,0 +1,108 @@ +/* + Unix SMB/CIFS implementation. + Basic test for share secdescs vs nttrans_create + Copyright (C) Volker Lendecke 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "libcli/security/dom_sid.h" +#include "libcli/security/secdesc.h" +#include "libcli/security/security.h" + +bool run_nttrans_create(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status, status2; + bool ret = false; + struct security_ace ace; + struct security_acl acl; + struct security_descriptor *sd; + const char *fname = "transtest"; + uint16_t fnum, fnum2; + struct dom_sid owner; + + printf("Starting NTTRANS_CREATE\n"); + + if (!torture_open_connection(&cli, 0)) { + printf("torture_open_connection failed\n"); + goto fail; + } + + ZERO_STRUCT(ace); + ace.type = SEC_ACE_TYPE_ACCESS_ALLOWED; + ace.access_mask = SEC_RIGHTS_FILE_ALL & ~SEC_STD_WRITE_DAC; + sid_copy(&ace.trustee, &global_sid_World); + + acl.revision = SECURITY_ACL_REVISION_NT4; + acl.size = 0; + acl.num_aces = 1; + acl.aces = &ace; + + dom_sid_parse("S-1-22-1-1000", &owner); + + sd = make_sec_desc(talloc_tos(), + SECURITY_DESCRIPTOR_REVISION_1, + SEC_DESC_SELF_RELATIVE| + SEC_DESC_DACL_PRESENT|SEC_DESC_OWNER_DEFAULTED| + SEC_DESC_GROUP_DEFAULTED, + NULL, NULL, NULL, &acl, NULL); + if (sd == NULL) { + d_fprintf(stderr, "make_sec_desc failed\n"); + goto fail; + } + + status = cli_nttrans_create( + cli, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS| + READ_CONTROL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| FILE_SHARE_DELETE, + FILE_CREATE, 0, 0, sd, NULL, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_nttrans_create returned %s\n", + nt_errstr(status)); + goto fail; + } + + cli_query_secdesc(cli, fnum, talloc_tos(), NULL); + + status2 = cli_ntcreate(cli, fname, 0, WRITE_DAC_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + + status = cli_nt_delete_on_close(cli, fnum, true); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_nt_delete_on_close returned %s\n", + nt_errstr(status)); + goto fail; + } + + if (!NT_STATUS_EQUAL(status2, NT_STATUS_ACCESS_DENIED)) { + d_fprintf(stderr, "cli_ntcreate returned %s\n", + nt_errstr(status)); + goto fail; + } + + ret = true; +fail: + if (cli != NULL) { + torture_close_connection(cli); + } + return ret; +} diff --git a/source3/torture/test_nttrans_fsctl.c b/source3/torture/test_nttrans_fsctl.c new file mode 100644 index 0000000..aea80c5 --- /dev/null +++ b/source3/torture/test_nttrans_fsctl.c @@ -0,0 +1,288 @@ +/* + Unix SMB/CIFS implementation. + Basic test for NTTRANS FSCTL requests (copied from NTTRANS CREATE) + Copyright (C) Richard Sharpe 2011 + Copyright (C) Volker Lendecke 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "libcli/security/security.h" + +bool run_nttrans_fsctl(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + bool ret = false; + const char *fname = "fsctltest"; + uint16_t fnum; + uint16_t setup[4]; + uint8_t *object_data = NULL; + uint8_t *ranges = NULL; + uint8_t range_data[16]; + uint8_t *param_data = NULL; + uint8_t data[1] = { 0x1 }; + uint32_t rdata_size; + uint32_t rparam_size; + + printf("Starting NTTRANS_FSCTL\n"); + + if (!torture_open_connection(&cli, 0)) { + printf("torture_open_connection failed\n"); + goto fail; + } + + status = cli_nttrans_create( + cli, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS| + READ_CONTROL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| FILE_SHARE_DELETE, + FILE_CREATE, 0, 0, NULL, NULL, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_nttrans_create returned %s\n", + nt_errstr(status)); + goto fail; + } + + status = cli_nt_delete_on_close(cli, fnum, true); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_nt_delete_on_close returned %s\n", + nt_errstr(status)); + goto fail; + } + + /* Fill in for FSCTL_SET_SPARSE and call cli_trans ... */ + SIVAL(setup, 0, FSCTL_SET_SPARSE); /* returns value */ + SSVAL(setup, 4, fnum); + SCVAL(setup, 6, 0x1); /* It is an fsctl */ + SCVAL(setup, 7, 0x0); + + status = cli_trans(talloc_tos(), cli, SMBnttrans, + NULL, fnum, + NT_TRANSACT_IOCTL, 0, + setup, 4, 4, + NULL, 0, 0, /* param, param_num, max_param */ + data, 1, 1, /* data, data_len, max_data */ + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup, min_rsetup, num_rsetup */ + NULL, 0, NULL, /* rparam, min_rparam, num_rparam */ + NULL, 0, NULL); /* rdata, ... */ + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_trans of FSCTL_SET_SPARSE returned %s instead of NT_STATUS_OK\n", + nt_errstr(status)); + goto fail; + } + + printf("FSCTL_SET_SPARSE returned correct status \n"); + + /* Fill in for FSCTL_CREATE_OR_GET_OBJECT_ID and call cli_trans ... */ + SIVAL(setup, 0, FSCTL_CREATE_OR_GET_OBJECT_ID); /* returns value */ + SSVAL(setup, 4, fnum); + SCVAL(setup, 6, 0x1); /* It is an fsctl */ + SCVAL(setup, 7, 0x0); + + status = cli_trans(talloc_tos(), cli, SMBnttrans, + NULL, fnum, + NT_TRANSACT_IOCTL, 0, + setup, 4, 4, + NULL, 0, 0, /* param, param_num, max_param */ + NULL, 0, 64, /* data, data_len, max_data */ + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup, min_rsetup, num_rsetup */ + ¶m_data, 0, &rparam_size, /* rparam, min_rparam, num_rparam */ + &object_data, 0, &rdata_size); /* rdata, ... */ + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_trans of FSCTL_CREATE_OR_GET_OBJECT_ID returned %s instead of NT_STATUS_OK\n", + nt_errstr(status)); + goto fail; + } + + TALLOC_FREE(object_data); + TALLOC_FREE(param_data); + + printf("FSCTL_CREATE_OR_GET_OBJECT_ID returned correct status \n"); + + /* Fill in for FSCTL_GET_REPARSE_POINT and call cli_trans ... */ + SIVAL(setup, 0, FSCTL_GET_REPARSE_POINT); /* returns NOT A REPARSE POINT */ + SSVAL(setup, 4, fnum); + SCVAL(setup, 6, 0x1); /* It is an fsctl */ + SCVAL(setup, 7, 0x0); + + status = cli_trans(talloc_tos(), cli, SMBnttrans, + NULL, fnum, + NT_TRANSACT_IOCTL, 0, + setup, 4, 4, + NULL, 0, 0, /* param, param_num, max_param */ + NULL, 0, 0, /* data, data_len, max_data */ + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup, min_rsetup, num_rsetup */ + NULL, 0, NULL, /* rparam, min_rparam, num_rparam */ + NULL, 0, NULL); /* rdata, ... */ + if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_REPARSE_POINT)) { + d_fprintf(stderr, "cli_trans of FSCTL_GET_REPARSE_POINT returned %s instead of NT_STATUS_NOT_A_REPARSE_POINT\n", + nt_errstr(status)); + goto fail; + } + + printf("FSCTL_GET_REPARSE_POINT returned correct status \n"); + + /* Fill in for FSCTL_SET_REPARSE_POINT and call cli_trans ... */ + SIVAL(setup, 0, FSCTL_SET_REPARSE_POINT); /* returns INVALID_BUFFER_SIZE */ + SSVAL(setup, 4, fnum); + SCVAL(setup, 6, 0x1); /* It is an fsctl */ + SCVAL(setup, 7, 0x0); + + status = cli_trans(talloc_tos(), cli, SMBnttrans, + NULL, fnum, + NT_TRANSACT_IOCTL, 0, + setup, 4, 4, + NULL, 0, 0, /* param, param_num, max_param */ + NULL, 0, 0, /* data, data_len, max_data */ + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup, min_rsetup, num_rsetup */ + NULL, 0, NULL, /* rparam, min_rparam, num_rparam */ + NULL, 0, NULL); /* rdata, ... */ + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_BUFFER_SIZE)) { + d_fprintf(stderr, + "cli_trans of FSCTL_SET_REPARSE_POINT returned %s " + "instead of NT_STATUS_INVALID_BUFFER_SIZE\n", + nt_errstr(status)); + goto fail; + } + + printf("FSCTL_SET_REPARSE_POINT returned correct status \n"); + + /* + * Fill in for FSCTL_GET_SHADOW_COPY_DATA and call cli_trans ... what + * we do is send an invalid data length to provoke an INVALID PARAMETER + * response. + */ + SIVAL(setup, 0, FSCTL_GET_SHADOW_COPY_DATA); /* Should return IVN VAL */ + SSVAL(setup, 4, fnum); + SCVAL(setup, 6, 0x1); /* It is an fsctl */ + SCVAL(setup, 7, 0x0); + + memset(range_data, 0, sizeof(range_data)); /* 0 and 0 */ + + status = cli_trans(talloc_tos(), cli, SMBnttrans, + NULL, fnum, + NT_TRANSACT_IOCTL, 0, + setup, 4, 4, + NULL, 0, 0, /* param, param_num, max_param */ + NULL, 0, 8, /* data, data_len, max_data */ + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup, min_rsetup, num_rsetup */ + NULL, 0, NULL, /* rparam, min_rparam, num_rparam */ + &ranges, 0, &rdata_size); /* rdata, ... */ + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { + d_fprintf(stderr, "cli_trans of FSCTL_QUERY_ALLOCATED_RANGES returned %s instead of NT_STATUS_INVALID_PARAMETER\n", + nt_errstr(status)); + goto fail; + } + + TALLOC_FREE(ranges); + + printf("FSCTL_GET_SHADOW_COPY_DATA returned correct status \n"); + /* + * Fill in for FSCTL_FIND_FILES_BY and call cli_trans ... here we are + * only probing for its existence by provoking an INVALID PARAM + * response with a short and invalid SID in range_data + */ + SIVAL(setup, 0, FSCTL_FIND_FILES_BY_SID); /* Should return 16 bytes */ + SSVAL(setup, 4, fnum); + SCVAL(setup, 6, 0x1); /* It is an fsctl */ + SCVAL(setup, 7, 0x0); + + memset(range_data, 0, sizeof(range_data)); /* 0 and 0 */ + + status = cli_trans(talloc_tos(), cli, SMBnttrans, + NULL, fnum, + NT_TRANSACT_IOCTL, 0, + setup, 4, 4, + NULL, 0, 0, /* param, param_num, max_param */ + range_data, 4, 16, /* data, data_len, max_data */ + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup, min_rsetup, num_rsetup */ + NULL, 0, NULL, /* rparam, min_rparam, num_rparam */ + &ranges, 0, &rdata_size); /* rdata, ... */ + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { + d_fprintf(stderr, "cli_trans of FSCTL_QUERY_ALLOCATED_RANGES returned %s instead of NT_STATUS_INVALID_PARAMETER\n", + nt_errstr(status)); + goto fail; + } + + printf("FSCTL_FIND_FILES_BY_SID returned correct status \n"); + + /* Fill in for FSCTL_QUERY_ALLOCATED_RANGES and call cli_trans ... */ + SIVAL(setup, 0, FSCTL_QUERY_ALLOCATED_RANGES); /* Should return 16 bytes */ + SSVAL(setup, 4, fnum); + SCVAL(setup, 6, 0x1); /* It is an fsctl */ + SCVAL(setup, 7, 0x0); + + memset(range_data, 0, sizeof(range_data)); /* 0 and 0 */ + + status = cli_trans(talloc_tos(), cli, SMBnttrans, + NULL, fnum, + NT_TRANSACT_IOCTL, 0, + setup, 4, 4, + NULL, 0, 0, /* param, param_num, max_param */ + range_data, 16, 16, /* data, data_len, max_data */ + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup, min_rsetup, num_rsetup */ + NULL, 0, NULL, /* rparam, min_rparam, num_rparam */ + &ranges, 0, &rdata_size); /* rdata, ... */ + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_trans of FSCTL_QUERY_ALLOCATED_RANGES returned %s instead of NT_STATUS_OK\n", + nt_errstr(status)); + goto fail; + } + + TALLOC_FREE(ranges); + + printf("FSCTL_QUERY_ALLOCATED_RANGES returned correct status \n"); + + /* Fill in for FSCTL_IS_VOLUME_DIRTY and call cli_trans ... */ + SIVAL(setup, 0, FSCTL_IS_VOLUME_DIRTY); /* Should return INVAL PARAM */ + SSVAL(setup, 4, fnum); + SCVAL(setup, 6, 0x1); /* It is an fsctl */ + SCVAL(setup, 7, 0x0); + + status = cli_trans(talloc_tos(), cli, SMBnttrans, + NULL, fnum, + NT_TRANSACT_IOCTL, 0, + setup, 4, 4, + NULL, 0, 0, /* param, param_num, max_param */ + NULL, 0, 0, /* data, data_len, max_data */ + NULL, /* recv_flags2 */ + NULL, 0, NULL, /* rsetup, min_rsetup, num_rsetup */ + NULL, 0, NULL, /* rparam, min_rparam, num_rparam */ + NULL, 0, NULL); /* rdata, ... */ + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { + d_fprintf(stderr, "cli_trans of FSCTL_IS_VOLUME_DIRTY returned %s instead of NT_STATUS_INVALID_PARAMETER\n", + nt_errstr(status)); + goto fail; + } + + printf("FSCTL_IS_VOLUME_DIRTY returned correct status \n"); + + ret = true; +fail: + if (cli != NULL) { + torture_close_connection(cli); + } + return ret; +} diff --git a/source3/torture/test_oplock_cancel.c b/source3/torture/test_oplock_cancel.c new file mode 100644 index 0000000..86ce5b7 --- /dev/null +++ b/source3/torture/test_oplock_cancel.c @@ -0,0 +1,168 @@ +/* + Unix SMB/CIFS implementation. + Test cleanup behaviour + Copyright (C) Volker Lendecke 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "locking/proto.h" +#include "torture/proto.h" +#include "system/filesys.h" +#include "system/select.h" +#include "libsmb/libsmb.h" +#include "libcli/smb/smbXcli_base.h" +#include "libcli/security/security.h" +#include "lib/util/tevent_ntstatus.h" + +struct create_cancel_state { + uint8_t dummy; +}; + +static void create_cancel_done(struct tevent_req *subreq); + +static struct tevent_req *create_cancel_send( + TALLOC_CTX *mem_ctx, struct tevent_context *ev, + struct cli_state *cli, const char *fname) +{ + struct tevent_req *req, *subreq; + struct create_cancel_state *state; + + req = tevent_req_create(mem_ctx, &state, struct create_cancel_state); + if (req == NULL) { + return NULL; + } + + subreq = cli_ntcreate_send( + mem_ctx, ev, cli, fname, 0, FILE_GENERIC_READ, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_OPEN_IF, 0, SMB2_IMPERSONATION_IMPERSONATION, 0); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + if (!tevent_req_cancel(subreq)) { + tevent_req_oom(req); + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, create_cancel_done, req); + return req; +} + +static void create_cancel_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + + status = cli_ntcreate_recv(subreq, NULL, NULL); + TALLOC_FREE(subreq); + if (!NT_STATUS_EQUAL(status, NT_STATUS_CANCELLED)) { + if (NT_STATUS_IS_OK(status)) { + status = NT_STATUS_UNSUCCESSFUL; + } + tevent_req_nterror(req, status); + return; + } + tevent_req_done(req); +} + +static NTSTATUS create_cancel_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static NTSTATUS create_cancel(struct cli_state *cli, const char *fname) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct tevent_context *ev; + struct tevent_req *req; + NTSTATUS status = NT_STATUS_NO_MEMORY; + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + goto fail; + } + req = create_cancel_send(frame, ev, cli, fname); + if (req == NULL) { + goto fail; + } + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + goto fail; + } + status = create_cancel_recv(req); + fail: + TALLOC_FREE(frame); + return status; +} + +bool run_oplock_cancel(int dummy) +{ + struct cli_state *cli1, *cli2; + const char *fname = "oplock-cancel"; + uint16_t fnum1; + NTSTATUS status; + /* + * Currently this test seems to work only + * with SMB2/3 and only against Samba. + * + * TODO: we should change our server + * to ignore cancel for SMB2 Create + * and behave like Windows. + */ + int flags = CLI_FULL_CONNECTION_DISABLE_SMB1; + + if (!torture_open_connection_flags(&cli1, 0, flags)) { + return false; + } + cli1->use_oplocks = true; + + if (!torture_open_connection_flags(&cli2, 0, flags)) { + return false; + } + cli2->use_oplocks = true; + + status = cli_ntcreate( + cli1, fname, 0, FILE_GENERIC_READ, FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0, + &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_ntcreate failed: %s\n", nt_errstr(status)); + return false; + } + + status = create_cancel(cli2, fname); + if (!NT_STATUS_IS_OK(status)) { + d_printf("create_cancel failed: %s\n", nt_errstr(status)); + return false; + } + + cli_close(cli1, fnum1); + + TALLOC_FREE(cli1); + + /* + * Give cli1's smbd time to inform cli2's smbd + */ + smb_msleep(5000); + + status = cli_unlink(cli2, fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_unlink failed: %s\n", nt_errstr(status)); + return false; + } + + return true; +} diff --git a/source3/torture/test_posix.c b/source3/torture/test_posix.c new file mode 100644 index 0000000..ca40336 --- /dev/null +++ b/source3/torture/test_posix.c @@ -0,0 +1,1972 @@ +/* + Unix SMB/CIFS implementation. + Copyright (C) Ralph Boehme 2020 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "libcli/security/security.h" +#include "libsmb/libsmb.h" +#include "libsmb/clirap.h" +#include "libsmb/proto.h" +#include "../libcli/smb/smbXcli_base.h" +#include "util_sd.h" +#include "trans2.h" + +extern struct cli_credentials *torture_creds; +extern fstring host, workgroup, share, password, username, myname; + +struct posix_test_entry { + const char *name; + const char *target; + const char *expected; + uint32_t attr_win; + uint32_t attr_lin; + uint64_t returned_size; + bool ok; +}; + +enum client_flavour { WINDOWS, POSIX }; + +struct posix_test_state { + enum client_flavour flavour; + struct posix_test_entry *entries; +}; + +static NTSTATUS posix_ls_fn(struct file_info *finfo, + const char *name, + void *_state) +{ + struct posix_test_state *state = + (struct posix_test_state *)_state; + struct posix_test_entry *e = state->entries; + + for (; e->name != NULL; e++) { + uint32_t attr; + if (!strequal(finfo->name, e->expected)) { + continue; + } + if (state->flavour == WINDOWS) { + attr = e->attr_win; + } else { + attr = e->attr_lin; + } + if (attr != finfo->attr) { + break; + } + e->ok = true; + e->returned_size = finfo->size; + break; + } + + return NT_STATUS_OK; +} + +static void posix_test_entries_reset(struct posix_test_state *state) +{ + struct posix_test_entry *e = state->entries; + + for (; e->name != NULL; e++) { + e->ok = false; + e->returned_size = 0; + } +} + +static bool posix_test_entry_check(struct posix_test_state *state, + const char *name, + bool expected, + uint64_t expected_size) +{ + struct posix_test_entry *e = state->entries; + bool result = false; + + for (; e->name != NULL; e++) { + if (strequal(name, e->name)) { + result = e->ok; + break; + } + } + if (e->name == NULL) { + printf("test failed, unknown name: %s\n", name); + return false; + } + + if (expected == result) { + return true; + } + + printf("test failed, %s: %s\n", + expected ? "missing" : "unexpected", + name); + + return false; +} + +/* + Test non-POSIX vs POSIX ls * of symlinks + */ +bool run_posix_ls_wildcard_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + struct cli_state *cli_win = NULL; + uint16_t fnum = (uint16_t)-1; + NTSTATUS status; + const char *file = "file"; + const char *symlnk_dangling = "dangling"; + const char *symlnk_dst_dangling = "xxxxxxx"; + const char *symlnk_in_share = "symlnk_in_share"; + const char *symlnk_dst_in_share = file; + const char *symlnk_outside_share = "symlnk_outside_share"; + const char *symlnk_dst_outside_share = "/etc/passwd"; + struct posix_test_entry entries[] = { + { + .name = file, + .target = NULL, + .expected = file, + .attr_win = FILE_ATTRIBUTE_ARCHIVE, + .attr_lin = FILE_ATTRIBUTE_ARCHIVE, + }, { + .name = symlnk_dangling, + .target = symlnk_dst_dangling, + .expected = symlnk_dangling, + .attr_win = FILE_ATTRIBUTE_INVALID, + .attr_lin = FILE_ATTRIBUTE_NORMAL, + }, { + .name = symlnk_in_share, + .target = symlnk_dst_in_share, + .expected = symlnk_in_share, + .attr_win = FILE_ATTRIBUTE_ARCHIVE, + .attr_lin = FILE_ATTRIBUTE_NORMAL, + }, { + .name = symlnk_outside_share, + .target = symlnk_dst_outside_share, + .expected = symlnk_outside_share, + .attr_win = FILE_ATTRIBUTE_INVALID, + .attr_lin = FILE_ATTRIBUTE_NORMAL, + }, { + .name = NULL, + } + }; + struct posix_test_state _state = { + .entries = entries, + }; + struct posix_test_state *state = &_state; + int i; + bool correct = false; + + frame = talloc_stackframe(); + + printf("Starting POSIX-LS-WILDCARD test\n"); + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + if (!torture_open_connection(&cli_win, 0)) { + TALLOC_FREE(frame); + return false; + } + + torture_conn_set_sockopt(cli_unix); + torture_conn_set_sockopt(cli_win); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + cli_posix_unlink(cli_unix, file); + cli_posix_unlink(cli_unix, symlnk_dangling); + cli_posix_unlink(cli_unix, symlnk_in_share); + cli_posix_unlink(cli_unix, symlnk_outside_share); + + status = cli_posix_open(cli_unix, + file, + O_RDWR|O_CREAT, + 0666, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + file, + nt_errstr(status)); + goto out; + } + + status = cli_close(cli_unix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + for (i = 0; entries[i].name != NULL; i++) { + if (entries[i].target == NULL) { + continue; + } + status = cli_posix_symlink(cli_unix, + entries[i].target, + entries[i].name); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX symlink of %s failed (%s)\n", + symlnk_dangling, nt_errstr(status)); + goto out; + } + } + + printf("Doing Windows ls *\n"); + state->flavour = WINDOWS; + + status = cli_list(cli_win, "*", 0, posix_ls_fn, state); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_list failed %s\n", nt_errstr(status)); + goto out; + } + + if (!posix_test_entry_check(state, file, true, 0)) { + goto out; + } + if (!posix_test_entry_check(state, symlnk_dangling, false, 0)) { + goto out; + } + if (!posix_test_entry_check(state, symlnk_outside_share, false, 0)) { + goto out; + } + if (!posix_test_entry_check(state, symlnk_in_share, true, 0)) { + goto out; + } + + posix_test_entries_reset(state); + + printf("Doing POSIX ls *\n"); + state->flavour = POSIX; + + status = cli_list(cli_unix, "*", 0, posix_ls_fn, state); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + + if (!posix_test_entry_check(state, file, true, 0)) { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_dangling, + true, + strlen(symlnk_dst_dangling))) + { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_outside_share, + true, + strlen(symlnk_dst_outside_share))) + { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_in_share, + true, + strlen(symlnk_dst_in_share))) { + goto out; + } + + printf("POSIX-LS-WILDCARD test passed\n"); + correct = true; + +out: + cli_posix_unlink(cli_unix, file); + cli_posix_unlink(cli_unix, symlnk_dangling); + cli_posix_unlink(cli_unix, symlnk_in_share); + cli_posix_unlink(cli_unix, symlnk_outside_share); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + if (!torture_close_connection(cli_win)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* + Test non-POSIX vs POSIX ls single of symlinks + */ +bool run_posix_ls_single_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + struct cli_state *cli_win = NULL; + uint16_t fnum = (uint16_t)-1; + NTSTATUS status; + const char *file = "file"; + const char *symlnk_dangling = "dangling"; + const char *symlnk_dst_dangling = "xxxxxxx"; + const char *symlnk_in_share = "symlnk_in_share"; + const char *symlnk_dst_in_share = file; + const char *symlnk_outside_share = "symlnk_outside_share"; + const char *symlnk_dst_outside_share = "/etc/passwd"; + struct posix_test_entry entries[] = { + { + .name = file, + .target = NULL, + .expected = file, + .attr_win = FILE_ATTRIBUTE_ARCHIVE, + .attr_lin = FILE_ATTRIBUTE_ARCHIVE, + }, { + .name = symlnk_dangling, + .target = symlnk_dst_dangling, + .expected = symlnk_dangling, + .attr_win = FILE_ATTRIBUTE_INVALID, + .attr_lin = FILE_ATTRIBUTE_NORMAL, + }, { + .name = symlnk_in_share, + .target = symlnk_dst_in_share, + .expected = symlnk_in_share, + .attr_win = FILE_ATTRIBUTE_ARCHIVE, + .attr_lin = FILE_ATTRIBUTE_NORMAL, + }, { + .name = symlnk_outside_share, + .target = symlnk_dst_outside_share, + .expected = symlnk_outside_share, + .attr_win = FILE_ATTRIBUTE_INVALID, + .attr_lin = FILE_ATTRIBUTE_NORMAL, + }, { + .name = NULL, + } + }; + struct posix_test_state _state = { + .entries = &entries[0], + }; + struct posix_test_state *state = &_state; + int i; + bool correct = false; + + frame = talloc_stackframe(); + + printf("Starting POSIX-LS-SINGLE test\n"); + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + if (!torture_init_connection(&cli_win)) { + TALLOC_FREE(frame); + return false; + } + + status = smbXcli_negprot(cli_win->conn, + cli_win->timeout, + lp_client_min_protocol(), + lp_client_max_protocol(), + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + TALLOC_FREE(frame); + return false; + } + + status = cli_session_setup_creds(cli_win, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_sesssetup returned %s\n", nt_errstr(status)); + TALLOC_FREE(frame); + return false; + } + + status = cli_tree_connect(cli_win, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + TALLOC_FREE(frame); + return false; + } + torture_conn_set_sockopt(cli_unix); + torture_conn_set_sockopt(cli_win); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + cli_posix_unlink(cli_unix, file); + cli_posix_unlink(cli_unix, symlnk_dangling); + cli_posix_unlink(cli_unix, symlnk_in_share); + cli_posix_unlink(cli_unix, symlnk_outside_share); + + status = cli_posix_open(cli_unix, + file, + O_RDWR|O_CREAT, + 0666, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + file, + nt_errstr(status)); + goto out; + } + + status = cli_close(cli_unix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + for (i = 0; entries[i].name != NULL; i++) { + if (entries[i].target == NULL) { + continue; + } + status = cli_posix_symlink(cli_unix, + entries[i].target, + entries[i].name); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX symlink of %s failed (%s)\n", + symlnk_dangling, nt_errstr(status)); + goto out; + } + } + + printf("Doing Windows ls single\n"); + state->flavour = WINDOWS; + + cli_list(cli_win, file, 0, posix_ls_fn, state); + cli_list(cli_win, symlnk_dangling, 0, posix_ls_fn, state); + cli_list(cli_win, symlnk_outside_share, 0, posix_ls_fn, state); + cli_list(cli_win, symlnk_in_share, 0, posix_ls_fn, state); + + if (!posix_test_entry_check(state, file, true, 0)) { + goto out; + } + if (!posix_test_entry_check(state, symlnk_dangling, false, 0)) { + goto out; + } + if (!posix_test_entry_check(state, symlnk_outside_share, false, 0)) { + goto out; + } + if (!posix_test_entry_check(state, symlnk_in_share, true, 0)) { + goto out; + } + + posix_test_entries_reset(state); + + printf("Doing POSIX ls single\n"); + state->flavour = POSIX; + + cli_list(cli_unix, file, 0, posix_ls_fn, state); + cli_list(cli_unix, symlnk_dangling, 0, posix_ls_fn, state); + cli_list(cli_unix, symlnk_outside_share, 0, posix_ls_fn, state); + cli_list(cli_unix, symlnk_in_share, 0, posix_ls_fn, state); + + if (!posix_test_entry_check(state, file, true, 0)) { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_dangling, + true, + strlen(symlnk_dst_dangling))) + { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_outside_share, + true, + strlen(symlnk_dst_outside_share))) + { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_in_share, + true, + strlen(symlnk_dst_in_share))) { + goto out; + } + + printf("POSIX-LS-SINGLE test passed\n"); + correct = true; + +out: + cli_posix_unlink(cli_unix, file); + cli_posix_unlink(cli_unix, symlnk_dangling); + cli_posix_unlink(cli_unix, symlnk_in_share); + cli_posix_unlink(cli_unix, symlnk_outside_share); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + if (!torture_close_connection(cli_win)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* + Test POSIX readlink of symlinks + */ +bool run_posix_readlink_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + uint16_t fnum = (uint16_t)-1; + NTSTATUS status; + const char *file = "file"; + const char *symlnk_dangling = "dangling"; + const char *symlnk_dst_dangling = "xxxxxxx"; + const char *symlnk_in_share = "symlnk_in_share"; + const char *symlnk_dst_in_share = file; + const char *symlnk_outside_share = "symlnk_outside_share"; + const char *symlnk_dst_outside_share = "/etc/passwd"; + struct posix_test_entry entries[] = { + { + .name = symlnk_dangling, + .target = symlnk_dst_dangling, + .expected = symlnk_dangling, + }, { + .name = symlnk_in_share, + .target = symlnk_dst_in_share, + .expected = symlnk_in_share, + }, { + .name = symlnk_outside_share, + .target = symlnk_dst_outside_share, + .expected = symlnk_outside_share, + }, { + .name = NULL, + } + }; + struct posix_test_state _state = { + .entries = &entries[0], + }; + struct posix_test_state *state = &_state; + int i; + bool correct = false; + + frame = talloc_stackframe(); + + printf("Starting POSIX-READLINK test\n"); + state->flavour = POSIX; + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + torture_conn_set_sockopt(cli_unix); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + cli_posix_unlink(cli_unix, file); + cli_posix_unlink(cli_unix, symlnk_dangling); + cli_posix_unlink(cli_unix, symlnk_in_share); + cli_posix_unlink(cli_unix, symlnk_outside_share); + + status = cli_posix_open(cli_unix, + file, + O_RDWR|O_CREAT, + 0666, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + file, + nt_errstr(status)); + goto out; + } + + status = cli_close(cli_unix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + for (i = 0; entries[i].name != NULL; i++) { + status = cli_posix_symlink(cli_unix, + entries[i].target, + entries[i].name); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX symlink of %s failed (%s)\n", + symlnk_dangling, nt_errstr(status)); + goto out; + } + } + + for (i = 0; entries[i].name != NULL; i++) { + char *target = NULL; + + status = cli_readlink( + cli_unix, + entries[i].name, + talloc_tos(), + &target, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX readlink on %s failed (%s)\n", + entries[i].name, nt_errstr(status)); + goto out; + } + if (strequal(target, entries[i].target)) { + entries[i].ok = true; + entries[i].returned_size = strlen(target); + } + } + + if (!posix_test_entry_check(state, + symlnk_dangling, + true, + strlen(symlnk_dst_dangling))) + { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_outside_share, + true, + strlen(symlnk_dst_outside_share))) + { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_in_share, + true, + strlen(symlnk_dst_in_share))) { + goto out; + } + + printf("POSIX-READLINK test passed\n"); + correct = true; + +out: + cli_posix_unlink(cli_unix, file); + cli_posix_unlink(cli_unix, symlnk_dangling); + cli_posix_unlink(cli_unix, symlnk_in_share); + cli_posix_unlink(cli_unix, symlnk_outside_share); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* + Test POSIX stat of symlinks + */ +bool run_posix_stat_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + uint16_t fnum = (uint16_t)-1; + NTSTATUS status; + const char *file = "file"; + const char *symlnk_dangling = "dangling"; + const char *symlnk_dst_dangling = "xxxxxxx"; + const char *symlnk_in_share = "symlnk_in_share"; + const char *symlnk_dst_in_share = file; + const char *symlnk_outside_share = "symlnk_outside_share"; + const char *symlnk_dst_outside_share = "/etc/passwd"; + struct posix_test_entry entries[] = { + { + .name = symlnk_dangling, + .target = symlnk_dst_dangling, + .expected = symlnk_dangling, + }, { + .name = symlnk_in_share, + .target = symlnk_dst_in_share, + .expected = symlnk_in_share, + }, { + .name = symlnk_outside_share, + .target = symlnk_dst_outside_share, + .expected = symlnk_outside_share, + }, { + .name = NULL, + } + }; + struct posix_test_state _state = { + .entries = &entries[0], + }; + struct posix_test_state *state = &_state; + int i; + bool correct = false; + + frame = talloc_stackframe(); + + printf("Starting POSIX-STAT test\n"); + state->flavour = POSIX; + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + torture_conn_set_sockopt(cli_unix); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + cli_posix_unlink(cli_unix, file); + cli_posix_unlink(cli_unix, symlnk_dangling); + cli_posix_unlink(cli_unix, symlnk_in_share); + cli_posix_unlink(cli_unix, symlnk_outside_share); + + status = cli_posix_open(cli_unix, + file, + O_RDWR|O_CREAT, + 0666, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + file, + nt_errstr(status)); + goto out; + } + + status = cli_close(cli_unix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + for (i = 0; entries[i].name != NULL; i++) { + status = cli_posix_symlink(cli_unix, + entries[i].target, + entries[i].name); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX symlink of %s failed (%s)\n", + symlnk_dangling, nt_errstr(status)); + goto out; + } + } + + for (i = 0; entries[i].name != NULL; i++) { + SMB_STRUCT_STAT sbuf; + + status = cli_posix_stat(cli_unix, + entries[i].name, + &sbuf); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX stat on %s failed (%s)\n", + entries[i].name, nt_errstr(status)); + continue; + } + entries[i].ok = true; + entries[i].returned_size = sbuf.st_ex_size; + } + + if (!posix_test_entry_check(state, + symlnk_dangling, + true, + strlen(symlnk_dst_dangling))) + { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_outside_share, + true, + strlen(symlnk_dst_outside_share))) + { + goto out; + } + if (!posix_test_entry_check(state, + symlnk_in_share, + true, + strlen(symlnk_dst_in_share))) { + goto out; + } + + printf("POSIX-STAT test passed\n"); + correct = true; + +out: + cli_posix_unlink(cli_unix, file); + cli_posix_unlink(cli_unix, symlnk_dangling); + cli_posix_unlink(cli_unix, symlnk_in_share); + cli_posix_unlink(cli_unix, symlnk_outside_share); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* + Test Creating files and directories directly + under a symlink. + */ +bool run_posix_symlink_parent_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + uint16_t fnum = (uint16_t)-1; + NTSTATUS status; + const char *parent_dir = "target_dir"; + const char *parent_symlink = "symlink_to_target_dir"; + const char *fname_real = "target_dir/file"; + const char *dname_real = "target_dir/dir"; + const char *fname_link = "symlink_to_target_dir/file"; + const char *dname_link = "symlink_to_target_dir/dir"; + const char *sname_link = "symlink_to_target_dir/symlink"; + const char *hname_link = "symlink_to_target_dir/hardlink"; + bool correct = false; + + frame = talloc_stackframe(); + + printf("Starting POSIX-SYMLINK-PARENT test\n"); + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + torture_conn_set_sockopt(cli_unix); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + /* Start with a clean slate. */ + cli_posix_unlink(cli_unix, fname_real); + cli_posix_rmdir(cli_unix, dname_real); + cli_posix_unlink(cli_unix, fname_link); + cli_posix_rmdir(cli_unix, dname_link); + cli_posix_unlink(cli_unix, sname_link); + cli_posix_unlink(cli_unix, hname_link); + cli_posix_unlink(cli_unix, parent_symlink); + cli_posix_rmdir(cli_unix, parent_dir); + + /* Create parent_dir. */ + status = cli_posix_mkdir(cli_unix, parent_dir, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s failed error %s\n", + parent_dir, + nt_errstr(status)); + goto out; + } + /* Create symlink to parent_dir. */ + status = cli_posix_symlink(cli_unix, + parent_dir, + parent_symlink); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + parent_symlink, + parent_dir, + nt_errstr(status)); + goto out; + } + /* Try and create a directory under the symlink. */ + status = cli_posix_mkdir(cli_unix, dname_link, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s failed error %s\n", + dname_link, + nt_errstr(status)); + goto out; + } + /* Try and create a file under the symlink. */ + status = cli_posix_open(cli_unix, + fname_link, + O_RDWR|O_CREAT, + 0666, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + fname_link, + nt_errstr(status)); + goto out; + } + status = cli_close(cli_unix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + /* Try and create a symlink to the file under the symlink. */ + status = cli_posix_symlink(cli_unix, + fname_link, + sname_link); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + sname_link, + fname_link, + nt_errstr(status)); + goto out; + } + + /* Try and create a hardlink to the file under the symlink. */ + status = cli_posix_hardlink(cli_unix, + fname_link, + hname_link); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_hardlink of %s -> %s failed error %s\n", + hname_link, + fname_link, + nt_errstr(status)); + goto out; + } + + /* Ensure we can delete the symlink via the parent symlink */ + status = cli_posix_unlink(cli_unix, sname_link); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_unlink of %s failed error %s\n", + sname_link, + nt_errstr(status)); + goto out; + } + + /* Ensure we can delete the hardlink via the parent symlink */ + status = cli_posix_unlink(cli_unix, hname_link); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_unlink of %s failed error %s\n", + hname_link, + nt_errstr(status)); + goto out; + } + + /* Ensure we can delete the directory via the parent symlink */ + status = cli_posix_rmdir(cli_unix, dname_link); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_rmdir of %s failed error %s\n", + dname_link, + nt_errstr(status)); + goto out; + } + /* Ensure we can delete the file via the parent symlink */ + status = cli_posix_unlink(cli_unix, fname_link); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_unlink of %s failed error %s\n", + fname_link, + nt_errstr(status)); + goto out; + } + + printf("POSIX-SYMLINK-PARENT test passed\n"); + correct = true; + +out: + if (fnum != (uint16_t)-1) { + cli_close(cli_unix, fnum); + } + cli_posix_unlink(cli_unix, fname_real); + cli_posix_rmdir(cli_unix, dname_real); + cli_posix_unlink(cli_unix, fname_link); + cli_posix_rmdir(cli_unix, dname_link); + cli_posix_unlink(cli_unix, sname_link); + cli_posix_unlink(cli_unix, hname_link); + cli_posix_unlink(cli_unix, parent_symlink); + cli_posix_rmdir(cli_unix, parent_dir); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* + Ensure we get an error when doing chmod on a symlink, + whether it is pointing to a real object or dangling. + */ +bool run_posix_symlink_chmod_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + NTSTATUS status; + uint16_t fnum = (uint16_t)-1; + const char *fname_real = "file_real"; + const char *fname_real_symlink = "file_real_symlink"; + const char *nonexist = "nonexist"; + const char *nonexist_symlink = "dangling_symlink"; + bool correct = false; + + frame = talloc_stackframe(); + + printf("Starting POSIX-SYMLINK-CHMOD test\n"); + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + torture_conn_set_sockopt(cli_unix); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + /* Start with a clean slate. */ + cli_posix_unlink(cli_unix, fname_real); + cli_posix_unlink(cli_unix, fname_real_symlink); + cli_posix_unlink(cli_unix, nonexist); + cli_posix_unlink(cli_unix, nonexist_symlink); + + /* Create a real file. */ + status = cli_posix_open(cli_unix, + fname_real, + O_RDWR|O_CREAT, + 0644, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + fname_real, + nt_errstr(status)); + goto out; + } + status = cli_close(cli_unix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + /* Create symlink to real target. */ + status = cli_posix_symlink(cli_unix, + fname_real, + fname_real_symlink); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + fname_real_symlink, + fname_real, + nt_errstr(status)); + goto out; + } + + /* We should not be able to chmod symlinks that point to something. */ + status = cli_posix_chmod(cli_unix, fname_real_symlink, 0777); + + /* This should fail with something other than server crashed. */ + if (NT_STATUS_IS_OK(status)) { + printf("cli_posix_chmod of %s succeeded (should have failed)\n", + fname_real_symlink); + goto out; + } + if (NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_DISCONNECTED)) { + /* Oops. Server crashed. */ + printf("cli_posix_chmod of %s failed error %s\n", + fname_real_symlink, + nt_errstr(status)); + goto out; + } + /* Any other failure is ok. */ + + /* Now create symlink to non-existing target. */ + status = cli_posix_symlink(cli_unix, + nonexist, + nonexist_symlink); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + nonexist_symlink, + nonexist, + nt_errstr(status)); + goto out; + } + + /* We should not be able to chmod symlinks that point to nothing. */ + status = cli_posix_chmod(cli_unix, nonexist_symlink, 0777); + + /* This should fail with something other than server crashed. */ + if (NT_STATUS_IS_OK(status)) { + printf("cli_posix_chmod of %s succeeded (should have failed)\n", + nonexist_symlink); + goto out; + } + if (NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_DISCONNECTED)) { + /* Oops. Server crashed. */ + printf("cli_posix_chmod of %s failed error %s\n", + nonexist_symlink, + nt_errstr(status)); + goto out; + } + + /* Any other failure is ok. */ + printf("POSIX-SYMLINK-CHMOD test passed (expected failure was %s)\n", + nt_errstr(status)); + correct = true; + +out: + if (fnum != (uint16_t)-1) { + cli_close(cli_unix, fnum); + } + cli_posix_unlink(cli_unix, fname_real); + cli_posix_unlink(cli_unix, fname_real_symlink); + cli_posix_unlink(cli_unix, nonexist); + cli_posix_unlink(cli_unix, nonexist_symlink); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* + Ensure we get an ACL containing OI|IO ACE entries + after we add a default POSIX ACL to a directory. + This will only ever be an SMB1 test as it depends + on POSIX ACL semantics. + */ +bool run_posix_dir_default_acl_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + NTSTATUS status; + uint16_t fnum = (uint16_t)-1; + const char *dname = "dir_with_default_acl"; + bool correct = false; + SMB_STRUCT_STAT sbuf; + size_t acl_size = 0; + char *aclbuf = NULL; + size_t num_file_acls = 0; + size_t num_dir_acls = 0; + size_t expected_buflen; + uint8_t def_acl[SMB_POSIX_ACL_HEADER_SIZE + + 5*SMB_POSIX_ACL_ENTRY_SIZE] = {0}; + uint8_t *p = NULL; + uint32_t i = 0; + struct security_descriptor *sd = NULL; + bool got_inherit = false; + + frame = talloc_stackframe(); + + printf("Starting POSIX-DIR-DEFAULT-ACL test\n"); + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + torture_conn_set_sockopt(cli_unix); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + /* Start with a clean slate. */ + cli_posix_unlink(cli_unix, dname); + cli_posix_rmdir(cli_unix, dname); + + status = cli_posix_mkdir(cli_unix, dname, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s failed error %s\n", + dname, + nt_errstr(status)); + goto out; + } + + /* Do a posix stat to get the owner. */ + status = cli_posix_stat(cli_unix, dname, &sbuf); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_stat of %s failed %s\n", + dname, + nt_errstr(status)); + goto out; + } + + /* Get the ACL on the directory. */ + status = cli_posix_getacl(cli_unix, dname, frame, &acl_size, &aclbuf); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_getacl on %s failed %s\n", + dname, + nt_errstr(status)); + goto out; + } + + if (acl_size < 6 || SVAL(aclbuf,0) != SMB_POSIX_ACL_VERSION) { + printf("%s, unknown POSIX acl version %u.\n", + dname, + (unsigned int)CVAL(aclbuf,0) ); + goto out; + } + + num_file_acls = SVAL(aclbuf,2); + num_dir_acls = SVAL(aclbuf,4); + + /* + * No overflow check, num_*_acls comes from a 16-bit value, + * and we expect expected_buflen (size_t) to be of at least 32 + * bit. + */ + expected_buflen = SMB_POSIX_ACL_HEADER_SIZE + + SMB_POSIX_ACL_ENTRY_SIZE*(num_file_acls+num_dir_acls); + + if (acl_size != expected_buflen) { + printf("%s, incorrect POSIX acl buffer size " + "(should be %zu, was %zu).\n", + dname, + expected_buflen, + acl_size); + goto out; + } + + if (num_dir_acls != 0) { + printf("%s, POSIX default acl already exists" + "(should be 0, was %zu).\n", + dname, + num_dir_acls); + goto out; + } + + /* + * Get the Windows ACL on the directory. + * Make sure there are no inheritable entries. + */ + status = cli_ntcreate(cli_unix, + dname, + 0, + SEC_STD_READ_CONTROL, + 0, + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, + FILE_DIRECTORY_FILE, + 0x0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Failed to open directory %s: %s\n", + dname, + nt_errstr(status)); + goto out; + } + + status = cli_query_security_descriptor(cli_unix, + fnum, + SECINFO_DACL, + frame, + &sd); + if (!NT_STATUS_IS_OK(status)) { + printf("Failed to get security descriptor on directory %s: %s\n", + dname, + nt_errstr(status)); + goto out; + } + + for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) { + struct security_ace *ace = &sd->dacl->aces[i]; + if (ace->flags & (SEC_ACE_FLAG_OBJECT_INHERIT| + SEC_ACE_FLAG_CONTAINER_INHERIT)) { + printf("security descriptor on directory %s already " + "contains inheritance flags\n", + dname); + sec_desc_print(NULL, stdout, sd, true); + goto out; + } + } + + TALLOC_FREE(sd); + + /* Construct a new default ACL. */ + SSVAL(def_acl,0,SMB_POSIX_ACL_VERSION); + SSVAL(def_acl,2,SMB_POSIX_IGNORE_ACE_ENTRIES); + SSVAL(def_acl,4,5); /* num_dir_acls. */ + + p = def_acl + SMB_POSIX_ACL_HEADER_SIZE; + + /* USER_OBJ. */ + SCVAL(p,0,SMB_POSIX_ACL_USER_OBJ); /* tagtype. */ + SCVAL(p,1,SMB_POSIX_ACL_READ|SMB_POSIX_ACL_WRITE|SMB_POSIX_ACL_EXECUTE); + p += SMB_POSIX_ACL_ENTRY_SIZE; + + /* GROUP_OBJ. */ + SCVAL(p,0,SMB_POSIX_ACL_GROUP_OBJ); /* tagtype. */ + SCVAL(p,1,SMB_POSIX_ACL_READ|SMB_POSIX_ACL_WRITE|SMB_POSIX_ACL_EXECUTE); + p += SMB_POSIX_ACL_ENTRY_SIZE; + + /* OTHER. */ + SCVAL(p,0,SMB_POSIX_ACL_OTHER); /* tagtype. */ + SCVAL(p,1,SMB_POSIX_ACL_READ|SMB_POSIX_ACL_WRITE|SMB_POSIX_ACL_EXECUTE); + p += SMB_POSIX_ACL_ENTRY_SIZE; + + /* Explicit user. */ + SCVAL(p,0,SMB_POSIX_ACL_USER); /* tagtype. */ + SCVAL(p,1,SMB_POSIX_ACL_READ|SMB_POSIX_ACL_WRITE|SMB_POSIX_ACL_EXECUTE); + SIVAL(p,2,sbuf.st_ex_uid); + p += SMB_POSIX_ACL_ENTRY_SIZE; + + /* MASK. */ + SCVAL(p,0,SMB_POSIX_ACL_MASK); /* tagtype. */ + SCVAL(p,1,SMB_POSIX_ACL_READ|SMB_POSIX_ACL_WRITE|SMB_POSIX_ACL_EXECUTE); + p += SMB_POSIX_ACL_ENTRY_SIZE; + + /* Set the POSIX default ACL. */ + status = cli_posix_setacl(cli_unix, dname, def_acl, sizeof(def_acl)); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_setacl on %s failed %s\n", + dname, + nt_errstr(status)); + goto out; + } + + /* + * Get the Windows ACL on the directory again. + * Now there should be inheritable entries. + */ + + status = cli_query_security_descriptor(cli_unix, + fnum, + SECINFO_DACL, + frame, + &sd); + if (!NT_STATUS_IS_OK(status)) { + printf("Failed (2) to get security descriptor " + "on directory %s: %s\n", + dname, + nt_errstr(status)); + goto out; + } + + for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) { + struct security_ace *ace = &sd->dacl->aces[i]; + if (ace->flags & (SEC_ACE_FLAG_OBJECT_INHERIT| + SEC_ACE_FLAG_CONTAINER_INHERIT)) { + got_inherit = true; + break; + } + } + + if (!got_inherit) { + printf("security descriptor on directory %s does not " + "contain inheritance flags\n", + dname); + sec_desc_print(NULL, stdout, sd, true); + goto out; + } + + cli_close(cli_unix, fnum); + fnum = (uint16_t)-1; + printf("POSIX-DIR-DEFAULT-ACL test passed\n"); + correct = true; + +out: + + TALLOC_FREE(sd); + + if (fnum != (uint16_t)-1) { + cli_close(cli_unix, fnum); + } + cli_posix_unlink(cli_unix, dname); + cli_posix_rmdir(cli_unix, dname); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* + Ensure we can rename a symlink whether it is + pointing to a real object or dangling. + */ +bool run_posix_symlink_rename_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + NTSTATUS status; + uint16_t fnum = (uint16_t)-1; + const char *fname_real = "file_real"; + const char *fname_real_symlink = "file_real_symlink"; + const char *fname_real_symlink_newname = "rename_file_real_symlink"; + const char *nonexist = "nonexist"; + const char *nonexist_symlink = "dangling_symlink"; + const char *nonexist_symlink_newname = "dangling_symlink_rename"; + bool correct = false; + + frame = talloc_stackframe(); + + printf("Starting POSIX-SYMLINK-RENAME test\n"); + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + torture_conn_set_sockopt(cli_unix); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + /* Start with a clean slate. */ + cli_posix_unlink(cli_unix, fname_real); + cli_posix_unlink(cli_unix, fname_real_symlink); + cli_posix_unlink(cli_unix, fname_real_symlink_newname); + cli_posix_unlink(cli_unix, nonexist); + cli_posix_unlink(cli_unix, nonexist_symlink); + cli_posix_unlink(cli_unix, nonexist_symlink_newname); + + /* Create a real file. */ + status = cli_posix_open(cli_unix, + fname_real, + O_RDWR|O_CREAT, + 0644, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + fname_real, + nt_errstr(status)); + goto out; + } + status = cli_close(cli_unix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + /* Create symlink to real target. */ + status = cli_posix_symlink(cli_unix, + fname_real, + fname_real_symlink); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + fname_real_symlink, + fname_real, + nt_errstr(status)); + goto out; + } + + /* Ensure we can rename the symlink to the real file. */ + status = cli_rename(cli_unix, + fname_real_symlink, + fname_real_symlink_newname, + false); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_rename of %s -> %s failed %s\n", + fname_real_symlink, + fname_real_symlink_newname, + nt_errstr(status)); + goto out; + } + + /* Now create symlink to non-existing target. */ + status = cli_posix_symlink(cli_unix, + nonexist, + nonexist_symlink); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + nonexist_symlink, + nonexist, + nt_errstr(status)); + goto out; + } + + /* Ensure we can rename the dangling symlink. */ + status = cli_rename(cli_unix, + nonexist_symlink, + nonexist_symlink_newname, + false); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_rename of %s -> %s failed %s\n", + nonexist_symlink, + nonexist_symlink_newname, + nt_errstr(status)); + goto out; + } + + printf("POSIX-SYMLINK-RENAME test passed\n"); + correct = true; + +out: + if (fnum != (uint16_t)-1) { + cli_close(cli_unix, fnum); + } + cli_posix_unlink(cli_unix, fname_real); + cli_posix_unlink(cli_unix, fname_real_symlink); + cli_posix_unlink(cli_unix, fname_real_symlink_newname); + cli_posix_unlink(cli_unix, nonexist); + cli_posix_unlink(cli_unix, nonexist_symlink); + cli_posix_unlink(cli_unix, nonexist_symlink_newname); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* List of info levels to try with a POSIX symlink path. */ + +static struct { + uint32_t level; + const char *name; +} posix_smb1_qpath_array[] = { + { SMB_INFO_STANDARD, "SMB_INFO_STANDARD"}, + { SMB_INFO_QUERY_EA_SIZE, "SMB_INFO_QUERY_EA_SIZE"}, + { SMB_INFO_IS_NAME_VALID, "SMB_INFO_IS_NAME_VALID"}, + { SMB_INFO_QUERY_EAS_FROM_LIST, "SMB_INFO_QUERY_EAS_FROM_LIST"}, + { SMB_INFO_QUERY_ALL_EAS, "SMB_INFO_QUERY_ALL_EAS"}, + { SMB_FILE_BASIC_INFORMATION, "SMB_FILE_BASIC_INFORMATION"}, + { SMB_FILE_STANDARD_INFORMATION, "SMB_FILE_STANDARD_INFORMATION"}, + { SMB_FILE_EA_INFORMATION, "SMB_FILE_EA_INFORMATION"}, + { SMB_FILE_ALTERNATE_NAME_INFORMATION,"SMB_FILE_ALTERNATE_NAME_INFORMATION"}, + { SMB_QUERY_FILE_NAME_INFO, "SMB_QUERY_FILE_NAME_INFO"}, + { SMB_FILE_NORMALIZED_NAME_INFORMATION,"SMB_FILE_NORMALIZED_NAME_INFORMATION"}, + { SMB_FILE_ALLOCATION_INFORMATION, "SMB_FILE_ALLOCATION_INFORMATION"}, + { SMB_FILE_END_OF_FILE_INFORMATION, "SMB_FILE_END_OF_FILE_INFORMATION"}, + { SMB_FILE_ALL_INFORMATION, "SMB_FILE_ALL_INFORMATION"}, + { SMB_FILE_INTERNAL_INFORMATION, "SMB_FILE_INTERNAL_INFORMATION"}, + { SMB_FILE_ACCESS_INFORMATION, "SMB_FILE_ACCESS_INFORMATION"}, + { SMB_FILE_NAME_INFORMATION, "SMB_FILE_NAME_INFORMATION"}, + { SMB_FILE_DISPOSITION_INFORMATION, "SMB_FILE_DISPOSITION_INFORMATION"}, + { SMB_FILE_POSITION_INFORMATION, "SMB_FILE_POSITION_INFORMATION"}, + { SMB_FILE_MODE_INFORMATION, "SMB_FILE_MODE_INFORMATION"}, + { SMB_FILE_ALIGNMENT_INFORMATION, "SMB_FILE_ALIGNMENT_INFORMATION"}, + { SMB_FILE_STREAM_INFORMATION, "SMB_FILE_STREAM_INFORMATION"}, + { SMB_FILE_COMPRESSION_INFORMATION, "SMB_FILE_COMPRESSION_INFORMATION"}, + { SMB_FILE_NETWORK_OPEN_INFORMATION, "SMB_FILE_NETWORK_OPEN_INFORMATION"}, + { SMB_FILE_ATTRIBUTE_TAG_INFORMATION, "SMB_FILE_ATTRIBUTE_TAG_INFORMATION"}, + { SMB_QUERY_FILE_UNIX_BASIC, "SMB_QUERY_FILE_UNIX_BASIC"}, + { SMB_QUERY_FILE_UNIX_INFO2, "SMB_QUERY_FILE_UNIX_INFO2"}, + { SMB_QUERY_FILE_UNIX_LINK, "SMB_QUERY_FILE_UNIX_LINK"}, + { SMB_QUERY_POSIX_ACL, "SMB_QUERY_POSIX_ACL"}, + { SMB_QUERY_POSIX_LOCK, "SMB_QUERY_POSIX_LOCK"}, +}; + +static NTSTATUS do_qpath(TALLOC_CTX *ctx, + struct cli_state *cli_unix, + const char *fname, + size_t i) +{ + NTSTATUS status; + + if (posix_smb1_qpath_array[i].level == + SMB_INFO_QUERY_EAS_FROM_LIST) { + uint16_t setup; + uint8_t *param; + uint8_t data[8]; + uint8_t *rparam = NULL; + uint8_t *rdata = NULL; + uint32_t rbytes = 0; + + /* Set up an EA list with 'a' as the single name. */ + SIVAL(data,0, 8); + SCVAL(data,4, 2); /* namelen. */ + SCVAL(data,5, 'a'); + SCVAL(data,6, '\0'); /* name. */ + SCVAL(data,7, '\0'); /* padding. */ + + SSVAL(&setup, 0, TRANSACT2_QPATHINFO); + + param = talloc_zero_array(ctx, uint8_t, 6); + if (param == NULL) { + return NT_STATUS_NO_MEMORY; + } + SSVAL(param, 0, SMB_INFO_QUERY_EAS_FROM_LIST); + param = trans2_bytes_push_str(param, + smbXcli_conn_use_unicode(cli_unix->conn), + fname, + strlen(fname)+1, + NULL); + if (param == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = cli_trans(ctx, + cli_unix, + SMBtrans2, + NULL, + -1, + 0, + 0, + &setup, 1, 0, + param, talloc_get_size(param), talloc_get_size(param), + data, 8, 0, + NULL, + NULL, 0, NULL, + &rparam, 0, &rbytes, + &rdata, 0, &rbytes); + TALLOC_FREE(rparam); + TALLOC_FREE(rdata); + } else { + uint8_t *rdata = NULL; + uint32_t num_rdata = 0; + + status = cli_qpathinfo(ctx, + cli_unix, + fname, + posix_smb1_qpath_array[i].level, + 0, /* min_rdata */ + 65534, /* max_rdata */ + &rdata, + &num_rdata); + TALLOC_FREE(rdata); + } + /* + * We don't care what came back, so long as the + * server didn't crash. + */ + if (NT_STATUS_EQUAL(status, + NT_STATUS_CONNECTION_DISCONNECTED)) { + printf("cli_qpathinfo of %s failed error " + "NT_STATUS_CONNECTION_DISCONNECTED\n", + fname); + return status; + } + + printf("cli_qpathinfo info %x (%s) of %s got %s " + "(this is not an error)\n", + (unsigned int)posix_smb1_qpath_array[i].level, + posix_smb1_qpath_array[i].name, + fname, + nt_errstr(status)); + + return NT_STATUS_OK; +} + +/* + Ensure we can call SMB1 getpathinfo in a symlink, + pointing to a real object or dangling. We mostly + expect errors, but the server must not crash. + */ +bool run_posix_symlink_getpathinfo_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + NTSTATUS status; + uint16_t fnum = (uint16_t)-1; + const char *fname_real = "file_getpath_real"; + const char *fname_real_symlink = "file_real_getpath_symlink"; + const char *nonexist = "nonexist_getpath"; + const char *nonexist_symlink = "dangling_getpath_symlink"; + bool correct = false; + size_t i; + + frame = talloc_stackframe(); + + printf("Starting POSIX-SYMLINK-GETPATHINFO test\n"); + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + torture_conn_set_sockopt(cli_unix); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + /* Start with a clean slate. */ + cli_posix_unlink(cli_unix, fname_real); + cli_posix_unlink(cli_unix, fname_real_symlink); + cli_posix_unlink(cli_unix, nonexist); + cli_posix_unlink(cli_unix, nonexist_symlink); + + /* Create a real file. */ + status = cli_posix_open(cli_unix, + fname_real, + O_RDWR|O_CREAT, + 0644, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + fname_real, + nt_errstr(status)); + goto out; + } + status = cli_close(cli_unix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + /* Create symlink to real target. */ + status = cli_posix_symlink(cli_unix, + fname_real, + fname_real_symlink); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + fname_real_symlink, + fname_real, + nt_errstr(status)); + goto out; + } + + /* Now create symlink to non-existing target. */ + status = cli_posix_symlink(cli_unix, + nonexist, + nonexist_symlink); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + nonexist_symlink, + nonexist, + nt_errstr(status)); + goto out; + } + + for (i = 0; i < ARRAY_SIZE(posix_smb1_qpath_array); i++) { + status = do_qpath(frame, + cli_unix, + fname_real_symlink, + i); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + status = do_qpath(frame, + cli_unix, + nonexist_symlink, + i); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + } + + printf("POSIX-SYMLINK-GETPATHINFO test passed\n"); + correct = true; + +out: + if (fnum != (uint16_t)-1) { + cli_close(cli_unix, fnum); + } + cli_posix_unlink(cli_unix, fname_real); + cli_posix_unlink(cli_unix, fname_real_symlink); + cli_posix_unlink(cli_unix, nonexist); + cli_posix_unlink(cli_unix, nonexist_symlink); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* List of info levels to try with a POSIX symlink path. */ + +static struct { + uint32_t level; + const char *name; + uint32_t data_len; +} posix_smb1_setpath_array[] = { + { SMB_SET_FILE_UNIX_BASIC, "SMB_SET_FILE_UNIX_BASIC", 100}, + { SMB_SET_FILE_UNIX_INFO2, "SMB_SET_FILE_UNIX_INFO2", 116}, + { SMB_SET_FILE_UNIX_LINK, "SMB_SET_FILE_UNIX_LINK", 8}, + { SMB_SET_FILE_UNIX_HLINK, "SMB_SET_FILE_UNIX_HLINK", 8}, + { SMB_SET_POSIX_ACL, "SMB_SET_POSIX_ACL", 6}, + { SMB_SET_POSIX_LOCK, "SMB_SET_POSIX_LOCK", 24}, + { SMB_INFO_STANDARD, "SMB_INFO_STANDARD", 12}, + { SMB_INFO_SET_EA, "SMB_INFO_SET_EA", 10}, + { SMB_FILE_BASIC_INFORMATION, "SMB_FILE_BASIC_INFORMATION", 36}, + { SMB_SET_FILE_ALLOCATION_INFO, "SMB_SET_FILE_ALLOCATION_INFO", 8}, + { SMB_SET_FILE_END_OF_FILE_INFO,"SMB_SET_FILE_END_OF_FILE_INFO",8}, + { SMB_SET_FILE_DISPOSITION_INFO,"SMB_SET_FILE_DISPOSITION_INFO",1}, + { SMB_FILE_POSITION_INFORMATION,"SMB_FILE_POSITION_INFORMATION",8}, + { SMB_FILE_FULL_EA_INFORMATION, "SMB_FILE_FULL_EA_INFORMATION",10}, + { SMB_FILE_MODE_INFORMATION, "SMB_FILE_MODE_INFORMATION", 4}, + { SMB_FILE_SHORT_NAME_INFORMATION,"SMB_FILE_SHORT_NAME_INFORMATION",12}, + { SMB_FILE_RENAME_INFORMATION,"SMB_FILE_RENAME_INFORMATION", 20}, + { SMB_FILE_LINK_INFORMATION, "SMB_FILE_LINK_INFORMATION", 20}, +}; + +static NTSTATUS do_setpath(TALLOC_CTX *ctx, + struct cli_state *cli_unix, + const char *fname, + size_t i) +{ + NTSTATUS status; + uint8_t *data = NULL; + + data = talloc_zero_array(ctx, + uint8_t, + posix_smb1_setpath_array[i].data_len); + if (data == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = cli_setpathinfo(cli_unix, + posix_smb1_setpath_array[i].level, + fname, + data, + posix_smb1_setpath_array[i].data_len); + TALLOC_FREE(data); + + /* + * We don't care what came back, so long as the + * server didn't crash. + */ + if (NT_STATUS_EQUAL(status, + NT_STATUS_CONNECTION_DISCONNECTED)) { + printf("cli_setpathinfo info %x (%s) of %s failed" + "error NT_STATUS_CONNECTION_DISCONNECTED\n", + (unsigned int)posix_smb1_setpath_array[i].level, + posix_smb1_setpath_array[i].name, + fname); + return status; + } + + printf("cli_setpathinfo info %x (%s) of %s got %s " + "(this is not an error)\n", + (unsigned int)posix_smb1_setpath_array[i].level, + posix_smb1_setpath_array[i].name, + fname, + nt_errstr(status)); + + return NT_STATUS_OK; +} + +/* + Ensure we can call SMB1 setpathinfo in a symlink, + pointing to a real object or dangling. We mostly + expect errors, but the server must not crash. + */ +bool run_posix_symlink_setpathinfo_test(int dummy) +{ + TALLOC_CTX *frame = NULL; + struct cli_state *cli_unix = NULL; + NTSTATUS status; + uint16_t fnum = (uint16_t)-1; + const char *fname_real = "file_setpath_real"; + const char *fname_real_symlink = "file_real_setpath_symlink"; + const char *nonexist = "nonexist_setpath"; + const char *nonexist_symlink = "dangling_setpath_symlink"; + bool correct = false; + size_t i; + + frame = talloc_stackframe(); + + printf("Starting POSIX-SYMLINK-SETPATHINFO test\n"); + + if (!torture_open_connection(&cli_unix, 0)) { + TALLOC_FREE(frame); + return false; + } + + torture_conn_set_sockopt(cli_unix); + + status = torture_setup_unix_extensions(cli_unix); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + /* Start with a clean slate. */ + cli_posix_unlink(cli_unix, fname_real); + cli_posix_unlink(cli_unix, fname_real_symlink); + cli_posix_unlink(cli_unix, nonexist); + cli_posix_unlink(cli_unix, nonexist_symlink); + + /* Create a real file. */ + status = cli_posix_open(cli_unix, + fname_real, + O_RDWR|O_CREAT, + 0644, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + fname_real, + nt_errstr(status)); + goto out; + } + status = cli_close(cli_unix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + /* Create symlink to real target. */ + status = cli_posix_symlink(cli_unix, + fname_real, + fname_real_symlink); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + fname_real_symlink, + fname_real, + nt_errstr(status)); + goto out; + } + + /* Now create symlink to non-existing target. */ + status = cli_posix_symlink(cli_unix, + nonexist, + nonexist_symlink); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed error %s\n", + nonexist_symlink, + nonexist, + nt_errstr(status)); + goto out; + } + + for (i = 0; i < ARRAY_SIZE(posix_smb1_setpath_array); i++) { + status = do_setpath(frame, + cli_unix, + fname_real_symlink, + i); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + status = do_setpath(frame, + cli_unix, + nonexist_symlink, + i); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + } + + printf("POSIX-SYMLINK-SETPATHINFO test passed\n"); + correct = true; + +out: + if (fnum != (uint16_t)-1) { + cli_close(cli_unix, fnum); + } + cli_posix_unlink(cli_unix, fname_real); + cli_posix_unlink(cli_unix, fname_real_symlink); + cli_posix_unlink(cli_unix, nonexist); + cli_posix_unlink(cli_unix, nonexist_symlink); + + if (!torture_close_connection(cli_unix)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} diff --git a/source3/torture/test_posix_append.c b/source3/torture/test_posix_append.c new file mode 100644 index 0000000..3abd448 --- /dev/null +++ b/source3/torture/test_posix_append.c @@ -0,0 +1,100 @@ +/* + Unix SMB/CIFS implementation. + reproducer for bug 6898 + Copyright (C) Volker Lendecke 2009 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "../libcli/security/security.h" +#include "libsmb/libsmb.h" +#include "libsmb/clirap.h" + +/* + * Make sure that GENERIC_WRITE does not trigger append. See + * https://bugzilla.samba.org/show_bug.cgi?id=6898 + */ + +bool run_posix_append(int dummy) +{ + struct cli_state *cli; + const char *fname = "append"; + NTSTATUS status; + uint16_t fnum; + off_t size; + uint8_t c = '\0'; + bool ret = false; + + printf("Starting POSIX_APPEND\n"); + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + status = torture_setup_unix_extensions(cli); + if (!NT_STATUS_IS_OK(status)) { + printf("torture_setup_unix_extensions failed: %s\n", + nt_errstr(status)); + goto fail; + } + + status = cli_ntcreate( + cli, fname, 0, + GENERIC_WRITE_ACCESS|GENERIC_READ_ACCESS|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL|FILE_FLAG_POSIX_SEMANTICS, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, + FILE_NON_DIRECTORY_FILE|FILE_DELETE_ON_CLOSE, + 0, &fnum, NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ntcreate failed: %s\n", nt_errstr(status)); + goto fail; + } + + /* + * Write two bytes at offset 0. With bug 6898 we would end up + * with a file of 2 byte length. + */ + + status = cli_writeall(cli, fnum, 0, &c, 0, sizeof(c), NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_write failed: %s\n", nt_errstr(status)); + goto fail; + } + status = cli_writeall(cli, fnum, 0, &c, 0, sizeof(c), NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_write failed: %s\n", nt_errstr(status)); + goto fail; + } + + status = cli_qfileinfo_basic( + cli, fnum, NULL, &size, NULL, NULL, NULL, NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_qfileinfo_basic failed: %s\n", nt_errstr(status)); + goto fail; + } + + if (size != sizeof(c)) { + printf("BUG: Writing with O_APPEND!!\n"); + goto fail; + } + + ret = true; +fail: + torture_close_connection(cli); + return ret; +} diff --git a/source3/torture/test_pthreadpool_tevent.c b/source3/torture/test_pthreadpool_tevent.c new file mode 100644 index 0000000..c90a394 --- /dev/null +++ b/source3/torture/test_pthreadpool_tevent.c @@ -0,0 +1,82 @@ +/* + * Unix SMB/CIFS implementation. + * Test pthreadpool_tevent + * Copyright (C) Volker Lendecke 2016 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "system/select.h" +#include "proto.h" +#include "lib/pthreadpool/pthreadpool_tevent.h" + +static void job_fn(void *private_data); + +bool run_pthreadpool_tevent(int dummy) +{ + struct tevent_context *ev; + struct pthreadpool_tevent *pool; + struct tevent_req *req; + int ret, val; + bool ok; + + ev = tevent_context_init_byname(NULL, "poll"); + if (ev == NULL) { + fprintf(stderr, "tevent_context_init failed\n"); + return false; + } + + ret = pthreadpool_tevent_init(ev, 100, &pool); + if (ret != 0) { + fprintf(stderr, "pthreadpool_tevent_init failed: %s\n", + strerror(ret)); + return false; + } + + val = -1; + + req = pthreadpool_tevent_job_send(ev, ev, pool, job_fn, &val); + if (req == NULL) { + fprintf(stderr, "pthreadpool_tevent_job_send failed\n"); + return false; + } + + ok = tevent_req_poll(req, ev); + if (!ok) { + fprintf(stderr, "tevent_req_poll failed\n"); + return false; + } + + ret = pthreadpool_tevent_job_recv(req); + if (ret != 0) { + fprintf(stderr, "pthreadpool_tevent_job failed: %s\n", + strerror(ret)); + return false; + } + + printf("%d\n", val); + + TALLOC_FREE(pool); + TALLOC_FREE(ev); + return true; +} + +static void job_fn(void *private_data) +{ + int *pret = private_data; + *pret = 4711; + + poll(NULL, 0, 100); +} diff --git a/source3/torture/test_readdir_timestamp.c b/source3/torture/test_readdir_timestamp.c new file mode 100644 index 0000000..0eba415 --- /dev/null +++ b/source3/torture/test_readdir_timestamp.c @@ -0,0 +1,533 @@ +/* + * Unix SMB/CIFS implementation. + * Copyright (C) Volker Lendecke 2020 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "includes.h" +#include "torture/proto.h" +#include "libsmb/libsmb.h" +#include "libsmb/clirap.h" +#include "lib/util/tevent_ntstatus.h" +#include "lib/util/smb_strtox.h" + +extern int torture_nprocs; +extern int torture_numops; + +struct create_ts_state { + struct tevent_context *ev; + struct cli_state *cli; + unsigned timestamp_idx; + uint16_t fnum; +}; + +static void create_ts_opened(struct tevent_req *subreq); +static void create_ts_setinfo_done(struct tevent_req *subreq); +static void create_ts_waited(struct tevent_req *subreq); +static void create_ts_written(struct tevent_req *subreq); +static void create_ts_doc_done(struct tevent_req *subreq); + +static struct tevent_req *create_ts_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *fname, + unsigned timestamp_idx) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct create_ts_state *state = NULL; + + req = tevent_req_create(mem_ctx, &state, struct create_ts_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + state->timestamp_idx = timestamp_idx; + + subreq = cli_ntcreate_send( + state, + ev, + cli, + fname, + 0, /* CreatFlags */ + SEC_FILE_WRITE_ATTRIBUTE| + SEC_FILE_WRITE_DATA| + SEC_STD_DELETE, /* DesiredAccess */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_WRITE|FILE_SHARE_READ, /* ShareAccess */ + FILE_OPEN_IF, /* CreateDisposition */ + FILE_NON_DIRECTORY_FILE, /* CreateOptions */ + 0, /* Impersonation */ + 0); /* SecurityFlags */ + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, create_ts_opened, req); + return req; +} + +static void create_ts_opened(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct create_ts_state *state = tevent_req_data( + req, struct create_ts_state); + struct smb_create_returns cr; + struct timespec mtime; + NTSTATUS status; + + status = cli_ntcreate_recv(subreq, &state->fnum, &cr); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + + mtime = nt_time_to_unix_timespec(cr.last_write_time); + + mtime.tv_sec &= ~(0xFFFFULL); + mtime.tv_sec |= (state->timestamp_idx & 0xFFFF); + + subreq = cli_setfileinfo_ext_send( + state, + state->ev, + state->cli, + state->fnum, + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* create */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* access */ + mtime, + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* change */ + UINT32_MAX); /* attr */ + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, create_ts_setinfo_done, req); +} + +static void create_ts_setinfo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct create_ts_state *state = tevent_req_data( + req, struct create_ts_state); + NTSTATUS status; + + status = cli_setfileinfo_ext_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + + subreq = tevent_wakeup_send( + state, state->ev, timeval_current_ofs_msec(100)); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, create_ts_waited, req); +} + +static void create_ts_waited(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct create_ts_state *state = tevent_req_data( + req, struct create_ts_state); + bool ok; + + ok = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (!ok) { + tevent_req_oom(subreq); + return; + } + + subreq = cli_write_send( + state, + state->ev, + state->cli, + state->fnum, + 0, + (uint8_t *)&state->fnum, + 0, + sizeof(state->fnum)); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, create_ts_written, req); +} + +static void create_ts_written(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct create_ts_state *state = tevent_req_data( + req, struct create_ts_state); + size_t written; + NTSTATUS status; + + status = cli_write_recv(subreq, &written); + TALLOC_FREE(subreq); + if (tevent_req_nterror(subreq, status)) { + return; + } + + subreq = cli_nt_delete_on_close_send( + state, state->ev, state->cli, state->fnum, true); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, create_ts_doc_done, req); +} + +static void create_ts_doc_done(struct tevent_req *subreq) +{ + NTSTATUS status = cli_nt_delete_on_close_recv(subreq); + tevent_req_simple_finish_ntstatus(subreq, status); +} + +static NTSTATUS create_ts_recv(struct tevent_req *req, uint16_t *fnum) +{ + struct create_ts_state *state = tevent_req_data( + req, struct create_ts_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + return status; + } + *fnum = state->fnum; + tevent_req_received(req); + return NT_STATUS_OK; +} + +struct create_ts_files_state { + size_t num_files; + size_t num_received; + uint16_t *fnums; +}; + +static void create_ts_files_done(struct tevent_req *subreq); + +static struct tevent_req *create_ts_files_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *prefix, + size_t idx, + size_t num_files) +{ + struct tevent_req *req = NULL; + struct create_ts_files_state *state = NULL; + size_t i; + + req = tevent_req_create(mem_ctx, &state, struct create_ts_files_state); + if (req == NULL) { + return NULL; + } + state->num_files = num_files; + + state->fnums = talloc_array(state, uint16_t, num_files); + if (tevent_req_nomem(state->fnums, req)) { + return tevent_req_post(req, ev); + } + + for (i=0; ifnums[state->num_received]); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + + state->num_received += 1; + if (state->num_received == state->num_files) { + tevent_req_done(req); + } +} + +static NTSTATUS create_ts_files_recv( + struct tevent_req *req, TALLOC_CTX *mem_ctx, uint16_t **fnums) +{ + struct create_ts_files_state *state = tevent_req_data( + req, struct create_ts_files_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + return status; + } + *fnums = talloc_move(mem_ctx, &state->fnums); + tevent_req_received(req); + return NT_STATUS_OK; +} + +struct create_files_state { + size_t num_reqs; + size_t num_received; + struct tevent_req **reqs; + uint16_t **fnums; +}; + +static void create_files_done(struct tevent_req *subreq); + +static struct tevent_req *create_files_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state **cli, + size_t num_cli, + const char *prefix, + size_t num_files) +{ + struct tevent_req *req = NULL; + struct create_files_state *state = NULL; + size_t i; + + req = tevent_req_create(mem_ctx, &state, struct create_files_state); + if (req == NULL) { + return NULL; + } + state->num_reqs = num_cli; + + state->reqs = talloc_array(state, struct tevent_req *, num_cli); + if (tevent_req_nomem(state->reqs, req)) { + return tevent_req_post(req, ev); + } + state->fnums = talloc_array(state, uint16_t *, num_cli); + if (tevent_req_nomem(state->fnums, req)) { + return tevent_req_post(req, ev); + } + + for (i=0; ireqs[i] = create_ts_files_send( + state, ev, cli[i], prefix, i, num_files); + if (tevent_req_nomem(state->reqs[i], req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback( + state->reqs[i], create_files_done, req); + } + return req; +} + +static void create_files_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct create_files_state *state = tevent_req_data( + req, struct create_files_state); + uint16_t *fnums = NULL; + NTSTATUS status; + size_t i; + + status = create_ts_files_recv(subreq, state->fnums, &fnums); + if (tevent_req_nterror(req, status)) { + return; + } + + for (i=0; inum_reqs; i++) { + if (state->reqs[i] == subreq) { + break; + } + } + if (i == state->num_reqs) { + tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR); + return; + } + + TALLOC_FREE(subreq); + state->reqs[i] = NULL; + state->fnums[i] = fnums; + + state->num_received += 1; + + if (state->num_reqs == state->num_received) { + tevent_req_done(req); + } +} + +static NTSTATUS create_files_recv( + struct tevent_req *req, TALLOC_CTX *mem_ctx, uint16_t ***fnums) +{ + struct create_files_state *state = tevent_req_data( + req, struct create_files_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + return status; + } + + *fnums = talloc_move(mem_ctx, &state->fnums); + tevent_req_received(req); + return NT_STATUS_OK; +} + +struct list_cb_state { + size_t found; + bool ok; +}; + +static NTSTATUS list_cb( + struct file_info *f, + const char *mask, + void *private_data) +{ + struct list_cb_state *state = private_data; + char *underbar = NULL; + unsigned long long int name_idx; + int err; + + underbar = strchr(f->name, '_'); + if (underbar == NULL) { + /* alien filename, . or ..? */ + return NT_STATUS_OK; + } + + name_idx = smb_strtoull(underbar+1, NULL, 10, &err, SMB_STR_STANDARD); + if (err != 0) { + /* non-numeric? */ + return NT_STATUS_OK; + } + + if ((name_idx & 0xFFFF) != (f->mtime_ts.tv_sec & 0xFFFF)) { + d_printf("idx=%llu, nsec=%ld\n", + name_idx, + f->mtime_ts.tv_nsec); + state->ok = false; + } + state->found += 1; + + return NT_STATUS_OK; +} + +bool run_readdir_timestamp(int dummy) +{ + struct cli_state **cli = NULL; + int i; + bool ret = false; + bool ok; + const char prefix[] = "readdir_ts/"; + struct list_cb_state state = { .ok = true }; + struct tevent_context *ev = NULL; + struct tevent_req *req = NULL; + uint16_t **fnums = NULL; + NTSTATUS status; + size_t expected; + + cli = talloc_array(talloc_tos(), struct cli_state *, torture_nprocs); + if (cli == NULL) { + d_printf("talloc_array failed\n"); + goto fail; + } + + for (i=0; i. + */ + +#include "source3/include/includes.h" +#include "source3/torture/proto.h" +#include "source3/libsmb/libsmb.h" +#include "librpc/gen_ndr/ndr_spoolss_c.h" +#include "lib/util/tevent_ntstatus.h" +#include "source3/rpc_client/rpc_client.h" +#include "source3/rpc_client/cli_pipe.h" +#include "libcli/smb/smbXcli_base.h" + +extern int torture_nprocs; +extern int torture_numops; + +struct rpc_scale_one_state { + struct tevent_context *ev; + struct cli_state *cli; + size_t num_iterations; + struct rpc_pipe_client *rpccli; + DATA_BLOB buffer; + uint32_t needed; + uint32_t num_printers; + union spoolss_PrinterInfo *printers; +}; + +static void rpc_scale_one_opened(struct tevent_req *subreq); +static void rpc_scale_one_bound(struct tevent_req *subreq); +static void rpc_scale_one_listed(struct tevent_req *subreq); + +static struct tevent_req *rpc_scale_one_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + size_t num_iterations) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct rpc_scale_one_state *state = NULL; + + req = tevent_req_create(mem_ctx, &state, struct rpc_scale_one_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + state->num_iterations = num_iterations; + + subreq = rpc_pipe_open_np_send( + state, ev, cli, &ndr_table_spoolss); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpc_scale_one_opened, req); + return req; +} + +static void rpc_scale_one_opened(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_scale_one_state *state = tevent_req_data( + req, struct rpc_scale_one_state); + struct pipe_auth_data *auth = NULL; + NTSTATUS status; + + status = rpc_pipe_open_np_recv(subreq, state, &state->rpccli); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + + status = rpccli_anon_bind_data(state, &auth); + if (tevent_req_nterror(req, status)) { + return; + } + + subreq = rpc_pipe_bind_send(state, state->ev, state->rpccli, auth); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, rpc_scale_one_bound, req); +} + +static void rpc_scale_one_bound(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_scale_one_state *state = tevent_req_data( + req, struct rpc_scale_one_state); + char *server = NULL; + NTSTATUS status; + + status = rpc_pipe_bind_recv(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + + server = talloc_asprintf( + state, + "\\%s\n", + smbXcli_conn_remote_name(state->cli->conn)); + if (tevent_req_nomem(server, req)) { + return; + } + state->buffer = data_blob_talloc(state, NULL, 4096); + if (tevent_req_nomem(state->buffer.data, req)) { + return; + } + + subreq = dcerpc_spoolss_EnumPrinters_send( + state, + state->ev, + state->rpccli->binding_handle, + PRINTER_ENUM_LOCAL, + server, + 1, /* level */ + &state->buffer, + state->buffer.length, + &state->num_printers, + &state->printers, + &state->needed); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, rpc_scale_one_listed, req); +} + +static void rpc_scale_one_listed(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_scale_one_state *state = tevent_req_data( + req, struct rpc_scale_one_state); + NTSTATUS status; + WERROR result; + + status = dcerpc_spoolss_EnumPrinters_recv(subreq, state, &result); + if (tevent_req_nterror(req, status)) { + return; + } + + if (!W_ERROR_IS_OK(result)) { + status = werror_to_ntstatus(result); + tevent_req_nterror(req, status); + return; + } + + /* + * This will trigger a sync close. Making that async will be a + * lot of effort, and even with this being sync this test is + * nasty enough. + */ + TALLOC_FREE(state->rpccli); + + state->num_iterations -= 1; + + if (state->num_iterations == 0) { + tevent_req_done(req); + return; + } + + subreq = rpc_pipe_open_np_send( + state, state->ev, state->cli, &ndr_table_spoolss); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, rpc_scale_one_opened, req); +} + +static NTSTATUS rpc_scale_one_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +struct rpc_scale_state { + size_t num_reqs; + size_t done; +}; + +static void rpc_scale_done(struct tevent_req *subreq); + +static struct tevent_req *rpc_scale_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state **clis) +{ + struct tevent_req *req = NULL; + struct rpc_scale_state *state = NULL; + size_t i, num_clis = talloc_array_length(clis); + + req = tevent_req_create(mem_ctx, &state, struct rpc_scale_state); + if (req == NULL) { + return NULL; + } + state->num_reqs = num_clis; + + for (i=0; idone += 1; + + if (state->done == state->num_reqs) { + tevent_req_done(req); + } +} + +static NTSTATUS rpc_scale_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +bool run_rpc_scale(int dummy) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct cli_state **clis = NULL; + struct tevent_req *req = NULL; + struct tevent_context *ev = NULL; + bool ok, result = false; + NTSTATUS status; + int i; + + clis = talloc_zero_array( + talloc_tos(), struct cli_state *, torture_nprocs); + if (clis == NULL) { + fprintf(stderr, "talloc failed\n"); + goto fail; + } + + for (i=0; i. +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "client.h" +#include "trans2.h" +#include "../libcli/smb/smbXcli_base.h" +#include "libcli/security/security.h" +#include "libsmb/proto.h" +#include "auth/credentials/credentials.h" +#include "auth/gensec/gensec.h" +#include "auth_generic.h" +#include "../librpc/ndr/libndr.h" +#include "libsmb/clirap.h" +#include "async_smb.h" +#include "../lib/util/tevent_ntstatus.h" +#include "lib/util/time_basic.h" + +extern fstring host, workgroup, share, password, username, myname; +extern struct cli_credentials *torture_creds; + +/* + * Open an SMB1 file readonly and return the create time. + */ +static NTSTATUS get_smb1_crtime(struct cli_state *cli, + const char *pathname, + struct timespec *pcrtime) +{ + NTSTATUS status; + uint16_t fnum = 0; + struct timespec crtime = {0}; + + /* + * Open the file. + */ + + status = smb1cli_ntcreatex(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + pathname, + OPLOCK_NONE, /* CreatFlags */ + 0, /* RootDirectoryFid */ + SEC_STD_SYNCHRONIZE| + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* DesiredAccess */ + 0, /* AllocationSize */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* ShareAccess */ + FILE_OPEN, /* CreateDisposition */ + 0, /* CreateOptions */ + 2, /* ImpersonationLevel */ + 0, /* SecurityFlags */ + &fnum); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + /* + * Get the create time. Note - we can use + * a higher-level cli_XXX function here + * for SMB1 as cli_qfileinfo_basic() + * doesn't use any pathnames, only fnums + * so it isn't affected by DFS pathnames. + */ + status = cli_qfileinfo_basic(cli, + fnum, + NULL, /* attr */ + NULL, /* size */ + &crtime, /* create_time */ + NULL, /* access_time */ + NULL, /* write_time */ + NULL, /* change_time */ + NULL); + if (NT_STATUS_IS_OK(status)) { + *pcrtime = crtime; + } + + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + return status; +} + +/* + * Check a crtime matches a given SMB1 path. + */ +static bool smb1_crtime_matches(struct cli_state *cli, + const char *match_pathname, + struct timespec crtime_tomatch, + const char *test_pathname) +{ + struct timespec test_crtime = { 0 }; + NTSTATUS status; + bool equal = false; + + status = get_smb1_crtime(cli, + test_pathname, + &test_crtime); + if (!NT_STATUS_IS_OK(status)) { + printf("%s: Failed to get crtime " + "for %s, (%s)\n", + __func__, + test_pathname, + nt_errstr(status)); + return false; + } + equal = (timespec_compare(&test_crtime, &crtime_tomatch) == 0); + if (!equal) { + struct timeval_buf test_buf; + struct timeval_buf tomatch_buf; + printf("%s: crtime mismatch " + "%s:crtime_tomatch=%s, %s:test_crtime = %s\n", + __func__, + match_pathname, + timespec_string_buf(&crtime_tomatch, + true, + &tomatch_buf), + test_pathname, + timespec_string_buf(&test_crtime, + true, + &test_buf)); + return false; + } + return true; +} + +/* + * Delete an SMB1 file on a DFS share. + */ +static NTSTATUS smb1_dfs_delete(struct cli_state *cli, + const char *pathname) +{ + NTSTATUS status; + uint16_t fnum = 0; + + /* + * Open the file. + */ + + status = smb1cli_ntcreatex(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + pathname, + OPLOCK_NONE, /* CreatFlags */ + 0, /* RootDirectoryFid */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE, /* DesiredAccess */ + 0, /* AllocationSize */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* ShareAccess */ + FILE_OPEN, /* CreateDisposition */ + 0, /* CreateOptions */ + 2, /* ImpersonationLevel */ + 0, /* SecurityFlags */ + &fnum); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + /* + * Set delete on close. Note - we can use + * a higher-level cli_XXX function here + * for SMB1 as cli_nt_delete_on_close() + * doesn't use any pathnames, only fnums + * so it isn't affected by DFS pathnames. + */ + /* + */ + status = cli_nt_delete_on_close(cli, fnum, 1); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + return smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ +} + +static void smb1_mv_done(struct tevent_req *subreq); + +struct smb1_mv_state { + uint16_t vwv[1]; +}; + +static struct tevent_req *smb1_mv_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *src_dfs_name, + const char *target_name) +{ + uint8_t *bytes = NULL; + struct tevent_req *req = NULL; + struct tevent_req *subreq = NULL; + struct smb1_mv_state *state = NULL; + + req = tevent_req_create(mem_ctx, + &state, + struct smb1_mv_state); + if (req == NULL) { + return NULL; + } + + PUSH_LE_U16(state->vwv, + 0, + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_DIRECTORY); + + bytes = talloc_array(state, uint8_t, 1); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + src_dfs_name, + strlen(src_dfs_name)+1, + NULL); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + + bytes = talloc_realloc(state, + bytes, + uint8_t, + talloc_get_size(bytes)+1); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + + bytes[talloc_get_size(bytes)-1] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + target_name, + strlen(target_name)+1, + NULL); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + + subreq = cli_smb_send(state, + ev, + cli, + SMBmv, + 0, /* additional_flags */ + 0, /* additional_flags2 */ + 1, + state->vwv, + talloc_get_size(bytes), + bytes); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, smb1_mv_done, req); + return req; +} + +static void smb1_mv_done(struct tevent_req *subreq) +{ + NTSTATUS status = cli_smb_recv(subreq, + NULL, + NULL, + 0, + NULL, + NULL, + NULL, + NULL); + tevent_req_simple_finish_ntstatus(subreq, + status); +} + +static NTSTATUS smb1_mv_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +/* + * Rename an SMB1 file on a DFS share. SMBmv version. + */ +static NTSTATUS smb1_mv(struct cli_state *cli, + const char *src_dfs_name, + const char *target_name) +{ + TALLOC_CTX *frame = NULL; + struct tevent_context *ev; + struct tevent_req *req; + NTSTATUS status; + + frame = talloc_stackframe(); + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + status = NT_STATUS_NO_MEMORY; + goto fail; + } + + req = smb1_mv_send(frame, + ev, + cli, + src_dfs_name, + target_name); + if (req == NULL) { + status = NT_STATUS_NO_MEMORY; + goto fail; + } + + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + goto fail; + } + + status = smb1_mv_recv(req); + + fail: + + TALLOC_FREE(frame); + return status; +} + +static bool test_smb1_mv(struct cli_state *cli, + const char *src_dfs_name) +{ + struct timespec test_timespec = { 0 }; + NTSTATUS status; + + status = smb1_mv(cli, + src_dfs_name, + "BAD\\BAD\\renamed_file"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMBmv of %s -> %s should succeed " + "got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "BAD\\BAD\\renamed_file", + nt_errstr(status)); + return false; + } + + /* Ensure we did rename. */ + status = get_smb1_crtime(cli, + "BAD\\BAD\\renamed_file", + &test_timespec); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get crtime " + "for %s, (%s)\n", + __FILE__, + __LINE__, + "BAD\\BAD\\renamed_file", + nt_errstr(status)); + return false; + } + + /* Put it back. */ + status = smb1_mv(cli, + "BAD\\BAD\\renamed_file", + src_dfs_name); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMBmv of %s -> %s should succeed " + "got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\renamed_file", + src_dfs_name, + nt_errstr(status)); + return false; + } + + /* Ensure we did put it back. */ + status = get_smb1_crtime(cli, + src_dfs_name, + &test_timespec); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get crtime " + "for %s, (%s)\n", + __FILE__, + __LINE__, + src_dfs_name, + nt_errstr(status)); + return false; + } + + /* Try with a non-DFS name. */ + status = smb1_mv(cli, + src_dfs_name, + "renamed_file"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) { + /* Fails I think as target becomes "" on server. */ + printf("%s:%d SMBmv of %s -> %s should get " + "NT_STATUS_OBJECT_PATH_SYNTAX_BAD got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "renamed_file", + nt_errstr(status)); + return false; + } + + /* Try with a non-DFS name. */ + status = smb1_mv(cli, + src_dfs_name, + "BAD\\renamed_file"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) { + /* Fails I think as target becomes "" on server. */ + printf("%s:%d SMBmv of %s -> %s should get " + "NT_STATUS_OBJECT_PATH_SYNTAX_BAD got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "BAD\\renamed_file", + nt_errstr(status)); + return false; + } + return true; +} + +static void smb1_setpathinfo_done(struct tevent_req *subreq); + +struct smb1_setpathinfo_state { + uint16_t setup; + uint8_t *param; + uint8_t *data; +}; + +static struct tevent_req *smb1_setpathinfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *src_dfs_name, + const char *target_name, + uint16_t info_level) +{ + struct tevent_req *req = NULL; + struct tevent_req *subreq = NULL; + struct smb1_setpathinfo_state *state = NULL; + smb_ucs2_t *converted_str = NULL; + size_t converted_size_bytes = 0; + bool ok = false; + + req = tevent_req_create(mem_ctx, + &state, + struct smb1_setpathinfo_state); + if (req == NULL) { + return NULL; + } + + PUSH_LE_U16(&state->setup, 0, TRANSACT2_SETPATHINFO); + + state->param = talloc_zero_array(state, uint8_t, 6); + if (tevent_req_nomem(state->param, req)) { + return tevent_req_post(req, ev); + } + PUSH_LE_U16(state->param, 0, info_level); + + state->param = trans2_bytes_push_str(state->param, + smbXcli_conn_use_unicode(cli->conn), + src_dfs_name, + strlen(src_dfs_name)+1, + NULL); + if (tevent_req_nomem(state->param, req)) { + return tevent_req_post(req, ev); + } + + ok = push_ucs2_talloc(state, + &converted_str, + target_name, + &converted_size_bytes); + if (!ok) { + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + return tevent_req_post(req, ev); + } + + /* + * W2K8 insists the dest name is not null + * terminated. Remove the last 2 zero bytes + * and reduce the name length. + */ + + if (converted_size_bytes < 2) { + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + return tevent_req_post(req, ev); + } + converted_size_bytes -= 2; + + state->data = talloc_zero_array(state, + uint8_t, + 12 + converted_size_bytes); + if (tevent_req_nomem(state->data, req)) { + return tevent_req_post(req, ev); + } + + SIVAL(state->data, 8, converted_size_bytes); + memcpy(state->data + 12, converted_str, converted_size_bytes); + + subreq = cli_trans_send(state, /* mem ctx. */ + ev,/* event ctx. */ + cli,/* cli_state. */ + 0,/* additional_flags2 */ + SMBtrans2, /* cmd. */ + NULL,/* pipe name. */ + -1,/* fid. */ + 0,/* function. */ + 0,/* flags. */ + &state->setup,/* setup. */ + 1,/* num setup uint16_t words. */ + 0,/* max returned setup. */ + state->param,/* param. */ + talloc_get_size(state->param),/* num param. */ + 2,/* max returned param. */ + state->data,/* data. */ + talloc_get_size(state->data),/* num data. */ + 0);/* max returned data. */ + + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, smb1_setpathinfo_done, req); + return req; +} + +static void smb1_setpathinfo_done(struct tevent_req *subreq) +{ + NTSTATUS status = cli_trans_recv(subreq, + NULL, + NULL, + NULL, + 0, + NULL, + NULL, + 0, + NULL, + NULL, + 0, + NULL); + tevent_req_simple_finish_ntstatus(subreq, + status); +} + +static NTSTATUS smb1_setpathinfo_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +/* + * Rename or hardlink an SMB1 file on a DFS share. SMB1 setpathinfo + * (pathnames only) version. + */ +static NTSTATUS smb1_setpathinfo(struct cli_state *cli, + const char *src_dfs_name, + const char *target_name, + uint16_t info_level) +{ + TALLOC_CTX *frame = NULL; + struct tevent_context *ev; + struct tevent_req *req; + NTSTATUS status; + + frame = talloc_stackframe(); + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + status = NT_STATUS_NO_MEMORY; + goto fail; + } + + req = smb1_setpathinfo_send(frame, + ev, + cli, + src_dfs_name, + target_name, + info_level); + if (req == NULL) { + status = NT_STATUS_NO_MEMORY; + goto fail; + } + + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + goto fail; + } + + status = smb1_setpathinfo_recv(req); + + fail: + + TALLOC_FREE(frame); + return status; +} + +static NTSTATUS smb1_setpathinfo_rename(struct cli_state *cli, + const char *src_dfs_name, + const char *target_name) +{ + return smb1_setpathinfo(cli, + src_dfs_name, + target_name, + SMB_FILE_RENAME_INFORMATION); +} + +static bool test_smb1_setpathinfo_rename(struct cli_state *cli, + const char *src_dfs_name) +{ + struct timespec test_crtime = { 0 }; + NTSTATUS status; + const char *putback_path = NULL; + + /* + * On Windows, setpathinfo rename where the target contains + * any directory separator returns STATUS_NOT_SUPPORTED. + * + * MS-SMB behavior note: <133> Section 3.3.5.10.6: + * + * "If the file name pointed to by the FileName parameter of the + * FILE_RENAME_INFORMATION structure contains a separator character, + * then the request fails with STATUS_NOT_SUPPORTED." + */ + status = smb1_setpathinfo_rename(cli, + src_dfs_name, + "BAD\\BAD\\renamed_file"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) { + printf("%s:%d SMB1 setpathinfo rename of %s -> %s should get " + "NT_STATUS_NOT_SUPPORTED got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "BAD\\BAD\\renamed_file", + nt_errstr(status)); + return false; + } + + /* Try with a non-DFS name. */ + status = smb1_setpathinfo_rename(cli, + src_dfs_name, + "renamed_file"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1 setpathinfo rename of %s -> %s " + "should succeed got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "renamed_file", + nt_errstr(status)); + return false; + } + + /* Ensure we did rename. */ + status = get_smb1_crtime(cli, + "BAD\\BAD\\renamed_file", + &test_crtime); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get crtime " + "for %s, (%s)\n", + __FILE__, + __LINE__, + "BAD\\BAD\\renamed_file", + nt_errstr(status)); + return false; + } + + /* + * To put it back we need to reverse the DFS-ness of src + * and destination paths. + */ + putback_path = strrchr(src_dfs_name, '\\'); + if (putback_path == NULL) { + printf("%s:%d non DFS path %s passed. Internal error\n", + __FILE__, + __LINE__, + src_dfs_name); + return false; + } + /* Walk past the last '\\' */ + putback_path++; + + /* Put it back. */ + status = smb1_setpathinfo_rename(cli, + "BAD\\BAD\\renamed_file", + putback_path); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1 setpathinfo rename of %s -> %s " + "should succeed got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\renamed_file", + putback_path, + nt_errstr(status)); + return false; + } + + /* Ensure we did rename. */ + status = get_smb1_crtime(cli, + src_dfs_name, + &test_crtime); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get crtime " + "for %s, (%s)\n", + __FILE__, + __LINE__, + src_dfs_name, + nt_errstr(status)); + return false; + } + + return true; +} + +static NTSTATUS smb1_setpathinfo_hardlink(struct cli_state *cli, + const char *src_dfs_name, + const char *target_name) +{ + return smb1_setpathinfo(cli, + src_dfs_name, + target_name, + SMB_FILE_LINK_INFORMATION); +} + +static bool test_smb1_setpathinfo_hardlink(struct cli_state *cli, + const char *src_dfs_name) +{ + NTSTATUS status; + + /* + * On Windows, setpathinfo rename where the target contains + * any directory separator returns STATUS_NOT_SUPPORTED. + * + * MS-SMB behavior note: <133> Section 3.3.5.10.6: + * + * "If the file name pointed to by the FileName parameter of the + * FILE_RENAME_INFORMATION structure contains a separator character, + * then the request fails with STATUS_NOT_SUPPORTED." + * + * setpathinfo info level SMB_FILE_LINK_INFORMATION + * seems to do the same, but this could be an artifact + * of the Windows version tested (Win2K8). I will + * revisit this when I'm able to test against + * a later Windows version with a DFS server. + */ + status = smb1_setpathinfo_hardlink(cli, + src_dfs_name, + "BAD\\BAD\\hlink"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) { + printf("%s:%d SMB1 setpathinfo hardlink of %s -> %s should get " + "NT_STATUS_NOT_SUPPORTED got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "BAD\\BAD\\hlink", + nt_errstr(status)); + return false; + } + + /* Try with a non-DFS name. */ + /* + * At least on Windows 2008 this also fails with + * NT_STATUS_NOT_SUPPORTED, leading me to believe + * setting hardlinks is only supported via NTrename + * in SMB1. + */ + status = smb1_setpathinfo_hardlink(cli, + src_dfs_name, + "hlink"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) { + printf("%s:%d SMB1 setpathinfo hardlink of %s -> %s should get " + "NT_STATUS_NOT_SUPPORTED got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "hlink", + nt_errstr(status)); + return false; + } + return true; +} + +static void smb1_ntrename_done(struct tevent_req *subreq); + +struct smb1_ntrename_state { + uint16_t vwv[4]; +}; + +static struct tevent_req *smb1_ntrename_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *src_dfs_name, + const char *target_name, + uint16_t rename_flag) +{ + struct tevent_req *req = NULL; + struct tevent_req *subreq = NULL; + struct smb1_ntrename_state *state = NULL; + uint8_t *bytes = NULL; + + req = tevent_req_create(mem_ctx, + &state, + struct smb1_ntrename_state); + if (req == NULL) { + return NULL; + } + + PUSH_LE_U16(state->vwv, + 0, + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_DIRECTORY); + PUSH_LE_U16(state->vwv, 2, rename_flag); + + bytes = talloc_array(state, uint8_t, 1); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + src_dfs_name, + strlen(src_dfs_name)+1, + NULL); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + bytes = talloc_realloc(state, + bytes, + uint8_t, + talloc_get_size(bytes)+1); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + + bytes[talloc_get_size(bytes)-1] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + target_name, + strlen(target_name)+1, + NULL); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + + subreq = cli_smb_send(state, + ev, + cli, + SMBntrename, + 0, /* additional_flags */ + 0, /* additional_flags2 */ + 4, + state->vwv, + talloc_get_size(bytes), + bytes); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, smb1_ntrename_done, req); + return req; +} + +static void smb1_ntrename_done(struct tevent_req *subreq) +{ + NTSTATUS status = cli_smb_recv(subreq, + NULL, + NULL, + 0, + NULL, + NULL, + NULL, + NULL); + tevent_req_simple_finish_ntstatus(subreq, status); +} + +static NTSTATUS smb1_ntrename_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +/* + * Rename or hardlink an SMB1 file on a DFS share. SMB1 ntrename version. + * (pathnames only). + */ +static NTSTATUS smb1_ntrename(struct cli_state *cli, + const char *src_dfs_name, + const char *target_name, + uint16_t rename_flag) +{ + TALLOC_CTX *frame = NULL; + struct tevent_context *ev; + struct tevent_req *req; + NTSTATUS status; + + frame = talloc_stackframe(); + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + status = NT_STATUS_NO_MEMORY; + goto fail; + } + + req = smb1_ntrename_send(frame, + ev, + cli, + src_dfs_name, + target_name, + rename_flag); + if (req == NULL) { + status = NT_STATUS_NO_MEMORY; + goto fail; + } + + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + goto fail; + } + + status = smb1_ntrename_recv(req); + + fail: + + TALLOC_FREE(frame); + return status; +} +/* + * Rename an SMB1 file on a DFS share. SMB1 ntrename version. + */ +static NTSTATUS smb1_ntrename_rename(struct cli_state *cli, + const char *src_dfs_name, + const char *target_name) +{ + return smb1_ntrename(cli, + src_dfs_name, + target_name, + RENAME_FLAG_RENAME); +} + + +static bool test_smb1_ntrename_rename(struct cli_state *cli, + const char *src_dfs_name) +{ + struct timespec test_crtime = { 0 }; + NTSTATUS status; + + /* Try with a non-DFS name. */ + status = smb1_ntrename_rename(cli, + src_dfs_name, + "renamed_file"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) { + /* Fails I think as target becomes "" on server. */ + printf("%s:%d SMB1 ntrename rename of %s -> %s should get " + "NT_STATUS_OBJECT_PATH_SYNTAX_BAD got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "renamed_file", + nt_errstr(status)); + return false; + } + + status = smb1_ntrename_rename(cli, + src_dfs_name, + "BAD\\BAD\\renamed_file"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1 ntrename rename of %s -> %s should " + "succeed got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "BAD\\BAD\\renamed_file", + nt_errstr(status)); + return false; + } + + /* Ensure we did rename. */ + status = get_smb1_crtime(cli, + "BAD\\BAD\\renamed_file", + &test_crtime); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get crtime " + "for %s, (%s)\n", + __FILE__, + __LINE__, + "BAD\\BAD\\renamed_file", + nt_errstr(status)); + return false; + } + + /* Put it back. */ + status = smb1_ntrename_rename(cli, + "BAD\\BAD\\renamed_file", + src_dfs_name); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1 ntrename rename of %s -> %s " + "should succeed got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\renamed_file", + src_dfs_name, + nt_errstr(status)); + return false; + } + + /* Ensure we did rename. */ + status = get_smb1_crtime(cli, + src_dfs_name, + &test_crtime); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get crtime " + "for %s, (%s)\n", + __FILE__, + __LINE__, + src_dfs_name, + nt_errstr(status)); + return false; + } + + return true; +} + +/* + * Hard link an SMB1 file on a DFS share. SMB1 ntrename version. + */ +static NTSTATUS smb1_ntrename_hardlink(struct cli_state *cli, + const char *src_dfs_name, + const char *target_name) +{ + return smb1_ntrename(cli, + src_dfs_name, + target_name, + RENAME_FLAG_HARD_LINK); +} + +static bool test_smb1_ntrename_hardlink(struct cli_state *cli, + const char *src_dfs_name) +{ + struct timespec test_crtime = { 0 }; + NTSTATUS status; + bool retval = false; + + /* Try with a non-DFS name. */ + status = smb1_ntrename_hardlink(cli, + src_dfs_name, + "hlink"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) { + /* Fails I think as target becomes "" on server. */ + printf("%s:%d SMB1 ntrename of %s -> %s should get " + "NT_STATUS_OBJECT_PATH_SYNTAX_BAD got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "hlink", + nt_errstr(status)); + return false; + } + + status = smb1_ntrename_hardlink(cli, + src_dfs_name, + "BAD\\BAD\\hlink"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1 ntrename hardlink of %s -> %s " + "should succeed got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "BAD\\BAD\\hlink", + nt_errstr(status)); + goto out; + } + + /* Ensure we did hardlink. */ + status = get_smb1_crtime(cli, + "BAD\\BAD\\hlink", + &test_crtime); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get crtime " + "for %s, (%s)\n", + __FILE__, + __LINE__, + "BAD\\BAD\\hlink", + nt_errstr(status)); + goto out; + } + + retval = smb1_crtime_matches(cli, + "BAD\\BAD\\hlink", + test_crtime, + src_dfs_name); + if (!retval) { + printf("%s:%d smb1_crtime_matches failed for " + "%s %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "BAD\\BAD\\hlink"); + goto out; + } + + out: + + /* Remove the hardlink to clean up. */ + (void)smb1_dfs_delete(cli, "BAD\\BAD\\hlink"); + return retval; +} + +static void smb1_setfileinfo_done(struct tevent_req *subreq); + +struct smb1_setfileinfo_state { + uint16_t setup; + uint8_t param[6]; + uint8_t *data; +}; + +static struct tevent_req *smb1_setfileinfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + uint16_t fnum, + const char *target_name, + uint16_t info_level) +{ + struct tevent_req *req = NULL; + struct tevent_req *subreq = NULL; + struct smb1_setfileinfo_state *state = NULL; + smb_ucs2_t *converted_str = NULL; + size_t converted_size_bytes = 0; + bool ok = false; + + req = tevent_req_create(mem_ctx, + &state, + struct smb1_setfileinfo_state); + if (req == NULL) { + return NULL; + } + + PUSH_LE_U16(&state->setup, 0, TRANSACT2_SETPATHINFO); + + PUSH_LE_U16(state->param, 0, fnum); + PUSH_LE_U16(state->param, 2, info_level); + + ok = push_ucs2_talloc(state, + &converted_str, + target_name, + &converted_size_bytes); + if (!ok) { + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + return tevent_req_post(req, ev); + } + + /* + * W2K8 insists the dest name is not null + * terminated. Remove the last 2 zero bytes + * and reduce the name length. + */ + + if (converted_size_bytes < 2) { + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + return tevent_req_post(req, ev); + } + converted_size_bytes -= 2; + + state->data = talloc_zero_array(state, + uint8_t, + 12 + converted_size_bytes); + if (tevent_req_nomem(state->data, req)) { + return tevent_req_post(req, ev); + } + + SIVAL(state->data, 8, converted_size_bytes); + memcpy(state->data + 12, converted_str, converted_size_bytes); + + subreq = cli_trans_send(state, /* mem ctx. */ + ev,/* event ctx. */ + cli,/* cli_state. */ + 0,/* additional_flags2 */ + SMBtrans2, /* cmd. */ + NULL,/* pipe name. */ + -1,/* fid. */ + 0,/* function. */ + 0,/* flags. */ + &state->setup,/* setup. */ + 1,/* num setup uint16_t words. */ + 0,/* max returned setup. */ + state->param,/* param. */ + 6,/* num param. */ + 2,/* max returned param. */ + state->data,/* data. */ + talloc_get_size(state->data),/* num data. */ + 0);/* max returned data. */ + + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, smb1_setfileinfo_done, req); + return req; +} + +static void smb1_setfileinfo_done(struct tevent_req *subreq) +{ + NTSTATUS status = cli_trans_recv(subreq, + NULL, + NULL, + NULL, + 0, + NULL, + NULL, + 0, + NULL, + NULL, + 0, + NULL); + tevent_req_simple_finish_ntstatus(subreq, + status); +} + +static NTSTATUS smb1_setfileinfo_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +/* + * Rename or hardlink an SMB1 file on a DFS share. + * setfileinfo (file handle + target pathname) version. + */ +static NTSTATUS smb1_setfileinfo(struct cli_state *cli, + uint16_t fnum, + const char *target_name, + uint16_t info_level) +{ + TALLOC_CTX *frame = NULL; + struct tevent_context *ev; + struct tevent_req *req; + NTSTATUS status; + + frame = talloc_stackframe(); + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + status = NT_STATUS_NO_MEMORY; + goto fail; + } + + req = smb1_setfileinfo_send(frame, + ev, + cli, + fnum, + target_name, + info_level); + if (req == NULL) { + status = NT_STATUS_NO_MEMORY; + goto fail; + } + + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + goto fail; + } + + status = smb1_setfileinfo_recv(req); + + fail: + + TALLOC_FREE(frame); + return status; +} + +static NTSTATUS smb1_setfileinfo_rename(struct cli_state *cli, + uint16_t fnum, + const char *target_name) +{ + return smb1_setfileinfo(cli, + fnum, + target_name, + SMB_FILE_RENAME_INFORMATION); +} + +/* + * On Windows, rename using a file handle as source + * is not supported. + */ + +static bool test_smb1_setfileinfo_rename(struct cli_state *cli, + const char *src_dfs_name) +{ + uint16_t fnum = (uint16_t)-1; + NTSTATUS status; + bool retval = false; + + /* First open the source file. */ + status = smb1cli_ntcreatex(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + src_dfs_name, + OPLOCK_NONE, /* CreatFlags */ + 0, /* RootDirectoryFid */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE, /* DesiredAccess */ + 0, /* AllocationSize */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* ShareAccess */ + FILE_OPEN, /* CreateDisposition */ + 0, /* CreateOptions */ + 2, /* ImpersonationLevel */ + 0, /* SecurityFlags */ + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d failed to open %s, %s\n", + __FILE__, + __LINE__, + src_dfs_name, + nt_errstr(status)); + goto out; + } + + /* + * On Windows rename given a file handle returns + * NT_STATUS_UNSUCCESSFUL (not documented in MS-SMB). + */ + + status = smb1_setfileinfo_rename(cli, + fnum, + "BAD\\BAD\\renamed_file"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL)) { + printf("%s:%d SMB1 setfileinfo rename of %s -> %s should get " + "NT_STATUS_UNSUCCESSFUL got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "BAD\\BAD\\hlink", + nt_errstr(status)); + goto out; + } + + /* Try with a non-DFS name - still gets NT_STATUS_UNSUCCESSFUL. */ + status = smb1_setfileinfo_rename(cli, + fnum, + "renamed_file"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL)) { + printf("%s:%d SMB1 setfileinfo rename of %s -> %s should get " + "NT_STATUS_UNSUCCESSFUL got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "hlink", + nt_errstr(status)); + goto out; + } + + retval = true; + + out: + + if (fnum != (uint16_t)-1) { + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + } + + (void)smb1_dfs_delete(cli, "BAD\\BAD\\renamed_file"); + return retval; +} + + +static NTSTATUS smb1_setfileinfo_hardlink(struct cli_state *cli, + uint16_t fnum, + const char *target_name) +{ + return smb1_setfileinfo(cli, + fnum, + target_name, + SMB_FILE_LINK_INFORMATION); +} + +/* + * On Windows, hardlink using a file handle as source + * is not supported. + */ + +static bool test_smb1_setfileinfo_hardlink(struct cli_state *cli, + const char *src_dfs_name) +{ + uint16_t fnum = (uint16_t)-1; + NTSTATUS status; + bool retval = false; + + /* First open the source file. */ + status = smb1cli_ntcreatex(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + src_dfs_name, + OPLOCK_NONE, /* CreatFlags */ + 0, /* RootDirectoryFid */ + SEC_STD_SYNCHRONIZE| + SEC_RIGHTS_FILE_READ, /* DesiredAccess */ + 0, /* AllocationSize */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* ShareAccess */ + FILE_OPEN, /* CreateDisposition */ + 0, /* CreateOptions */ + 2, /* ImpersonationLevel */ + 0, /* SecurityFlags */ + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d failed to open %s, %s\n", + __FILE__, + __LINE__, + src_dfs_name, + nt_errstr(status)); + goto out; + } + + /* + * On Windows hardlink given a file handle returns + * NT_STATUS_UNSUCCESSFUL (not documented in MS-SMB). + */ + + status = smb1_setfileinfo_hardlink(cli, + fnum, + "BAD\\BAD\\hlink"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL)) { + printf("%s:%d SMB1 setfileinfo hardlink of %s -> %s should get " + "NT_STATUS_UNSUCCESSFUL got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "BAD\\BAD\\hlink", + nt_errstr(status)); + goto out; + } + + /* Try with a non-DFS name - still gets NT_STATUS_UNSUCCESSFUL. */ + status = smb1_setfileinfo_hardlink(cli, + fnum, + "hlink"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL)) { + printf("%s:%d SMB1 setfileinfo hardlink of %s -> %s should get " + "NT_STATUS_UNSUCCESSFUL got %s\n", + __FILE__, + __LINE__, + src_dfs_name, + "hlink", + nt_errstr(status)); + goto out; + } + + retval = true; + + out: + + if (fnum != (uint16_t)-1) { + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + } + + (void)smb1_dfs_delete(cli, "BAD\\BAD\\hlink"); + return retval; +} + +/* + * According to: + + * https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-fscc/dc9978d7-6299-4c5a-a22d-a039cdc716ea + * + * (Characters " \ / [ ] : | < > + = ; , * ?, + * and control characters in range 0x00 through + * 0x1F, inclusive, are illegal in a share name) + * + * But Windows server only checks in DFS sharenames ':'. All other + * share names are allowed. + */ + +static bool test_smb1_dfs_sharenames(struct cli_state *cli, + const char *dfs_root_share_name, + struct timespec root_crtime) +{ + char test_path[20]; + const char *test_str = "/[]:|<>+=;,*?"; + const char *p; + unsigned int i; + bool crtime_matched = false; + + /* Setup template pathname. */ + memcpy(test_path, "\\SERVER\\X", 10); + + /* Test invalid control characters. */ + for (i = 1; i < 0x20; i++) { + test_path[8] = i; + crtime_matched = smb1_crtime_matches(cli, + dfs_root_share_name, + root_crtime, + test_path); + if (!crtime_matched) { + return false; + } + } + + /* Test explicit invalid characters. */ + for (p = test_str; *p != '\0'; p++) { + test_path[8] = *p; + if (*p == ':') { + /* + * Only ':' is treated as an INVALID sharename + * for a DFS SERVER\\SHARE path. + */ + struct timespec test_crtime = { 0 }; + NTSTATUS status = get_smb1_crtime(cli, + test_path, + &test_crtime); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_INVALID)) { + printf("%s:%d Open of %s should get " + "NT_STATUS_OBJECT_NAME_INVALID, got %s\n", + __FILE__, + __LINE__, + test_path, + nt_errstr(status)); + return false; + } + } else { + crtime_matched = smb1_crtime_matches(cli, + dfs_root_share_name, + root_crtime, + test_path); + if (!crtime_matched) { + return false; + } + } + } + return true; +} + +/* + * "Raw" test of SMB1 paths to a DFS share. + * We must (mostly) use the lower level smb1cli_XXXX() interfaces, + * not the cli_XXX() ones here as the ultimate goal is to fix our + * cli_XXX() interfaces to work transparently over DFS. + * + * So here, we're testing the server code, not the client code. + * + * Passes cleanly against Windows. + */ + +bool run_smb1_dfs_paths(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + bool dfs_supported = false; + char *dfs_root_share_name = NULL; + struct timespec root_crtime = { 0 }; + struct timespec test_crtime = { 0 }; + bool crtime_matched = false; + bool retval = false; + bool ok = false; + bool equal = false; + unsigned int i; + uint16_t fnum = (uint16_t)-1; + + printf("Starting SMB1-DFS-PATHS\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + /* Ensure this is a DFS share. */ + dfs_supported = smbXcli_conn_dfs_supported(cli->conn); + if (!dfs_supported) { + printf("Server %s does not support DFS\n", + smbXcli_conn_remote_name(cli->conn)); + return false; + } + dfs_supported = smbXcli_tcon_is_dfs_share(cli->smb1.tcon); + if (!dfs_supported) { + printf("Share %s does not support DFS\n", + cli->share); + return false; + } + + /* Start with an empty share. */ + (void)smb1_dfs_delete(cli, "BAD\\BAD\\BAD"); + (void)smb1_dfs_delete(cli, "BAD\\BAD\\file"); + (void)smb1_dfs_delete(cli, "BAD\\BAD\\renamed_file"); + (void)smb1_dfs_delete(cli, "BAD\\BAD\\hlink"); + + /* + * Create the "official" DFS share root name. + */ + dfs_root_share_name = talloc_asprintf(talloc_tos(), + "\\%s\\%s", + smbXcli_conn_remote_name(cli->conn), + cli->share); + if (dfs_root_share_name == NULL) { + printf("Out of memory\n"); + return false; + } + + /* Get the share root crtime. */ + status = get_smb1_crtime(cli, + dfs_root_share_name, + &root_crtime); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get crtime for share root %s, (%s)\n", + __FILE__, + __LINE__, + dfs_root_share_name, + nt_errstr(status)); + return false; + } + + /* + * Test the Windows algorithm for parsing DFS names. + */ + /* + * A single "SERVER" element should open and match the share root. + */ + crtime_matched = smb1_crtime_matches(cli, + dfs_root_share_name, + root_crtime, + smbXcli_conn_remote_name(cli->conn)); + if (!crtime_matched) { + printf("%s:%d Failed to match crtime for %s\n", + __FILE__, + __LINE__, + smbXcli_conn_remote_name(cli->conn)); + return false; + } + + /* An "" (empty) server name should open and match the share root. */ + crtime_matched = smb1_crtime_matches(cli, + dfs_root_share_name, + root_crtime, + ""); + if (!crtime_matched) { + printf("%s:%d Failed to match crtime for %s\n", + __FILE__, + __LINE__, + ""); + return false; + } + + /* + * For SMB1 the server just strips off any number of leading '\\' + * characters. Show this is the case. + */ + for (i = 0; i < 10; i++) { + char leading_backslash_name[20]; + leading_backslash_name[i] = '\\'; + memcpy(&leading_backslash_name[i+1], + "SERVER", + strlen("SERVER")+1); + + crtime_matched = smb1_crtime_matches(cli, + dfs_root_share_name, + root_crtime, + leading_backslash_name); + if (!crtime_matched) { + printf("%s:%d Failed to match crtime for %s\n", + __FILE__, + __LINE__, + leading_backslash_name); + return false; + } + } + + /* A "BAD" server name should open and match the share root. */ + crtime_matched = smb1_crtime_matches(cli, + dfs_root_share_name, + root_crtime, + "BAD"); + if (!crtime_matched) { + printf("%s:%d Failed to match crtime for %s\n", + __FILE__, + __LINE__, + "BAD"); + return false; + } + /* + * A "BAD\\BAD" server and share name should open + * and match the share root. + */ + crtime_matched = smb1_crtime_matches(cli, + dfs_root_share_name, + root_crtime, + "BAD\\BAD"); + if (!crtime_matched) { + printf("%s:%d Failed to match crtime for %s\n", + __FILE__, + __LINE__, + "BAD\\BAD"); + return false; + } + /* + * Trying to open "BAD\\BAD\\BAD" should get + * NT_STATUS_OBJECT_NAME_NOT_FOUND. + */ + status = get_smb1_crtime(cli, + "BAD\\BAD\\BAD", + &test_crtime); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + printf("%s:%d Open of %s should get " + "STATUS_OBJECT_NAME_NOT_FOUND, got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\BAD", + nt_errstr(status)); + return false; + } + /* + * Trying to open "BAD\\BAD\\BAD\\BAD" should get + * NT_STATUS_OBJECT_PATH_NOT_FOUND. + */ + status = get_smb1_crtime(cli, + "BAD\\BAD\\BAD\\BAD", + &test_crtime); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("%s:%d Open of %s should get " + "STATUS_OBJECT_NAME_NOT_FOUND, got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\BAD\\BAD", + nt_errstr(status)); + return false; + } + /* + * Test for invalid pathname characters in the servername. + * They are ignored, and it still opens the share root. + */ + crtime_matched = smb1_crtime_matches(cli, + dfs_root_share_name, + root_crtime, + "::::"); + if (!crtime_matched) { + printf("%s:%d Failed to match crtime for %s\n", + __FILE__, + __LINE__, + "::::"); + return false; + } + + /* + * Test for invalid pathname characters in the sharename. + * Invalid sharename characters should still be flagged as + * NT_STATUS_OBJECT_NAME_INVALID. It turns out only ':' + * is considered an invalid sharename character. + */ + ok = test_smb1_dfs_sharenames(cli, + dfs_root_share_name, + root_crtime); + if (!ok) { + return false; + } + + status = smb1cli_ntcreatex(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + "BAD\\BAD\\file", + OPLOCK_NONE, /* CreatFlags */ + 0, /* RootDirectoryFid */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* DesiredAccess */ + 0, /* AllocationSize */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* ShareAccess */ + FILE_CREATE, /* CreateDisposition */ + 0, /* CreateOptions */ + 2, /* ImpersonationLevel */ + 0, /* SecurityFlags */ + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb1cli_ntcreatex on %s returned %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\file", + nt_errstr(status)); + return false; + } + + /* Close "file" handle. */ + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + fnum = (uint16_t)-1; + + /* + * Trying to open "BAD\\BAD\\file" should now get + * a valid crtime. + */ + status = get_smb1_crtime(cli, + "BAD\\BAD\\file", + &test_crtime); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Open of %s should succeed " + "got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\file", + nt_errstr(status)); + goto err; + } + + /* + * This crtime must be different from the root_crtime. + * This checks we're actually correctly reading crtimes + * from the filesystem. + */ + equal = (timespec_compare(&test_crtime, &root_crtime) == 0); + if (equal) { + printf("%s:%d Error. crtime of %s must differ from " + "root_crtime\n", + __FILE__, + __LINE__, + "BAD\\BAD\\file"); + goto err; + } + + /* + * Test different SMB1 renames + * and hard links. + */ + + /* SMBmv only does rename. */ + ok = test_smb1_mv(cli, + "BAD\\BAD\\file"); + if (!ok) { + goto err; + } + + ok = test_smb1_setpathinfo_rename(cli, + "BAD\\BAD\\file"); + if (!ok) { + goto err; + } + + ok = test_smb1_setpathinfo_hardlink(cli, + "BAD\\BAD\\file"); + if (!ok) { + goto err; + } + + ok = test_smb1_setfileinfo_rename(cli, + "BAD\\BAD\\file"); + if (!ok) { + goto err; + } + + ok = test_smb1_setfileinfo_hardlink(cli, + "BAD\\BAD\\file"); + if (!ok) { + goto err; + } + + ok = test_smb1_ntrename_rename(cli, + "BAD\\BAD\\file"); + if (!ok) { + goto err; + } + + ok = test_smb1_ntrename_hardlink(cli, + "BAD\\BAD\\file"); + if (!ok) { + goto err; + } + + retval = true; + + err: + + if (fnum != (uint16_t)-1) { + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + } + + /* Delete anything we made. */ + (void)smb1_dfs_delete(cli, "BAD\\BAD\\BAD"); + (void)smb1_dfs_delete(cli, "BAD\\BAD\\file"); + (void)smb1_dfs_delete(cli, "BAD\\BAD\\renamed_file"); + (void)smb1_dfs_delete(cli, "BAD\\BAD\\hlink"); + return retval; +} + +/* + * SMB1 Findfirst. This is a minimal implementation + * that expects all filename returns in one packet. + * We're only using this to test the search DFS pathname + * parsing. + */ + +/**************************************************************************** + Calculate a safe next_entry_offset. +****************************************************************************/ + +static size_t calc_next_entry_offset(const uint8_t *base, + const uint8_t *pdata_end) +{ + size_t next_entry_offset = (size_t)PULL_LE_U32(base,0); + + if (next_entry_offset == 0 || + base + next_entry_offset < base || + base + next_entry_offset > pdata_end) { + next_entry_offset = pdata_end - base; + } + return next_entry_offset; +} + +static size_t get_filename(TALLOC_CTX *ctx, + struct cli_state *cli, + const uint8_t *base_ptr, + uint16_t recv_flags2, + const uint8_t *p, + const uint8_t *pdata_end, + struct file_info *finfo) +{ + size_t ret = 0; + const uint8_t *base = p; + size_t namelen = 0; + size_t slen = 0; + + ZERO_STRUCTP(finfo); + + if (pdata_end - base < 94) { + return pdata_end - base; + } + p += 4; /* next entry offset */ + p += 4; /* fileindex */ + /* Offset zero is "create time", not "change time". */ + p += 8; + finfo->atime_ts = interpret_long_date(BVAL(p, 0)); + p += 8; + finfo->mtime_ts = interpret_long_date(BVAL(p, 0)); + p += 8; + finfo->ctime_ts = interpret_long_date(BVAL(p, 0)); + p += 8; + finfo->size = PULL_LE_U64(p, 0); + p += 8; + p += 8; /* alloc size */ + finfo->attr = PULL_LE_U32(p, 0); + p += 4; + namelen = PULL_LE_U32(p, 0); + p += 4; + p += 4; /* EA size */ + slen = PULL_LE_U8(p, 0); + if (slen > 24) { + /* Bad short name length. */ + return pdata_end - base; + } + p += 2; + ret = pull_string_talloc(ctx, + base_ptr, + recv_flags2, + &finfo->short_name, + p, + slen, + STR_UNICODE); + if (ret == (size_t)-1) { + return pdata_end - base; + } + p += 24; /* short name */ + if (p + namelen < p || p + namelen > pdata_end) { + return pdata_end - base; + } + ret = pull_string_talloc(ctx, + base_ptr, + recv_flags2, + &finfo->name, + p, + namelen, + 0); + if (ret == (size_t)-1) { + return pdata_end - base; + } + return calc_next_entry_offset(base, pdata_end); +} + +/* Single shot SMB1 TRANS2 FindFirst. */ + +static NTSTATUS smb1_findfirst(TALLOC_CTX *mem_ctx, + struct cli_state *cli, + const char *search_name, + struct file_info **names, + size_t *num_names) +{ + NTSTATUS status; + uint16_t setup[1]; + uint8_t *param = NULL; + uint16_t recv_flags2 = 0; + uint8_t *rparam = NULL; + uint32_t num_rparam = 0; + uint8_t *rdata = NULL; + uint32_t num_rdata = 0; + uint16_t num_names_returned = 0; + struct file_info *finfo = NULL; + uint8_t *p2 = NULL; + uint8_t *data_end = NULL; + uint16_t i = 0; + + PUSH_LE_U16(&setup[0], 0, TRANSACT2_FINDFIRST); + + param = talloc_array(mem_ctx, uint8_t, 12); + if (param == NULL) { + return NT_STATUS_NO_MEMORY; + } + + PUSH_LE_U16(param, 0, FILE_ATTRIBUTE_DIRECTORY | + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN); + PUSH_LE_U16(param, 2, 1366); /* max_matches */ + PUSH_LE_U16(param, 4, FLAG_TRANS2_FIND_CLOSE_IF_END); + PUSH_LE_U16(param, 6, SMB_FIND_FILE_BOTH_DIRECTORY_INFO); /* info_level */ + + param = trans2_bytes_push_str(param, + smbXcli_conn_use_unicode(cli->conn), + search_name, + strlen(search_name)+1, + NULL); + if (param == NULL) { + return NT_STATUS_NO_MEMORY; + } + + /* + * A one shot SMB1 findfirst will be enough to + * return ".", "..", and "file". + */ + status = cli_trans(mem_ctx, + cli, + SMBtrans2, /* cmd */ + NULL, /* pipe_name */ + 0, /* fid */ + 0, /* function */ + 0, /* flags */ + &setup[0], + 1, /* num_setup uint16_t words */ + 0, /* max returned setup */ + param, + talloc_get_size(param), /* num_param */ + 10, /* max returned param */ + NULL, /* data */ + 0, /* num_data */ + SMB_BUFFER_SIZE_MAX, /* max returned data */ + /* Return values from here on.. */ + &recv_flags2, /* recv_flags2 */ + NULL, /* rsetup */ + 0, /* min returned rsetup */ + NULL, /* num_rsetup */ + &rparam, + 6, /* min returned rparam */ + &num_rparam, /* number of returned rparam */ + &rdata, + 0, /* min returned rdata */ + &num_rdata); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + num_names_returned = PULL_LE_U16(rparam, 2); + + finfo = talloc_array(mem_ctx, struct file_info, num_names_returned); + if (param == NULL) { + return NT_STATUS_NO_MEMORY; + } + + p2 = rdata; + data_end = rdata + num_rdata; + + for (i = 0; i < num_names_returned; i++) { + if (p2 >= data_end) { + break; + } + if (i == num_names_returned - 1) { + /* Last entry - fixup the last offset length. */ + PUSH_LE_U32(p2, 0, PTR_DIFF((rdata + num_rdata), p2)); + } + + p2 += get_filename(mem_ctx, + cli, + rdata, + recv_flags2, + p2, + data_end, + &finfo[i]); + + if (finfo->name == NULL) { + printf("%s:%d Unable to parse name from listing " + "of %s, position %u\n", + __FILE__, + __LINE__, + search_name, + (unsigned int)i); + return NT_STATUS_INVALID_NETWORK_RESPONSE; + } + } + *num_names = i; + *names = finfo; + return NT_STATUS_OK; +} + +/* + * Test a specific SMB1 findfirst path to see if it + * matches a given file array. + */ +static bool test_smb1_findfirst_path(struct cli_state *cli, + const char *search_path, + struct file_info *root_finfo, + size_t num_root_finfo) +{ + size_t i = 0; + size_t num_finfo = 0; + struct file_info *finfo = NULL; + NTSTATUS status; + + status = smb1_findfirst(talloc_tos(), + cli, + search_path, + &finfo, + &num_finfo); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb1findfirst on %s returned %s\n", + __FILE__, + __LINE__, + search_path, + nt_errstr(status)); + return false; + } + + if (num_finfo != num_root_finfo) { + printf("%s:%d On %s, num_finfo = %zu, num_root_finfo = %zu\n", + __FILE__, + __LINE__, + search_path, + num_finfo, + num_root_finfo); + return false; + } + for (i = 0; i < num_finfo; i++) { + bool match = strequal_m(finfo[i].name, + root_finfo[i].name); + if (!match) { + printf("%s:%d Mismatch. For %s, at position %zu, " + "finfo[i].name = %s, " + "root_finfo[i].name = %s\n", + __FILE__, + __LINE__, + search_path, + i, + finfo[i].name, + root_finfo[i].name); + return false; + } + } + TALLOC_FREE(finfo); + return true; +} + +/* + * "Raw" test of doing a SMB1 findfirst to a DFS share. + * We must (mostly) use the lower level smb1cli_XXXX() interfaces, + * not the cli_XXX() ones here as the ultimate goal is to fix our + * cli_XXX() interfaces to work transparently over DFS. + * + * So here, we're testing the server code, not the client code. + * + * Passes cleanly against Windows. + */ + +bool run_smb1_dfs_search_paths(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + bool dfs_supported = false; + struct file_info *root_finfo = NULL; + size_t num_root_finfo = 0; + bool retval = false; + bool ok = false; + uint16_t fnum = (uint16_t)-1; + + printf("Starting SMB1-DFS-SEARCH-PATHS\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + /* Ensure this is a DFS share. */ + dfs_supported = smbXcli_conn_dfs_supported(cli->conn); + if (!dfs_supported) { + printf("Server %s does not support DFS\n", + smbXcli_conn_remote_name(cli->conn)); + return false; + } + dfs_supported = smbXcli_tcon_is_dfs_share(cli->smb1.tcon); + if (!dfs_supported) { + printf("Share %s does not support DFS\n", + cli->share); + return false; + } + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "BAD\\BAD\\file"); + + /* Create a test file to search for. */ + status = smb1cli_ntcreatex(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + "BAD\\BAD\\file", + OPLOCK_NONE, /* CreatFlags */ + 0, /* RootDirectoryFid */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* DesiredAccess */ + 0, /* AllocationSize */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* ShareAccess */ + FILE_CREATE, /* CreateDisposition */ + 0, /* CreateOptions */ + 2, /* ImpersonationLevel */ + 0, /* SecurityFlags */ + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb1cli_ntcreatex on %s returned %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\file", + nt_errstr(status)); + return false; + } + + /* Close "file" handle. */ + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + fnum = (uint16_t)-1; + + /* Get the list of files in the share. */ + status = smb1_findfirst(talloc_tos(), + cli, + "SERVER\\SHARE\\*", + &root_finfo, + &num_root_finfo); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb1findfirst on %s returned %s\n", + __FILE__, + __LINE__, + "SERVER\\SHARE\\*", + nt_errstr(status)); + return false; + } + + /* + * Try different search names. They should + * all match the root directory list. + */ + ok = test_smb1_findfirst_path(cli, + "\\SERVER\\SHARE\\*", + root_finfo, + num_root_finfo); + if (!ok) { + goto err; + } + + ok = test_smb1_findfirst_path(cli, + "*", + root_finfo, + num_root_finfo); + if (!ok) { + goto err; + } + ok = test_smb1_findfirst_path(cli, + "\\*", + root_finfo, + num_root_finfo); + if (!ok) { + goto err; + } + ok = test_smb1_findfirst_path(cli, + "\\SERVER\\*", + root_finfo, + num_root_finfo); + if (!ok) { + goto err; + } + retval = true; + + err: + + if (fnum != (uint16_t)-1) { + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + } + + /* Delete anything we made. */ + (void)smb1_dfs_delete(cli, "BAD\\BAD\\file"); + return retval; +} + +static bool smb1_create_testfile(struct cli_state *cli, + const char *path) +{ + NTSTATUS status; + uint16_t fnum = (uint16_t)-1; + + /* Create a test file. */ + status = smb1cli_ntcreatex(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + path, + OPLOCK_NONE, /* CreatFlags */ + 0, /* RootDirectoryFid */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* DesiredAccess */ + 0, /* AllocationSize */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* ShareAccess */ + FILE_CREATE, /* CreateDisposition */ + 0, /* CreateOptions */ + 2, /* ImpersonationLevel */ + 0, /* SecurityFlags */ + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb1cli_ntcreatex on %s returned %s\n", + __FILE__, + __LINE__, + path, + nt_errstr(status)); + return false; + } + + /* Close "file" handle. */ + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + return true; +} + +static NTSTATUS smb1_unlink(struct cli_state *cli, + const char *path) +{ + uint16_t vwv[1]; + uint8_t *bytes = NULL; + + PUSH_LE_U16(vwv, 0, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + bytes = talloc_array(talloc_tos(), uint8_t, 1); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + + return cli_smb(talloc_tos(), + cli, + SMBunlink, /* command. */ + 0, /* additional_flags. */ + 1, /* wct. */ + vwv, /* vwv. */ + talloc_get_size(bytes), /* num_bytes. */ + bytes, /* bytes. */ + NULL, /* result parent. */ + 0, /* min_wct. */ + NULL, /* return wcount. */ + NULL, /* return wvw. */ + NULL, /* return byte count. */ + NULL); /* return bytes. */ +} + +static bool test_smb1_unlink(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + bool ok = false; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\file"); + + /* Create a test file. */ + ok = smb1_create_testfile(cli, "\\BAD\\BAD\\file"); + if (!ok) { + printf("%s:%d failed to create test file %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\file"); + goto err; + } + + status = smb1_unlink(cli, "file"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1unlink of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "file", + nt_errstr(status)); + goto err; + } + status = smb1_unlink(cli, "\\BAD\\file"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1unlink of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\file", + nt_errstr(status)); + goto err; + } + status = smb1_unlink(cli, "\\BAD\\BAD\\file"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1unlink on %s returned %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\file", + nt_errstr(status)); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\file"); + return retval; +} + +static NTSTATUS smb1_mkdir(struct cli_state *cli, + const char *path) +{ + uint8_t *bytes = NULL; + + bytes = talloc_array(talloc_tos(), uint8_t, 1); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + + return cli_smb(talloc_tos(), + cli, + SMBmkdir, /* command. */ + 0, /* additional_flags. */ + 0, /* wct. */ + NULL, /* vwv. */ + talloc_get_size(bytes), /* num_bytes. */ + bytes, /* bytes. */ + NULL, /* result parent. */ + 0, /* min_wct. */ + NULL, /* return wcount. */ + NULL, /* return wvw. */ + NULL, /* return byte count. */ + NULL); /* return bytes. */ +} + +static bool test_smb1_mkdir(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\dir"); + + status = smb1_mkdir(cli, "dir"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) { + printf("%s:%d SMB1mkdir of %s should get " + "NT_STATUS_OBJECT_NAME_COLLISION, got %s\n", + __FILE__, + __LINE__, + "dir", + nt_errstr(status)); + goto err; + } + status = smb1_mkdir(cli, "\\BAD\\dir"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) { + printf("%s:%d SMB1mkdir of %s should get " + "NT_STATUS_OBJECT_NAME_COLLISION, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\dir", + nt_errstr(status)); + goto err; + } + status = smb1_mkdir(cli, "\\BAD\\BAD\\dir"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1mkdir on %s returned %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\dir", + nt_errstr(status)); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\dir"); + return retval; +} + +static NTSTATUS smb1_rmdir(struct cli_state *cli, + const char *path) +{ + uint8_t *bytes = NULL; + + bytes = talloc_array(talloc_tos(), uint8_t, 1); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + + return cli_smb(talloc_tos(), + cli, + SMBrmdir, /* command. */ + 0, /* additional_flags. */ + 0, /* wct. */ + NULL, /* vwv. */ + talloc_get_size(bytes), /* num_bytes. */ + bytes, /* bytes. */ + NULL, /* result parent. */ + 0, /* min_wct. */ + NULL, /* return wcount. */ + NULL, /* return wvw. */ + NULL, /* return byte count. */ + NULL); /* return bytes. */ +} + +static bool test_smb1_rmdir(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\dir"); + + status = smb1_mkdir(cli, "\\BAD\\BAD\\dir"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1rmdir on %s returned %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\dir", + nt_errstr(status)); + goto err; + } + + status = smb1_rmdir(cli, "dir"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("%s:%d SMB1rmdir of %s should get " + "NT_STATUS_ACCESS_DENIED, got %s\n", + __FILE__, + __LINE__, + "dir", + nt_errstr(status)); + goto err; + } + status = smb1_rmdir(cli, "\\BAD\\dir"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("%s:%d SMB1rmdir of %s should get " + "NT_STATUS_ACCESS_DENIED, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\dir", + nt_errstr(status)); + goto err; + } + status = smb1_rmdir(cli, "\\BAD\\BAD\\dir"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1rmdir on %s returned %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\dir", + nt_errstr(status)); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\dir"); + return retval; +} + +static NTSTATUS smb1_ntcreatex(struct cli_state *cli, + const char *path) +{ + NTSTATUS status; + uint16_t fnum = (uint16_t)-1; + + status = smb1cli_ntcreatex(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + path, + OPLOCK_NONE, /* CreatFlags */ + 0, /* RootDirectoryFid */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* DesiredAccess */ + 0, /* AllocationSize */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* ShareAccess */ + FILE_CREATE, /* CreateDisposition */ + 0, /* CreateOptions */ + 2, /* ImpersonationLevel */ + 0, /* SecurityFlags */ + &fnum); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + /* Close "file" handle. */ + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + return NT_STATUS_OK; +} + +static bool test_smb1_ntcreatex(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\ntcreateXfile"); + + status = smb1_ntcreatex(cli, "ntcreateXfile"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) { + printf("%s:%d SMB1ntcreateX of %s should get " + "NT_STATUS_OBJECT_NAME_COLLISION, got %s\n", + __FILE__, + __LINE__, + "ntcreateXfile", + nt_errstr(status)); + goto err; + } + status = smb1_ntcreatex(cli, "\\BAD\\ntcreateXfile"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) { + printf("%s:%d SMB1ntcreateX of %s should get " + "NT_STATUS_OBJECT_NAME_COLLISION, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\ntcreateXfile", + nt_errstr(status)); + goto err; + } + status = smb1_ntcreatex(cli, "\\BAD\\BAD\\ntcreateXfile"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1ntcreateX on %s returned %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\ntcreateXfile", + nt_errstr(status)); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\ntcreateXfile"); + return retval; +} + +static NTSTATUS smb1_nttrans_create(struct cli_state *cli, + const char *path) +{ + uint8_t *param = NULL; + size_t converted_len = 0; + uint8_t *rparam = NULL; + uint32_t num_rparam = 0; + uint16_t fnum = (uint16_t)-1; + NTSTATUS status; + + param = talloc_zero_array(talloc_tos(), uint8_t, 53); + if (param == NULL) { + return NT_STATUS_NO_MEMORY; + } + + param = trans2_bytes_push_str(param, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path), + &converted_len); + if (param == NULL) { + return NT_STATUS_NO_MEMORY; + } + + PUSH_LE_U32(param, 8, SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE); /* DesiredAccess */ + PUSH_LE_U32(param, 20, FILE_ATTRIBUTE_NORMAL); + PUSH_LE_U32(param, 24, FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE); /* ShareAccess */ + PUSH_LE_U32(param, 28, FILE_CREATE); + PUSH_LE_U32(param, 44, converted_len); + PUSH_LE_U32(param, 48, 0x02); /* ImpersonationLevel */ + + status = cli_trans(talloc_tos(), + cli, + SMBnttrans, /* trans cmd */ + NULL, /* pipe_name */ + 0, /* fid */ + NT_TRANSACT_CREATE, /* function */ + 0, /* flags */ + NULL, /* setup */ + 0, /* num_setup */ + 0, /* max_setup */ + param, /* param */ + talloc_get_size(param), /* num_param */ + 128, /* max_param */ + NULL, /* data */ + 0, /* num_data */ + 0, /* max_data */ + NULL, /* recv_flags2 */ + NULL, /* rsetup */ + 0, /* min_rsetup */ + NULL, /* num_rsetup */ + &rparam, /* rparam */ + 69, /* min_rparam */ + &num_rparam, /* num_rparam */ + NULL, /* rdata */ + 0, /* min_rdata */ + NULL); /* num_rdata */ + if (!NT_STATUS_IS_OK(status)) { + return status; + } + fnum = PULL_LE_U16(param, 2); + /* Close "file" handle. */ + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + return NT_STATUS_OK; +} + +static bool test_smb1_nttrans_create(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\nttransfile"); + + status = smb1_nttrans_create(cli, "nttransfile"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) { + printf("%s:%d SMB1trans NT_TRANSACT_CREATE of %s should get " + "NT_STATUS_OBJECT_NAME_COLLISION, got %s\n", + __FILE__, + __LINE__, + "nttransfile", + nt_errstr(status)); + goto err; + } + status = smb1_nttrans_create(cli, "\\BAD\\nttransfile"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) { + printf("%s:%d SMB1trans NT_TRANSACT_CREATE of %s should get " + "NT_STATUS_OBJECT_NAME_COLLISION, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\nttransfile", + nt_errstr(status)); + goto err; + } + status = smb1_nttrans_create(cli, "\\BAD\\BAD\\nttransfile"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1trans NT_TRANSACT_CREATE on %s returned %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\nttransfile", + nt_errstr(status)); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\nttransfile"); + return retval; +} + +struct smb1_openx_state { + const char *fname; + uint16_t vwv[15]; + uint16_t fnum; + struct iovec bytes; +}; + +static void smb1_openx_done(struct tevent_req *subreq); + +static struct tevent_req *smb1_openx_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *path) +{ + struct tevent_req *req = NULL; + struct tevent_req *subreq = NULL; + uint16_t accessmode = 0; + struct smb1_openx_state *state = NULL; + uint8_t *bytes = NULL; + NTSTATUS status; + + req = tevent_req_create(mem_ctx, &state, struct smb1_openx_state); + if (req == NULL) { + return NULL; + } + + accessmode = (DENY_NONE<<4); + accessmode |= DOS_OPEN_RDONLY; + + PUSH_LE_U8(state->vwv + 0, 0, 0xFF); + PUSH_LE_U16(state->vwv + 3, 0, accessmode); + PUSH_LE_U16(state->vwv + 4, 0, + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_DIRECTORY); + PUSH_LE_U16(state->vwv + 8, + 0, + OPENX_FILE_CREATE_IF_NOT_EXIST| OPENX_FILE_EXISTS_FAIL); + + bytes = talloc_array(state, uint8_t, 0); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (tevent_req_nomem(bytes, req)) { + return tevent_req_post(req, ev); + } + + state->bytes.iov_base = (void *)bytes; + state->bytes.iov_len = talloc_get_size(bytes); + subreq = cli_smb_req_create(state, + ev, + cli, + SMBopenX, /* cmd */ + 0, /* additional_flags */ + 0, /* additional_flags2 */ + 15, /* num_vwv */ + state->vwv, /* vwv */ + 1, /* iovcount */ + &state->bytes); /* iovec */ + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, smb1_openx_done, req); + + status = smb1cli_req_chain_submit(&subreq, 1); + if (tevent_req_nterror(req, status)) { + return tevent_req_post(req, ev); + } + return req; +} + +static void smb1_openx_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct smb1_openx_state *state = tevent_req_data( + req, struct smb1_openx_state); + uint8_t wct = 0; + uint16_t *vwv = NULL; + NTSTATUS status; + + status = cli_smb_recv(subreq, + state, + NULL, /* pinbuf */ + 3, /* min_wct */ + &wct, /* wct */ + &vwv, /* vwv */ + NULL, /* num_rbytes */ + NULL); /* rbytes */ + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + state->fnum = PULL_LE_U16(vwv+2, 0); + tevent_req_done(req); +} + +static NTSTATUS smb1_openx_recv(struct tevent_req *req, uint16_t *pfnum) +{ + struct smb1_openx_state *state = tevent_req_data( + req, struct smb1_openx_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + return status; + } + *pfnum = state->fnum; + return NT_STATUS_OK; +} + +static NTSTATUS smb1_openx(struct cli_state *cli, const char *path) +{ + TALLOC_CTX *frame = talloc_stackframe(); + struct tevent_context *ev = NULL; + struct tevent_req *req = NULL; + uint16_t fnum = (uint16_t)-1; + NTSTATUS status = NT_STATUS_NO_MEMORY; + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + goto fail; + } + + req = smb1_openx_send(frame, + ev, + cli, + path); + if (req == NULL) { + goto fail; + } + + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + goto fail; + } + + status = smb1_openx_recv(req, &fnum); + fail: + + /* Close "file" handle. */ + if (fnum != (uint16_t)-1) { + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + } + TALLOC_FREE(frame); + return status; +} + +static bool test_smb1_openx(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\openxfile"); + + status = smb1_openx(cli, "openxfile"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1openx of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "openxfile", + nt_errstr(status)); + goto err; + } + status = smb1_openx(cli, "\\BAD\\openxfile"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1openx of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\openxfile", + nt_errstr(status)); + goto err; + } + status = smb1_openx(cli, "\\BAD\\BAD\\openxfile"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1openx on %s returned %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\openxfile", + nt_errstr(status)); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\openxfile"); + return retval; +} + +static NTSTATUS smb1_open(struct cli_state *cli, + const char *path, + uint16_t *pfnum) +{ + uint16_t vwv[2] = { 0, 0}; + uint8_t *bytes = NULL; + uint16_t accessmode = 0; + uint16_t *return_words = NULL; + uint8_t return_wcount = 0; + NTSTATUS status; + + accessmode = (DENY_NONE<<4); + accessmode |= DOS_OPEN_RDONLY; + + PUSH_LE_U16(vwv + 0, 0, accessmode); + PUSH_LE_U16(vwv + 1, 0, FILE_ATTRIBUTE_NORMAL); + + bytes = talloc_array(talloc_tos(), uint8_t, 1); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = cli_smb(talloc_tos(), + cli, + SMBopen, /* command. */ + 0, /* additional_flags. */ + 2, /* wct. */ + vwv, /* vwv. */ + talloc_get_size(bytes), /* num_bytes. */ + bytes, /* bytes. */ + NULL, /* result parent. */ + 7, /* min_wct. */ + &return_wcount, /* return wcount. */ + &return_words, /* return wvw. */ + NULL, /* return byte count. */ + NULL); /* return bytes. */ + if (!NT_STATUS_IS_OK(status)) { + return status; + } + *pfnum = PULL_LE_U16(return_words, 0); + return status; +} + +static bool test_smb1_open(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + bool ok = false; + bool equal = false; + uint16_t fnum = (uint16_t)-1; + struct timespec testfile_crtime = { 0 }; + struct timespec open_crtime = { 0 }; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\openfile"); + + /* Create a test file. */ + ok = smb1_create_testfile(cli, "\\BAD\\BAD\\openfile"); + if (!ok) { + printf("%s:%d failed to create test file %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\openfile"); + goto err; + } + + /* Get the test file crtime number. */ + status = get_smb1_crtime(cli, + "\\BAD\\BAD\\openfile", + &testfile_crtime); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get crtime for %s, (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\openfile", + nt_errstr(status)); + goto err; + } + + status = smb1_open(cli, "openfile", &fnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1open of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "openfile", + nt_errstr(status)); + goto err; + } + status = smb1_open(cli, "\\BAD\\openfile", &fnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1open of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\openfile", + nt_errstr(status)); + goto err; + } + status = smb1_open(cli, "\\BAD\\BAD\\openfile", &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d failed to open test file %s (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\openfile", + nt_errstr(status)); + goto err; + } + + status = cli_qfileinfo_basic(cli, + fnum, + NULL, /* attr */ + NULL, /* size */ + &open_crtime, /* create_time */ + NULL, /* access_time */ + NULL, /* write_time */ + NULL, /* change_time */ + NULL); /* ino */ + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d failed to get crtime of test file %s (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\openfile", + nt_errstr(status)); + goto err; + } + equal = (timespec_compare(&testfile_crtime, &open_crtime) == 0); + if (!equal) { + printf("%s:%d crtime mismatch of test file %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\openfile"); + goto err; + } + + retval = true; + + err: + + /* Close "openfile" handle. */ + if (fnum != (uint16_t)-1) { + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + } + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\openfile"); + return retval; +} + +static NTSTATUS smb1_create(struct cli_state *cli, + const char *path, + uint16_t smb1_operation, + uint16_t *pfnum) +{ + uint16_t vwv[3] = { 0, 0, 0}; + uint8_t *bytes = NULL; + uint16_t *return_words = NULL; + uint8_t return_wcount = 0; + NTSTATUS status; + + PUSH_LE_U16(vwv + 0, 0, FILE_ATTRIBUTE_NORMAL); + + bytes = talloc_array(talloc_tos(), uint8_t, 1); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = cli_smb(talloc_tos(), + cli, + smb1_operation, /* command. */ + 0, /* additional_flags. */ + 3, /* wct. */ + vwv, /* vwv. */ + talloc_get_size(bytes), /* num_bytes. */ + bytes, /* bytes. */ + NULL, /* result parent. */ + 1, /* min_wct. */ + &return_wcount, /* return wcount. */ + &return_words, /* return wvw. */ + NULL, /* return byte count. */ + NULL); /* return bytes. */ + if (!NT_STATUS_IS_OK(status)) { + return status; + } + *pfnum = PULL_LE_U16(return_words, 0); + return status; +} + +static bool test_smb1_create(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + uint16_t fnum = (uint16_t)-1; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\createfile"); + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\mknewfile"); + + status = smb1_create(cli, "createfile", SMBcreate, &fnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1create of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "createfile", + nt_errstr(status)); + goto err; + } + status = smb1_create(cli, "\\BAD\\createfile", SMBcreate, &fnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1open of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\openfile", + nt_errstr(status)); + goto err; + } + status = smb1_create(cli, "\\BAD\\BAD\\createfile", SMBcreate, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d failed to create file %s (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\createfile", + nt_errstr(status)); + goto err; + } + + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + + fnum = (uint16_t)-1; + + /* Now do the same with SMBmknew */ + status = smb1_create(cli, "mknewfile", SMBmknew, &fnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1mknew of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "mknewfile", + nt_errstr(status)); + goto err; + } + status = smb1_create(cli, "\\BAD\\mknewfile", SMBmknew, &fnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1mknew of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\mknewfile", + nt_errstr(status)); + goto err; + } + status = smb1_create(cli, "\\BAD\\BAD\\mknewfile", SMBmknew, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d failed to create file %s (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\mknewfile", + nt_errstr(status)); + goto err; + } + + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + + fnum = (uint16_t)-1; + + retval = true; + + err: + + /* Close "openfile" handle. */ + if (fnum != (uint16_t)-1) { + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + } + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\createfile"); + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\mknewfile"); + return retval; +} + +static NTSTATUS smb1_getatr(struct cli_state *cli, + const char *path, + uint16_t *pattr) +{ + uint8_t *bytes = NULL; + uint16_t *return_words = NULL; + uint8_t return_wcount = 0; + NTSTATUS status; + + bytes = talloc_array(talloc_tos(), uint8_t, 1); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = cli_smb(talloc_tos(), + cli, + SMBgetatr, /* command. */ + 0, /* additional_flags. */ + 0, /* wct. */ + NULL, /* vwv. */ + talloc_get_size(bytes), /* num_bytes. */ + bytes, /* bytes. */ + NULL, /* result parent. */ + 10, /* min_wct. */ + &return_wcount, /* return wcount. */ + &return_words, /* return wvw. */ + NULL, /* return byte count. */ + NULL); /* return bytes. */ + if (!NT_STATUS_IS_OK(status)) { + return status; + } + *pattr = PULL_LE_U16(return_words, 0); + return status; +} + +static bool test_smb1_getatr(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + bool ok = false; + uint16_t attrs = 0; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\getatrfile"); + + /* Create a test file. */ + ok = smb1_create_testfile(cli, "\\BAD\\BAD\\getatrfile"); + if (!ok) { + printf("%s:%d failed to create test file %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\getatrfile"); + goto err; + } + + /* + * We expect this to succeed, but get attributes of + * the root directory. + */ + status = smb1_getatr(cli, "getatrfile", &attrs); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1getatr of %s failed (%s)\n", + __FILE__, + __LINE__, + "getatrfile", + nt_errstr(status)); + goto err; + } + if ((attrs & FILE_ATTRIBUTE_DIRECTORY) == 0) { + printf("%s:%d error expected SMB1getatr of file %s " + "to return directory attributes. Got 0x%x\n", + __FILE__, + __LINE__, + "getatrfile", + (unsigned int)attrs); + goto err; + } + + /* + * We expect this to succeed, but get attributes of + * the root directory. + */ + status = smb1_getatr(cli, "\\BAD\\getatrfile", &attrs); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1getatr of %s failed (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\getatrfile", + nt_errstr(status)); + goto err; + } + if ((attrs & FILE_ATTRIBUTE_DIRECTORY) == 0) { + printf("%s:%d error expected SMB1getatr of file %s " + "to return directory attributes. Got 0x%x\n", + __FILE__, + __LINE__, + "\\BAD\\getatrfile", + (unsigned int)attrs); + goto err; + } + + /* + * We expect this to succeed, and get attributes of + * the testfile. + */ + status = smb1_getatr(cli, "\\BAD\\BAD\\getatrfile", &attrs); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1getatr of %s failed (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\getatrfile", + nt_errstr(status)); + goto err; + } + if (attrs & FILE_ATTRIBUTE_DIRECTORY) { + printf("%s:%d error expected SMB1getatr of file %s " + "to return non-directory attributes. Got 0x%x\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\getatrfile", + (unsigned int)attrs); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\getatrfile"); + return retval; +} + +static NTSTATUS smb1_setatr(struct cli_state *cli, + const char *path, + uint16_t attr) +{ + uint16_t vwv[8] = { 0 }; + uint8_t *bytes = NULL; + NTSTATUS status; + + PUSH_LE_U16(vwv, 0, attr); + bytes = talloc_array(talloc_tos(), uint8_t, 1); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + status = cli_smb(talloc_tos(), + cli, + SMBsetatr, /* command. */ + 0, /* additional_flags. */ + 8, /* wct. */ + vwv, /* vwv. */ + talloc_get_size(bytes), /* num_bytes. */ + bytes, /* bytes. */ + NULL, /* result parent. */ + 0, /* min_wct. */ + NULL, /* return wcount. */ + NULL, /* return wvw. */ + NULL, /* return byte count. */ + NULL); /* return bytes. */ + if (!NT_STATUS_IS_OK(status)) { + return status; + } + return status; +} + +static bool test_smb1_setatr(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + bool ok = false; + uint16_t file_attrs = 0; + uint16_t orig_file_attrs = 0; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\setatrfile"); + + /* Create a test file. */ + ok = smb1_create_testfile(cli, "\\BAD\\BAD\\setatrfile"); + if (!ok) { + printf("%s:%d failed to create test file %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\setatrfile"); + goto err; + } + /* Get it's original attributes. */ + status = smb1_getatr(cli, "\\BAD\\BAD\\setatrfile", &orig_file_attrs); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1getatr of %s failed (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\setatrfile", + nt_errstr(status)); + goto err; + } + + if (orig_file_attrs & FILE_ATTRIBUTE_SYSTEM) { + printf("%s:%d orig_file_attrs of %s already has SYSTEM. " + "Test cannot proceed.\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\setatrfile"); + goto err; + } + + /* + * Seems we can't set attrs on the root of a share, + * even as Administrator. + */ + status = smb1_setatr(cli, "setatrfile", FILE_ATTRIBUTE_SYSTEM); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("%s:%d SMB1setatr of %s should get " + "NT_STATUS_ACCESS_DENIED, got %s\n", + __FILE__, + __LINE__, + "setatrfile", + nt_errstr(status)); + goto err; + } + + /* + * Seems we can't set attrs on the root of a share, + * even as Administrator. + */ + status = smb1_setatr(cli, "\\BAD\\setatrfile", FILE_ATTRIBUTE_SYSTEM); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("%s:%d SMB1setatr of %s should get " + "NT_STATUS_ACCESS_DENIED, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\setatrfile", + nt_errstr(status)); + goto err; + } + + status = smb1_setatr(cli, + "\\BAD\\BAD\\setatrfile", + FILE_ATTRIBUTE_SYSTEM); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1setatr of %s failed (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\setatrfile", + nt_errstr(status)); + goto err; + } + status = smb1_getatr(cli, "\\BAD\\BAD\\setatrfile", &file_attrs); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1getatr of %s failed (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\setatrfile", + nt_errstr(status)); + goto err; + } + + if (file_attrs != FILE_ATTRIBUTE_SYSTEM) { + printf("%s:%d Failed to set SYSTEM attr on %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\setatrfile"); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\setatrfile"); + return retval; +} + +static NTSTATUS smb1_chkpath(struct cli_state *cli, + const char *path) +{ + uint8_t *bytes = NULL; + NTSTATUS status; + + bytes = talloc_array(talloc_tos(), uint8_t, 1); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + status = cli_smb(talloc_tos(), + cli, + SMBcheckpath, /* command. */ + 0, /* additional_flags. */ + 0, /* wct. */ + NULL, /* vwv. */ + talloc_get_size(bytes), /* num_bytes. */ + bytes, /* bytes. */ + NULL, /* result parent. */ + 0, /* min_wct. */ + NULL, /* return wcount. */ + NULL, /* return wvw. */ + NULL, /* return byte count. */ + NULL); /* return bytes. */ + if (!NT_STATUS_IS_OK(status)) { + return status; + } + return status; +} + +static bool test_smb1_chkpath(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + bool ok = false; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\chkpathfile"); + + /* Create a test file. */ + ok = smb1_create_testfile(cli, "\\BAD\\BAD\\chkpathfile"); + if (!ok) { + printf("%s:%d failed to create test file %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\chkpathfile"); + goto err; + } + /* + * Should succeed - "chkpathfile" maps to + * directory "". + */ + status = smb1_chkpath(cli, "chkpathfile"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1chkpath of %s failed (%s)\n", + __FILE__, + __LINE__, + "chkpathfile", + nt_errstr(status)); + goto err; + } + + /* + * Should succeed - "\\BAD\\chkpathfile" maps to + * directory "". + */ + status = smb1_chkpath(cli, "\\BAD\\chkpathfile"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1chkpath of %s failed (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\chkpathfile", + nt_errstr(status)); + goto err; + } + + /* + * Should fail - "\\BAD\\BAD\\chkpathfile" maps to the + * "\\BAD\\BAD\\chkpathfile", not a directory. + */ + status = smb1_chkpath(cli, "\\BAD\\BAD\\chkpathfile"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) { + printf("%s:%d SMB1chkpath of %s should get " + "NT_STATUS_NOT_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\chkpathfile", + nt_errstr(status)); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\chkpathfile"); + return retval; +} + +/* + * Test BUG: https://bugzilla.samba.org/show_bug.cgi?id=15419 + */ + +static bool test_smb1_chkpath_bad(struct cli_state *cli) +{ + NTSTATUS status; + + status = smb1_chkpath(cli, "\\x//\\/"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d SMB1chkpath of %s failed (%s)\n", + __FILE__, + __LINE__, + "\\x//\\/", + nt_errstr(status)); + return false; + } + return true; +} + +static NTSTATUS smb1_ctemp(struct cli_state *cli, + const char *path, + char **tmp_path) +{ + uint16_t vwv[3] = { 0 }; + uint8_t *bytes = NULL; + NTSTATUS status; + uint16_t *return_words = NULL; + uint8_t return_wcount = 0; + uint32_t return_bytecount = 0; + uint8_t *return_bytes = NULL; + size_t sret = 0; + uint16_t fnum = (uint16_t)-1; + + bytes = talloc_array(talloc_tos(), uint8_t, 1); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + bytes[0] = 4; + bytes = smb_bytes_push_str(bytes, + smbXcli_conn_use_unicode(cli->conn), + path, + strlen(path)+1, + NULL); + if (bytes == NULL) { + return NT_STATUS_NO_MEMORY; + } + status = cli_smb(talloc_tos(), + cli, + SMBctemp, /* command. */ + 0, /* additional_flags. */ + 3, /* wct. */ + vwv, /* vwv. */ + talloc_get_size(bytes), /* num_bytes. */ + bytes, /* bytes. */ + NULL, /* result parent. */ + 1, /* min_wct. */ + &return_wcount, /* return wcount. */ + &return_words, /* return wvw. */ + &return_bytecount, /* return byte count. */ + &return_bytes); /* return bytes. */ + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (return_wcount != 1) { + return NT_STATUS_INVALID_NETWORK_RESPONSE; + } + + fnum = PULL_LE_U16(return_words, 0); + + /* Delete the file by fnum. */ + status = cli_nt_delete_on_close(cli, fnum, 1); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + (void)smb1cli_close(cli->conn, + cli->timeout, + cli->smb1.pid, + cli->smb1.tcon, + cli->smb1.session, + fnum, + 0); /* last_modified */ + fnum = (uint16_t)-1; + + if (return_bytecount < 2) { + return NT_STATUS_DATA_ERROR; + } + + sret = pull_string_talloc(talloc_tos(), + NULL, + 0, + tmp_path, + return_bytes, + return_bytecount, + STR_ASCII); + if (sret == 0) { + return NT_STATUS_NO_MEMORY; + } + + return status; +} + +static bool test_smb1_ctemp(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + char *retpath = NULL; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\ctemp_dir"); + + status = smb1_mkdir(cli, "\\BAD\\BAD\\ctemp_dir"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to create %s (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\ctemp_dir", + nt_errstr(status)); + goto err; + } + + /* + * Windows returns NT_STATUS_FILE_IS_A_DIRECTORY + * for all SMBctemp calls on a DFS share, no + * matter what we put in the pathname. + */ + + /* + * When we fix smbd we'll need to detect running + * in smbtorture3 against smbd here and modify + * the expected behavior. Windows is simply + * broken here. + */ + status = smb1_ctemp(cli, "ctemp_dir", &retpath); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1ctemp of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "ctemp_dir", + nt_errstr(status)); + goto err; + } + status = smb1_ctemp(cli, "\\BAD\\ctemp_dir", &retpath); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1ctemp of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\ctemp_dir", + nt_errstr(status)); + goto err; + } + status = smb1_ctemp(cli, "\\BAD\\BAD\\ctemp_dir", &retpath); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) { + printf("%s:%d SMB1ctemp of %s should get " + "NT_STATUS_FILE_IS_A_DIRECTORY, got %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\ctemp_dir", + nt_errstr(status)); + goto err; + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\ctemp_dir"); + return retval; +} + +static NTSTATUS smb1_qpathinfo(struct cli_state *cli, + const char *fname, + uint32_t *pattrs) +{ + NTSTATUS status; + uint8_t *param = NULL; + uint16_t setup[1] = { 0 }; + uint8_t *rdata = NULL; + uint32_t num_rdata = 0; + + PUSH_LE_U16(setup, 0, TRANSACT2_QPATHINFO); + + param = talloc_zero_array(talloc_tos(), uint8_t, 6); + if (param == NULL) { + return NT_STATUS_NO_MEMORY; + } + PUSH_LE_U16(param, 0, SMB_QUERY_FILE_BASIC_INFO); + + param = trans2_bytes_push_str(param, + smbXcli_conn_use_unicode(cli->conn), + fname, + strlen(fname)+1, + NULL); + if (param == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = cli_trans(talloc_tos(), + cli, + SMBtrans2, /* cmd */ + NULL, /* pipe_name */ + 0, /* fid */ + 0, /* function */ + 0, /* flags */ + &setup[0], + 1, /* num_setup uint16_t words */ + 0, /* max returned setup */ + param, + talloc_get_size(param), /* num_param */ + 2, /* max returned param */ + NULL, /* data */ + 0, /* num_data */ + SMB_BUFFER_SIZE_MAX, /* max returned data */ + /* Return values from here on.. */ + NULL, /* recv_flags2 */ + NULL, /* rsetup */ + 0, /* min returned rsetup */ + NULL, /* num_rsetup */ + NULL, + 0, /* min returned rparam */ + NULL, /* number of returned rparam */ + &rdata, + 36, /* min returned rdata */ + &num_rdata); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + *pattrs = PULL_LE_U32(rdata, 32); + return NT_STATUS_OK; +} + +static bool test_smb1_qpathinfo(struct cli_state *cli) +{ + NTSTATUS status; + bool retval = false; + bool ok = false; + uint32_t attrs; + + /* Start clean. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\qpathinfo_file"); + + /* Create a test file. */ + ok = smb1_create_testfile(cli, "\\BAD\\BAD\\qpathinfo_file"); + if (!ok) { + printf("%s:%d failed to create test file %s\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\qpathinfo_file"); + goto err; + } + + /* Should get root dir attrs. */ + status = smb1_qpathinfo(cli, "qpathinfo_file", &attrs); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb1_qpathinfo failed %s (%s)\n", + __FILE__, + __LINE__, + "qpathinfo_file", + nt_errstr(status)); + goto err; + } + if ((attrs & FILE_ATTRIBUTE_DIRECTORY) == 0) { + printf("%s:%d expected FILE_ATTRIBUTE_DIRECTORY on %s " + "got attribute 0x%x\n", + __FILE__, + __LINE__, + "qpathinfo_file", + (unsigned int)attrs); + goto err; + } + + /* Should get root dir attrs. */ + status = smb1_qpathinfo(cli, "\\BAD\\qpathinfo_file", &attrs); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb1_qpathinfo failed %s (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\qpathinfo_file", + nt_errstr(status)); + goto err; + } + if ((attrs & FILE_ATTRIBUTE_DIRECTORY) == 0) { + printf("%s:%d expected FILE_ATTRIBUTE_DIRECTORY on %s " + "got attribute 0x%x\n", + __FILE__, + __LINE__, + "\\BAD\\qpathinfo_file", + (unsigned int)attrs); + goto err; + } + + /* Should get file attrs. */ + status = smb1_qpathinfo(cli, "\\BAD\\BAD\\qpathinfo_file", &attrs); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb1_qpathinfo failed %s (%s)\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\qpathinfo_file", + nt_errstr(status)); + goto err; + } + if ((attrs & FILE_ATTRIBUTE_DIRECTORY) != 0) { + printf("%s:%d expected not FILE_ATTRIBUTE_DIRECTORY on %s " + "got attribute 0x%x\n", + __FILE__, + __LINE__, + "\\BAD\\BAD\\qpathinfo_file", + (unsigned int)attrs); + } + + retval = true; + + err: + + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\qpathinfo_file"); + return retval; +} + +/* + * "Raw" test of different SMB1 operations to a DFS share. + * We must (mostly) use the lower level smb1cli_XXXX() interfaces, + * not the cli_XXX() ones here as the ultimate goal is to fix our + * cli_XXX() interfaces to work transparently over DFS. + * + * So here, we're testing the server code, not the client code. + * + * Passes cleanly against Windows. + */ + +bool run_smb1_dfs_operations(int dummy) +{ + struct cli_state *cli = NULL; + bool dfs_supported = false; + bool retval = false; + bool ok = false; + + printf("Starting SMB1-DFS-OPS\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + /* Ensure this is a DFS share. */ + dfs_supported = smbXcli_conn_dfs_supported(cli->conn); + if (!dfs_supported) { + printf("Server %s does not support DFS\n", + smbXcli_conn_remote_name(cli->conn)); + return false; + } + dfs_supported = smbXcli_tcon_is_dfs_share(cli->smb1.tcon); + if (!dfs_supported) { + printf("Share %s does not support DFS\n", + cli->share); + return false; + } + + ok = test_smb1_unlink(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_mkdir(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_rmdir(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_ntcreatex(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_nttrans_create(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_openx(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_open(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_create(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_getatr(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_setatr(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_chkpath(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_ctemp(cli); + if (!ok) { + goto err; + } + + ok = test_smb1_qpathinfo(cli); + if (!ok) { + goto err; + } + + retval = true; + + err: + + /* Delete anything we made. */ + (void)smb1_dfs_delete(cli, "\\BAD\\BAD\\file"); + return retval; +} + +/* + * Test BUG: https://bugzilla.samba.org/show_bug.cgi?id=15419 + */ + +bool run_smb1_dfs_check_badpath(int dummy) +{ + struct cli_state *cli = NULL; + bool dfs_supported = false; + + printf("Starting SMB1-DFS-CHECK-BADPATH\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + /* Ensure this is a DFS share. */ + dfs_supported = smbXcli_conn_dfs_supported(cli->conn); + if (!dfs_supported) { + printf("Server %s does not support DFS\n", + smbXcli_conn_remote_name(cli->conn)); + return false; + } + dfs_supported = smbXcli_tcon_is_dfs_share(cli->smb1.tcon); + if (!dfs_supported) { + printf("Share %s does not support DFS\n", + cli->share); + return false; + } + + return test_smb1_chkpath_bad(cli); +} diff --git a/source3/torture/test_smb2.c b/source3/torture/test_smb2.c new file mode 100644 index 0000000..3b2e1e4 --- /dev/null +++ b/source3/torture/test_smb2.c @@ -0,0 +1,5471 @@ +/* + Unix SMB/CIFS implementation. + Initial test for the smb2 client lib + Copyright (C) Volker Lendecke 2011 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" +#include "client.h" +#include "trans2.h" +#include "../libcli/smb/smbXcli_base.h" +#include "libcli/security/security.h" +#include "libsmb/proto.h" +#include "auth/credentials/credentials.h" +#include "auth/gensec/gensec.h" +#include "auth_generic.h" +#include "../librpc/ndr/libndr.h" +#include "libsmb/clirap.h" +#include "libsmb/cli_smb2_fnum.h" + +extern fstring host, workgroup, share, password, username, myname; +extern struct cli_credentials *torture_creds; + +bool run_smb2_basic(int dummy) +{ + struct cli_state *cli; + NTSTATUS status; + uint64_t fid_persistent, fid_volatile; + const char *hello = "Hello, world\n"; + uint8_t *result; + uint32_t nread; + uint8_t *dir_data; + uint32_t dir_data_length; + uint32_t saved_tid = 0; + struct smbXcli_tcon *saved_tcon = NULL; + char *saved_share = NULL; + uint64_t saved_uid = 0; + + printf("Starting SMB2-BASIC\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB2_02, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "smb2-basic.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_write(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, strlen(hello), 0, fid_persistent, + fid_volatile, 0, 0, (const uint8_t *)hello, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_write returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_read(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0x10000, 0, fid_persistent, + fid_volatile, 2, 0, + talloc_tos(), &result, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_read returned %s\n", nt_errstr(status)); + return false; + } + + if (nread != strlen(hello)) { + printf("smb2cli_read returned %d bytes, expected %d\n", + (int)nread, (int)strlen(hello)); + return false; + } + + if (memcmp(hello, result, nread) != 0) { + printf("smb2cli_read returned '%s', expected '%s'\n", + result, hello); + return false; + } + + status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_DIR_LIST| + SEC_DIR_READ_ATTRIBUTE, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_SYNCHRONOUS_IO_NONALERT| + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_query_directory( + cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon, + 1, 0, 0, fid_persistent, fid_volatile, "*", 0xffff, + talloc_tos(), &dir_data, &dir_data_length); + + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_directory returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + saved_tid = smb2cli_tcon_current_id(cli->smb2.tcon); + cli_state_save_tcon_share(cli, &saved_tcon, &saved_share); + cli->smb2.tcon = smbXcli_tcon_create(cli); + smb2cli_tcon_set_values(cli->smb2.tcon, + NULL, /* session */ + saved_tid, + 0, /* type */ + 0, /* flags */ + 0, /* capabilities */ + 0 /* maximal_access */); + status = smb2cli_tdis(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon); + cli_state_restore_tcon_share(cli, saved_tcon, saved_share); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_tdis returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_tdis(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) { + printf("2nd smb2cli_tdis returned %s\n", nt_errstr(status)); + return false; + } + + saved_uid = smb2cli_session_current_id(cli->smb2.session); + status = smb2cli_logoff(cli->conn, cli->timeout, cli->smb2.session); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_logoff returned %s\n", nt_errstr(status)); + return false; + } + + cli->smb2.session = smbXcli_session_create(cli, cli->conn); + if (cli->smb2.session == NULL) { + printf("smbXcli_session_create() returned NULL\n"); + return false; + } + + smb2cli_session_set_id_and_flags(cli->smb2.session, saved_uid, 0); + + status = smb2cli_logoff(cli->conn, cli->timeout, cli->smb2.session); + if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) { + printf("2nd smb2cli_logoff returned %s\n", nt_errstr(status)); + return false; + } + + return true; +} + +bool run_smb2_negprot(int dummy) +{ + struct cli_state *cli; + NTSTATUS status; + enum protocol_types protocol; + const char *name = NULL; + + printf("Starting SMB2-NEGPROT\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_CORE, + PROTOCOL_LATEST, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + protocol = smbXcli_conn_protocol(cli->conn); + name = smb_protocol_types_string(protocol); + + if (protocol >= PROTOCOL_SMB2_02) { + printf("Server supports %s\n", name); + } else { + printf("Server DOES NOT support SMB2, only %s\n", name); + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + protocol, + protocol, + NULL, + NULL, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_RESET) && + !NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_DISCONNECTED) && + !NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_ABORTED)) { + printf("2nd smbXcli_negprot should disconnect - returned %s\n", + nt_errstr(status)); + return false; + } + + if (smbXcli_conn_is_connected(cli->conn)) { + printf("2nd smbXcli_negprot should disconnect " + "- still connected\n"); + return false; + } + + return true; +} + +bool run_smb2_anonymous(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + struct cli_credentials *anon_creds = NULL; + bool guest = false; + + printf("Starting SMB2-ANONYMOUS\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_LATEST, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + anon_creds = cli_credentials_init_anon(talloc_tos()); + if (anon_creds == NULL) { + printf("cli_credentials_init_anon failed\n"); + return false; + } + + status = cli_session_setup_creds(cli, anon_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + guest = smbXcli_session_is_guest(cli->smb2.session); + if (guest) { + printf("anonymous session should not have guest authentication\n"); + return false; + } + + return true; +} + +bool run_smb2_session_reconnect(int dummy) +{ + struct cli_state *cli1; + struct cli_state *cli2; + NTSTATUS status; + bool ok; + uint64_t fid_persistent, fid_volatile; + struct tevent_context *ev; + struct tevent_req *subreq; + DATA_BLOB in_blob = data_blob_null; + DATA_BLOB out_blob; + DATA_BLOB session_key; + struct auth_generic_state *auth_generic_state; + struct iovec *recv_iov; + const char *hello = "Hello, world\n"; + uint8_t *result; + uint32_t nread; + + printf("Starting SMB2-SESSION-RECONNECT\n"); + + if (!torture_init_connection(&cli1)) { + return false; + } + + status = smbXcli_negprot(cli1->conn, + cli1->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_LATEST, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli1, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli1, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli1->conn, + cli1->timeout, + cli1->smb2.session, + cli1->smb2.tcon, + "session-reconnect.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create on cli1 %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_write(cli1->conn, cli1->timeout, cli1->smb2.session, + cli1->smb2.tcon, strlen(hello), 0, fid_persistent, + fid_volatile, 0, 0, (const uint8_t *)hello, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_write returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_read(cli1->conn, cli1->timeout, cli1->smb2.session, + cli1->smb2.tcon, 0x10000, 0, fid_persistent, + fid_volatile, 2, 0, + talloc_tos(), &result, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_read returned %s\n", nt_errstr(status)); + return false; + } + + if (nread != strlen(hello)) { + printf("smb2cli_read returned %d bytes, expected %d\n", + (int)nread, (int)strlen(hello)); + return false; + } + + if (memcmp(hello, result, nread) != 0) { + printf("smb2cli_read returned '%s', expected '%s'\n", + result, hello); + return false; + } + + /* prepare second session */ + + if (!torture_init_connection(&cli2)) { + return false; + } + + status = smbXcli_negprot(cli2->conn, + cli2->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_LATEST, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_prepare returned %s\n", nt_errstr(status)); + return false; + } + + gensec_want_feature(auth_generic_state->gensec_security, + GENSEC_FEATURE_SESSION_KEY); + + status = auth_generic_set_creds(auth_generic_state, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_set_creds returned %s\n", nt_errstr(status)); + return false; + } + + status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_start returned %s\n", nt_errstr(status)); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + printf("samba_tevent_context_init() returned NULL\n"); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), data_blob_null, &in_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("gensec_update returned %s\n", nt_errstr(status)); + return false; + } + + cli2->smb2.session = smbXcli_session_create(cli2, cli2->conn); + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli2->conn, + cli2->timeout, + cli2->smb2.session, + 0x0, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + /* in_previous_session_id: */ + smb2cli_session_current_id(cli1->smb2.session), + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + NULL, &out_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), out_blob, &in_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_update returned %s\n", nt_errstr(status)); + return false; + } + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli2->conn, + cli2->timeout, + cli2->smb2.session, + 0x0, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + /* in_previous_session_id: */ + smb2cli_session_current_id(cli1->smb2.session), + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + &recv_iov, &out_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(), + &session_key); + if (!NT_STATUS_IS_OK(status)) { + printf("gensec_session_key returned %s\n", + nt_errstr(status)); + return false; + } + + /* check file operation on the old client */ + + status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli1, share, "?????", NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + /* + * checking file operations without signing. + * on w2k8r2 at least, flush, read and write also work the same way, + * while create gives ACCESS_DENIED without signing + */ + status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session, + cli2->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) && + !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) + { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_write(cli2->conn, cli2->timeout, cli2->smb2.session, + cli2->smb2.tcon, strlen(hello), 0, fid_persistent, + fid_volatile, 0, 0, (const uint8_t *)hello, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) && + !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) + { + printf("smb2cli_write returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session, + cli2->smb2.tcon, 0x10000, 0, fid_persistent, + fid_volatile, 2, 0, + talloc_tos(), &result, &nread); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) && + !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) + { + printf("smb2cli_read returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli2->conn, + cli2->timeout, + cli2->smb2.session, + cli2->smb2.tcon, + "session-reconnect.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) && + !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) { + printf("smb2cli_create on cli2 %s\n", nt_errstr(status)); + return false; + } + + /* now grab the session key and try with signing */ + + status = smb2cli_session_set_session_key(cli2->smb2.session, + session_key, + recv_iov); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_set_session_key %s\n", nt_errstr(status)); + return false; + } + + /* the tid seems to be irrelevant at this stage */ + + status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) && + !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) + { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_write(cli2->conn, cli2->timeout, cli2->smb2.session, + cli1->smb2.tcon, strlen(hello), 0, fid_persistent, + fid_volatile, 0, 0, (const uint8_t *)hello, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) && + !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) + { + printf("smb2cli_write returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session, + cli1->smb2.tcon, 0x10000, 0, fid_persistent, + fid_volatile, 2, 0, + talloc_tos(), &result, &nread); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) && + !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) + { + printf("smb2cli_read returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli2->conn, + cli2->timeout, + cli2->smb2.session, + cli1->smb2.tcon, + "session-reconnect.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED) && + !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) + { + printf("smb2cli_create on cli2 %s\n", nt_errstr(status)); + return false; + } + + /* now do a new tcon and test file calls again */ + + status = cli_tree_connect(cli2, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli2->conn, + cli2->timeout, + cli2->smb2.session, + cli2->smb2.tcon, + "session-reconnect.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create on cli2 %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_write(cli2->conn, cli2->timeout, cli2->smb2.session, + cli2->smb2.tcon, strlen(hello), 0, fid_persistent, + fid_volatile, 0, 0, (const uint8_t *)hello, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_write returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session, + cli2->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session, + cli2->smb2.tcon, 0x10000, 0, fid_persistent, + fid_volatile, 2, 0, + talloc_tos(), &result, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_read returned %s\n", nt_errstr(status)); + return false; + } + + if (nread != strlen(hello)) { + printf("smb2cli_read returned %d bytes, expected %d\n", + (int)nread, (int)strlen(hello)); + return false; + } + + if (memcmp(hello, result, nread) != 0) { + printf("smb2cli_read returned '%s', expected '%s'\n", + result, hello); + return false; + } + + return true; +} + +bool run_smb2_tcon_dependence(int dummy) +{ + struct cli_state *cli; + NTSTATUS status; + uint64_t fid_persistent, fid_volatile; + const char *hello = "Hello, world\n"; + uint8_t *result; + uint32_t nread; + struct smbXcli_tcon *tcon2; + uint32_t tcon2_id; + + printf("Starting SMB2-TCON-DEPENDENCE\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_LATEST, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "tcon_depedence.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create on cli %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_write(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, strlen(hello), 0, fid_persistent, + fid_volatile, 0, 0, (const uint8_t *)hello, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_write returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_read(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0x10000, 0, fid_persistent, + fid_volatile, 2, 0, + talloc_tos(), &result, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_read returned %s\n", nt_errstr(status)); + return false; + } + + if (nread != strlen(hello)) { + printf("smb2cli_read returned %d bytes, expected %d\n", + (int)nread, (int)strlen(hello)); + return false; + } + + if (memcmp(hello, result, nread) != 0) { + printf("smb2cli_read returned '%s', expected '%s'\n", + result, hello); + return false; + } + + /* check behaviour with wrong tid... */ + + tcon2 = smbXcli_tcon_create(cli); + tcon2_id = smb2cli_tcon_current_id(cli->smb2.tcon); + tcon2_id++; + smb2cli_tcon_set_values(tcon2, + NULL, /* session */ + tcon2_id, + 0, /* type */ + 0, /* flags */ + 0, /* capabilities */ + 0 /* maximal_access */); + + status = smb2cli_read(cli->conn, cli->timeout, cli->smb2.session, + tcon2, 0x10000, 0, fid_persistent, + fid_volatile, 2, 0, + talloc_tos(), &result, &nread); + if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) { + printf("smb2cli_read returned %s\n", nt_errstr(status)); + return false; + } + + talloc_free(tcon2); + + return true; +} + +bool run_smb2_multi_channel(int dummy) +{ + struct cli_state *cli1; + struct cli_state *cli2; + struct cli_state *cli3; + NTSTATUS status; + bool ok; + uint64_t fid_persistent, fid_volatile; + struct tevent_context *ev; + struct tevent_req *subreq; + DATA_BLOB in_blob = data_blob_null; + DATA_BLOB out_blob; + DATA_BLOB channel_session_key; + struct auth_generic_state *auth_generic_state; + struct iovec *recv_iov; + const char *hello = "Hello, world\n"; + uint8_t *result; + uint32_t nread; + struct GUID saved_guid = cli_state_client_guid; + + printf("Starting SMB2-MULTI-CHANNEL\n"); + + cli_state_client_guid = GUID_random(); + + if (!torture_init_connection(&cli1)) { + return false; + } + + if (!torture_init_connection(&cli2)) { + return false; + } + + if (!torture_init_connection(&cli3)) { + return false; + } + + cli_state_client_guid = saved_guid; + + status = smbXcli_negprot(cli1->conn, + cli1->timeout, + PROTOCOL_SMB3_00, + PROTOCOL_LATEST, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = smbXcli_negprot(cli2->conn, + cli2->timeout, + PROTOCOL_SMB3_00, + PROTOCOL_LATEST, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = smbXcli_negprot(cli3->conn, + cli3->timeout, + PROTOCOL_SMB3_00, + PROTOCOL_LATEST, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli1, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_sesssetup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli1, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_session_create_channel(cli2, + cli1->smb2.session, + cli2->conn, + &cli2->smb2.session); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_create_channel returned %s\n", + nt_errstr(status)); + return false; + } + + status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_prepare returned %s\n", nt_errstr(status)); + return false; + } + + gensec_want_feature(auth_generic_state->gensec_security, + GENSEC_FEATURE_SESSION_KEY); + + status = auth_generic_set_creds(auth_generic_state, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_set_creds returned %s\n", nt_errstr(status)); + return false; + } + + status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_start returned %s\n", nt_errstr(status)); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + printf("samba_tevent_context_init() returned NULL\n"); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), data_blob_null, &in_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("gensec_update returned %s\n", nt_errstr(status)); + return false; + } + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli2->conn, + cli2->timeout, + cli2->smb2.session, + 0x01, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + 0, /* in_previous_session_id */ + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + NULL, &out_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), out_blob, &in_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_update returned %s\n", nt_errstr(status)); + return false; + } + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli2->conn, + cli2->timeout, + cli2->smb2.session, + 0x01, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + 0, /* in_previous_session_id */ + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + &recv_iov, &out_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(), + &channel_session_key); + if (!NT_STATUS_IS_OK(status)) { + printf("gensec_session_key returned %s\n", + nt_errstr(status)); + return false; + } + + status = smb2cli_session_set_channel_key(cli2->smb2.session, + channel_session_key, + recv_iov); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_set_channel_key %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_session_create_channel(cli3, + cli1->smb2.session, + cli3->conn, + &cli3->smb2.session); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_create_channel returned %s\n", + nt_errstr(status)); + return false; + } + + status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_prepare returned %s\n", nt_errstr(status)); + return false; + } + + gensec_want_feature(auth_generic_state->gensec_security, + GENSEC_FEATURE_SESSION_KEY); + + status = auth_generic_set_creds(auth_generic_state, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_set_creds returned %s\n", nt_errstr(status)); + return false; + } + + status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_start returned %s\n", nt_errstr(status)); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), data_blob_null, &in_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("gensec_update returned %s\n", nt_errstr(status)); + return false; + } + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli3->conn, + cli3->timeout, + cli3->smb2.session, + 0x01, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + 0, /* in_previous_session_id */ + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + NULL, &out_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), out_blob, &in_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_update returned %s\n", nt_errstr(status)); + return false; + } + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli3->conn, + cli3->timeout, + cli3->smb2.session, + 0x01, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + 0, /* in_previous_session_id */ + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + &recv_iov, &out_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(), + &channel_session_key); + if (!NT_STATUS_IS_OK(status)) { + printf("gensec_session_key returned %s\n", + nt_errstr(status)); + return false; + } + + status = smb2cli_session_set_channel_key(cli3->smb2.session, + channel_session_key, + recv_iov); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_set_channel_key %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli2->conn, + cli2->timeout, + cli2->smb2.session, + cli1->smb2.tcon, + "multi-channel.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create on cli2 %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_write(cli1->conn, cli1->timeout, cli1->smb2.session, + cli1->smb2.tcon, strlen(hello), 0, fid_persistent, + fid_volatile, 0, 0, (const uint8_t *)hello, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_write returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli3->conn, cli3->timeout, cli3->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session, + cli1->smb2.tcon, 0x10000, 0, fid_persistent, + fid_volatile, 2, 0, + talloc_tos(), &result, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_read returned %s\n", nt_errstr(status)); + return false; + } + + if (nread != strlen(hello)) { + printf("smb2cli_read returned %d bytes, expected %d\n", + (int)nread, (int)strlen(hello)); + return false; + } + + if (memcmp(hello, result, nread) != 0) { + printf("smb2cli_read returned '%s', expected '%s'\n", + result, hello); + return false; + } + + status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_prepare returned %s\n", nt_errstr(status)); + return false; + } + + gensec_want_feature(auth_generic_state->gensec_security, + GENSEC_FEATURE_SESSION_KEY); + + status = auth_generic_set_creds(auth_generic_state, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_set_creds returned %s\n", nt_errstr(status)); + return false; + } + + status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_start returned %s\n", nt_errstr(status)); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), data_blob_null, &in_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("gensec_update returned %s\n", nt_errstr(status)); + return false; + } + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli3->conn, + cli3->timeout, + cli3->smb2.session, + 0x0, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + 0, /* in_previous_session_id */ + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + NULL, &out_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), out_blob, &in_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_update returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli3->conn, cli3->timeout, cli3->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli1->conn, + cli1->timeout, + cli1->smb2.session, + cli1->smb2.tcon, + "multi-channel-invalid.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("smb2cli_create %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli2->conn, + cli2->timeout, + cli2->smb2.session, + cli1->smb2.tcon, + "multi-channel-invalid.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("smb2cli_create %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli3->conn, + cli3->timeout, + cli3->smb2.session, + cli1->smb2.tcon, + "multi-channel-invalid.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("smb2cli_create %s\n", nt_errstr(status)); + return false; + } + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli2->conn, + cli2->timeout, + cli2->smb2.session, + 0x0, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + 0, /* in_previous_session_id */ + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + &recv_iov, &out_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = smb2cli_close(cli3->conn, cli3->timeout, cli3->smb2.session, + cli1->smb2.tcon, 0, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli3->conn, cli3->timeout, cli3->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session, + cli1->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + return true; +} + +bool run_smb2_session_reauth(int dummy) +{ + struct cli_state *cli; + NTSTATUS status; + bool ok; + uint64_t fid_persistent, fid_volatile; + uint64_t dir_persistent, dir_volatile; + uint8_t *dir_data; + uint32_t dir_data_length; + struct tevent_context *ev; + struct tevent_req *subreq; + DATA_BLOB in_blob = data_blob_null; + DATA_BLOB out_blob; + DATA_BLOB in_input_buffer; + DATA_BLOB out_output_buffer; + uint8_t in_file_info_class; + struct auth_generic_state *auth_generic_state; + struct iovec *recv_iov; + uint32_t saved_tid; + struct smbXcli_tcon *saved_tcon; + + printf("Starting SMB2-SESSION_REAUTH\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + /* + * PROTOCOL_SMB2_22 has a bug in win8pre0 + * it behaves like PROTOCOL_SMB2_02 + * and returns NT_STATUS_REQUEST_NOT_ACCEPTED, + * while it allows it on PROTOCOL_SMB2_10. + */ + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_10, + PROTOCOL_SMB2_10, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_sesssetup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "session-reauth.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_DIR_LIST| + SEC_DIR_READ_ATTRIBUTE, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_SYNCHRONOUS_IO_NONALERT| + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &dir_persistent, + &dir_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_query_directory( + cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon, + 1, 0x3, 0, dir_persistent, dir_volatile, + "session-reauth.txt", 0xffff, + talloc_tos(), &dir_data, &dir_data_length); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_directory returned %s\n", nt_errstr(status)); + return false; + } + + status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_prepare returned %s\n", nt_errstr(status)); + return false; + } + + gensec_want_feature(auth_generic_state->gensec_security, + GENSEC_FEATURE_SESSION_KEY); + + status = auth_generic_set_creds(auth_generic_state, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_set_creds returned %s\n", nt_errstr(status)); + return false; + } + + status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_client_start returned %s\n", nt_errstr(status)); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + printf("samba_tevent_context_init() returned NULL\n"); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), data_blob_null, &in_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("gensec_update returned %s\n", nt_errstr(status)); + return false; + } + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli->conn, + cli->timeout, + cli->smb2.session, + 0x0, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + 0, /* in_previous_session_id */ + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + NULL, &out_blob); + if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = gensec_update(auth_generic_state->gensec_security, + talloc_tos(), out_blob, &in_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("auth_generic_update returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_query_directory( + cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon, + 1, 0x3, 0, dir_persistent, dir_volatile, + "session-reauth.txt", 0xffff, + talloc_tos(), &dir_data, &dir_data_length); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_directory returned %s\n", nt_errstr(status)); + return false; + } + + /* + * query_info seems to be a path based operation on Windows... + */ + status = smb2cli_query_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_SECURITY, + 0, /* in_file_info_class */ + 1024, /* in_max_output_length */ + NULL, /* in_input_buffer */ + SECINFO_OWNER, /* in_additional_info */ + 0, /* in_flags */ + fid_persistent, + fid_volatile, + talloc_tos(), + &out_output_buffer); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("smb2cli_query_info (security) returned %s\n", nt_errstr(status)); + return false; + } + + in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000; + status = smb2cli_query_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_FILE, + in_file_info_class, + 1024, /* in_max_output_length */ + NULL, /* in_input_buffer */ + 0, /* in_additional_info */ + 0, /* in_flags */ + fid_persistent, + fid_volatile, + talloc_tos(), + &out_output_buffer); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("smb2cli_query_info (position) returned %s\n", nt_errstr(status)); + return false; + } + + in_input_buffer = data_blob_talloc(talloc_tos(), NULL, 8); + SBVAL(in_input_buffer.data, 0, 512); + + in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000; + status = smb2cli_set_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_FILE, + in_file_info_class, + &in_input_buffer, + 0, /* in_additional_info */ + fid_persistent, + fid_volatile); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("smb2cli_set_info (position) returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "session-reauth-invalid.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("smb2cli_create %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_DIR_LIST| + SEC_DIR_READ_ATTRIBUTE, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_SYNCHRONOUS_IO_NONALERT| + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &dir_persistent, + &dir_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("smb2cli_create returned %s\n", nt_errstr(status)); + return false; + } + + saved_tid = smb2cli_tcon_current_id(cli->smb2.tcon); + saved_tcon = cli->smb2.tcon; + cli->smb2.tcon = smbXcli_tcon_create(cli); + smb2cli_tcon_set_values(cli->smb2.tcon, + NULL, /* session */ + saved_tid, + 0, /* type */ + 0, /* flags */ + 0, /* capabilities */ + 0 /* maximal_access */); + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + talloc_free(cli->smb2.tcon); + cli->smb2.tcon = saved_tcon; + + subreq = smb2cli_session_setup_send(talloc_tos(), ev, + cli->conn, + cli->timeout, + cli->smb2.session, + 0x0, /* in_flags */ + SMB2_CAP_DFS, /* in_capabilities */ + 0, /* in_channel */ + 0, /* in_previous_session_id */ + &in_blob); /* in_security_buffer */ + if (subreq == NULL) { + printf("smb2cli_session_setup_send() returned NULL\n"); + return false; + } + + ok = tevent_req_poll(subreq, ev); + if (!ok) { + printf("tevent_req_poll() returned false\n"); + return false; + } + + status = smb2cli_session_setup_recv(subreq, talloc_tos(), + &recv_iov, &out_blob); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_session_setup_recv returned %s\n", + nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_query_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_SECURITY, + 0, /* in_file_info_class */ + 1024, /* in_max_output_length */ + NULL, /* in_input_buffer */ + SECINFO_OWNER, /* in_additional_info */ + 0, /* in_flags */ + fid_persistent, + fid_volatile, + talloc_tos(), + &out_output_buffer); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_info (security) returned %s\n", nt_errstr(status)); + return false; + } + + in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000; + status = smb2cli_query_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_FILE, + in_file_info_class, + 1024, /* in_max_output_length */ + NULL, /* in_input_buffer */ + 0, /* in_additional_info */ + 0, /* in_flags */ + fid_persistent, + fid_volatile, + talloc_tos(), + &out_output_buffer); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_info (position) returned %s\n", nt_errstr(status)); + return false; + } + + in_input_buffer = data_blob_talloc(talloc_tos(), NULL, 8); + SBVAL(in_input_buffer.data, 0, 512); + + in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000; + status = smb2cli_set_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_FILE, + in_file_info_class, + &in_input_buffer, + 0, /* in_additional_info */ + fid_persistent, + fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_set_info (position) returned %s\n", nt_errstr(status)); + return false; + } + + in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000; + status = smb2cli_query_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_FILE, + in_file_info_class, + 1024, /* in_max_output_length */ + NULL, /* in_input_buffer */ + 0, /* in_additional_info */ + 0, /* in_flags */ + fid_persistent, + fid_volatile, + talloc_tos(), + &out_output_buffer); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_info (position) returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "session-reauth.txt", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DELETE_ON_CLOSE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_query_directory( + cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon, + 1, 0x3, 0, dir_persistent, dir_volatile, + "session-reauth.txt", 0xffff, + talloc_tos(), &dir_data, &dir_data_length); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_directory returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0, dir_persistent, dir_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + saved_tid = smb2cli_tcon_current_id(cli->smb2.tcon); + saved_tcon = cli->smb2.tcon; + cli->smb2.tcon = smbXcli_tcon_create(cli); + smb2cli_tcon_set_values(cli->smb2.tcon, + NULL, /* session */ + saved_tid, + 0, /* type */ + 0, /* flags */ + 0, /* capabilities */ + 0 /* maximal_access */); + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + talloc_free(cli->smb2.tcon); + cli->smb2.tcon = saved_tcon; + + return true; +} + +static NTSTATUS check_size(struct cli_state *cli, + uint16_t fnum, + const char *fname, + size_t size) +{ + off_t size_read = 0; + + NTSTATUS status = cli_qfileinfo_basic(cli, + fnum, + NULL, + &size_read, + NULL, + NULL, + NULL, + NULL, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_qfileinfo_basic of %s failed (%s)\n", + fname, + nt_errstr(status)); + return status; + } + + if (size != size_read) { + printf("size (%u) != size_read(%u) for %s\n", + (unsigned int)size, + (unsigned int)size_read, + fname); + /* Use EOF to mean bad size. */ + return NT_STATUS_END_OF_FILE; + } + return NT_STATUS_OK; +} + +/* Ensure cli_ftruncate() works for SMB2. */ + +bool run_smb2_ftruncate(int dummy) +{ + struct cli_state *cli = NULL; + const char *fname = "smb2_ftruncate.txt"; + uint16_t fnum = (uint16_t)-1; + bool correct = false; + size_t buflen = 1024*1024; + uint8_t *buf = NULL; + unsigned int i; + NTSTATUS status; + + printf("Starting SMB2-FTRUNCATE\n"); + + if (!torture_init_connection(&cli)) { + goto fail; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB2_02, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + goto fail; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + goto fail; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + goto fail; + } + + cli_setatr(cli, fname, 0, 0); + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli, + fname, + 0, + GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_NONE, + FILE_CREATE, + 0, + 0, + &fnum, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + buf = talloc_zero_array(cli, uint8_t, buflen); + if (buf == NULL) { + goto fail; + } + + /* Write 1MB. */ + status = cli_writeall(cli, + fnum, + 0, + buf, + 0, + buflen, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("write of %u to %s failed (%s)\n", + (unsigned int)buflen, + fname, + nt_errstr(status)); + goto fail; + } + + status = check_size(cli, fnum, fname, buflen); + if (!NT_STATUS_IS_OK(status)) { + goto fail; + } + + /* Now ftruncate. */ + for ( i = 0; i < 10; i++) { + status = cli_ftruncate(cli, fnum, i*1024); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ftruncate %u of %s failed (%s)\n", + (unsigned int)i*1024, + fname, + nt_errstr(status)); + goto fail; + } + status = check_size(cli, fnum, fname, i*1024); + if (!NT_STATUS_IS_OK(status)) { + goto fail; + } + } + + correct = true; + + fail: + + if (cli == NULL) { + return false; + } + + if (fnum != (uint16_t)-1) { + cli_close(cli, fnum); + } + cli_setatr(cli, fname, 0, 0); + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + if (!torture_close_connection(cli)) { + correct = false; + } + return correct; +} + +/* Ensure SMB2 flush on directories behaves correctly. */ + +static bool test_dir_fsync(struct cli_state *cli, const char *path) +{ + NTSTATUS status; + uint64_t fid_persistent, fid_volatile; + uint8_t *dir_data = NULL; + uint32_t dir_data_length = 0; + + /* Open directory - no write abilities. */ + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + path, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_DIR_LIST| + SEC_DIR_READ_ATTRIBUTE, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_SYNCHRONOUS_IO_NONALERT| + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create '%s' (readonly) returned %s\n", + path, + nt_errstr(status)); + return false; + } + + status = smb2cli_query_directory( + cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon, + 1, 0, 0, fid_persistent, fid_volatile, "*", 0xffff, + talloc_tos(), &dir_data, &dir_data_length); + + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_directory returned %s\n", + nt_errstr(status)); + return false; + } + + /* Open directory no write access. Flush should fail. */ + + status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("smb2cli_flush on a read-only directory returned %s\n", + nt_errstr(status)); + return false; + } + + status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + /* Open directory write-attributes only. Flush should still fail. */ + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + path, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_DIR_LIST| + SEC_DIR_WRITE_ATTRIBUTE| + SEC_DIR_READ_ATTRIBUTE, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_SYNCHRONOUS_IO_NONALERT| + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create '%s' (write attr) returned %s\n", + path, + nt_errstr(status)); + return false; + } + + status = smb2cli_query_directory( + cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon, + 1, 0, 0, fid_persistent, fid_volatile, "*", 0xffff, + talloc_tos(), &dir_data, &dir_data_length); + + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_directory returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("smb2cli_flush on a write-attributes directory " + "returned %s\n", + nt_errstr(status)); + return false; + } + + status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + /* Open directory with SEC_DIR_ADD_FILE access. Flush should now succeed. */ + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + path, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_DIR_LIST| + SEC_DIR_ADD_FILE, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_SYNCHRONOUS_IO_NONALERT| + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create '%s' (write FILE access) returned %s\n", + path, + nt_errstr(status)); + return false; + } + + status = smb2cli_query_directory( + cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon, + 1, 0, 0, fid_persistent, fid_volatile, "*", 0xffff, + talloc_tos(), &dir_data, &dir_data_length); + + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_directory returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush on a directory returned %s\n", + nt_errstr(status)); + return false; + } + + status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + /* Open directory with SEC_DIR_ADD_FILE access. Flush should now succeed. */ + + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + path, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_DIR_LIST| + SEC_DIR_ADD_SUBDIR, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_SYNCHRONOUS_IO_NONALERT| + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create '%s' (write DIR access) returned %s\n", + path, + nt_errstr(status)); + return false; + } + + status = smb2cli_query_directory( + cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tcon, + 1, 0, 0, fid_persistent, fid_volatile, "*", 0xffff, + talloc_tos(), &dir_data, &dir_data_length); + + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_query_directory returned %s\n", nt_errstr(status)); + return false; + } + + status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_flush on a directory returned %s\n", + nt_errstr(status)); + return false; + } + + status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session, + cli->smb2.tcon, 0, fid_persistent, fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + + return true; +} + +bool run_smb2_dir_fsync(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + bool bret = false; + const char *dname = "fsync_test_dir"; + + printf("Starting SMB2-DIR-FSYNC\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB2_02, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + (void)cli_rmdir(cli, dname); + status = cli_mkdir(cli, dname); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_mkdir(%s) returned %s\n", + dname, + nt_errstr(status)); + return false; + } + + /* Test on a subdirectory. */ + bret = test_dir_fsync(cli, dname); + if (bret == false) { + (void)cli_rmdir(cli, dname); + return false; + } + (void)cli_rmdir(cli, dname); + + /* Test on the root handle of a share. */ + bret = test_dir_fsync(cli, ""); + if (bret == false) { + return false; + } + return true; +} + +bool run_smb2_path_slash(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + uint64_t fid_persistent; + uint64_t fid_volatile; + const char *dname_noslash = "smb2_dir_slash"; + const char *dname_backslash = "smb2_dir_slash\\"; + const char *dname_slash = "smb2_dir_slash/"; + const char *fname_noslash = "smb2_file_slash"; + const char *fname_backslash = "smb2_file_slash\\"; + const char *fname_slash = "smb2_file_slash/"; + + printf("Starting SMB2-PATH-SLASH\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB2_02, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + (void)cli_unlink(cli, dname_noslash, 0); + (void)cli_rmdir(cli, dname_noslash); + (void)cli_unlink(cli, fname_noslash, 0); + (void)cli_rmdir(cli, fname_noslash); + + /* Try to create a directory with the backslash name. */ + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + dname_backslash, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + FILE_READ_DATA|FILE_READ_ATTRIBUTES, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + + /* directory ending in '\\' should be success. */ + + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_create '%s' returned %s - " + "should be NT_STATUS_OK\n", + dname_backslash, + nt_errstr(status)); + return false; + } + status = smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, + fid_persistent, + fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + printf("smb2cli_close returned %s\n", nt_errstr(status)); + return false; + } + + (void)cli_rmdir(cli, dname_noslash); + + /* Try to create a directory with the slash name. */ + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + dname_slash, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + FILE_READ_DATA|FILE_READ_ATTRIBUTES, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + + /* directory ending in '/' is an error. */ + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_INVALID)) { + printf("smb2cli_create '%s' returned %s - " + "should be NT_STATUS_OBJECT_NAME_INVALID\n", + dname_slash, + nt_errstr(status)); + if (NT_STATUS_IS_OK(status)) { + (void)smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, + fid_persistent, + fid_volatile); + } + (void)cli_rmdir(cli, dname_noslash); + return false; + } + + (void)cli_rmdir(cli, dname_noslash); + + /* Try to create a file with the backslash name. */ + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + fname_backslash, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + FILE_READ_DATA|FILE_READ_ATTRIBUTES, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_NON_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + + /* file ending in '\\' should be error. */ + + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_INVALID)) { + printf("smb2cli_create '%s' returned %s - " + "should be NT_STATUS_OBJECT_NAME_INVALID\n", + fname_backslash, + nt_errstr(status)); + if (NT_STATUS_IS_OK(status)) { + (void)smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, + fid_persistent, + fid_volatile); + } + (void)cli_unlink(cli, fname_noslash, 0); + return false; + } + + (void)cli_unlink(cli, fname_noslash, 0); + + /* Try to create a file with the slash name. */ + status = smb2cli_create( + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + fname_slash, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + FILE_READ_DATA|FILE_READ_ATTRIBUTES, /* desired_access, */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + FILE_NON_DIRECTORY_FILE, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, + NULL, + NULL, + NULL); + + /* file ending in '/' should be error. */ + + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_INVALID)) { + printf("smb2cli_create '%s' returned %s - " + "should be NT_STATUS_OBJECT_NAME_INVALID\n", + fname_slash, + nt_errstr(status)); + if (NT_STATUS_IS_OK(status)) { + (void)smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, + fid_persistent, + fid_volatile); + } + (void)cli_unlink(cli, fname_noslash, 0); + return false; + } + + (void)cli_unlink(cli, fname_noslash, 0); + return true; +} + +/* + * NB. This can only work against a server where + * the connecting user has been granted SeSecurityPrivilege. + * + * 1). Create a test file. + * 2). Open with SEC_FLAG_SYSTEM_SECURITY *only*. ACCESS_DENIED - + * NB. SMB2-only behavior. + * 3). Open with SEC_FLAG_SYSTEM_SECURITY|FILE_WRITE_ATTRIBUTES. + * 4). Write SACL. Should fail with ACCESS_DENIED (seems to need WRITE_DAC). + * 5). Close (3). + * 6). Open with SEC_FLAG_SYSTEM_SECURITY|SEC_STD_WRITE_DAC. + * 7). Write SACL. Success. + * 8). Close (4). + * 9). Open with SEC_FLAG_SYSTEM_SECURITY|READ_ATTRIBUTES. + * 10). Read SACL. Success. + * 11). Read DACL. Should fail with ACCESS_DENIED (no READ_CONTROL). + * 12). Close (9). + */ + +bool run_smb2_sacl(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + struct security_descriptor *sd_dacl = NULL; + struct security_descriptor *sd_sacl = NULL; + const char *fname = "sacl_test_file"; + uint16_t fnum = (uint16_t)-1; + + printf("Starting SMB2-SACL\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + (void)cli_unlink(cli, fname, 0); + + /* First create a file. */ + status = cli_ntcreate(cli, + fname, + 0, + GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_NONE, + FILE_CREATE, + 0, + 0, + &fnum, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("Create of %s failed (%s)\n", + fname, + nt_errstr(status)); + goto fail; + } + + cli_close(cli, fnum); + fnum = (uint16_t)-1; + + /* + * Now try to open with *only* SEC_FLAG_SYSTEM_SECURITY. + * This should fail with NT_STATUS_ACCESS_DENIED - but + * only against an SMB2 server. SMB1 allows this as tested + * in SMB1-SYSTEM-SECURITY. + */ + + status = cli_smb2_create_fnum(cli, + fname, + (struct cli_smb2_create_flags){0}, + SMB2_IMPERSONATION_IMPERSONATION, + SEC_FLAG_SYSTEM_SECURITY, /* desired access */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_NON_DIRECTORY_FILE, /* create_options, */ + NULL, /* in_cblobs. */ + &fnum, /* fnum */ + NULL, /* smb_create_returns */ + talloc_tos(), /* mem_ctx */ + NULL); /* out_cblobs */ + + if (NT_STATUS_EQUAL(status, NT_STATUS_PRIVILEGE_NOT_HELD)) { + printf("SMB2-SACL-TEST can only work with a user " + "who has been granted SeSecurityPrivilege.\n" + "This is the " + "\"Manage auditing and security log\"" + "privilege setting on Windows\n"); + goto fail; + } + + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("open file %s with SEC_FLAG_SYSTEM_SECURITY only: " + "got %s - should fail with ACCESS_DENIED\n", + fname, + nt_errstr(status)); + goto fail; + } + + /* + * Open with SEC_FLAG_SYSTEM_SECURITY|FILE_WRITE_ATTRIBUTES. + */ + + status = cli_smb2_create_fnum(cli, + fname, + (struct cli_smb2_create_flags){0}, + SMB2_IMPERSONATION_IMPERSONATION, + SEC_FLAG_SYSTEM_SECURITY| + FILE_WRITE_ATTRIBUTES, /* desired access */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_NON_DIRECTORY_FILE, /* create_options, */ + NULL, /* in_cblobs. */ + &fnum, /* fnum */ + NULL, /* smb_create_returns */ + talloc_tos(), /* mem_ctx */ + NULL); /* out_cblobs */ + + if (!NT_STATUS_IS_OK(status)) { + printf("Open of %s with (SEC_FLAG_SYSTEM_SECURITY|" + "FILE_WRITE_ATTRIBUTES) failed (%s)\n", + fname, + nt_errstr(status)); + goto fail; + } + + /* Create an SD with a SACL. */ + sd_sacl = security_descriptor_sacl_create(talloc_tos(), + 0, + NULL, /* owner. */ + NULL, /* group. */ + /* first ACE. */ + SID_WORLD, + SEC_ACE_TYPE_SYSTEM_AUDIT, + SEC_GENERIC_ALL, + SEC_ACE_FLAG_FAILED_ACCESS, + NULL); + + if (sd_sacl == NULL) { + printf("Out of memory creating SACL\n"); + goto fail; + } + + /* + * Write the SACL SD. This should fail + * even though we have SEC_FLAG_SYSTEM_SECURITY, + * as it seems to also need WRITE_DAC access. + */ + status = cli_set_security_descriptor(cli, + fnum, + SECINFO_DACL|SECINFO_SACL, + sd_sacl); + + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("Writing SACL on file %s got (%s) " + "should have failed with ACCESS_DENIED.\n", + fname, + nt_errstr(status)); + goto fail; + } + + /* And close. */ + cli_smb2_close_fnum(cli, fnum); + fnum = (uint16_t)-1; + + /* + * Open with SEC_FLAG_SYSTEM_SECURITY|SEC_STD_WRITE_DAC. + */ + + status = cli_smb2_create_fnum(cli, + fname, + (struct cli_smb2_create_flags){0}, + SMB2_IMPERSONATION_IMPERSONATION, + SEC_FLAG_SYSTEM_SECURITY| + SEC_STD_WRITE_DAC, /* desired access */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_NON_DIRECTORY_FILE, /* create_options, */ + NULL, /* in_cblobs. */ + &fnum, /* fnum */ + NULL, /* smb_create_returns */ + talloc_tos(), /* mem_ctx */ + NULL); /* out_cblobs */ + + if (!NT_STATUS_IS_OK(status)) { + printf("Open of %s with (SEC_FLAG_SYSTEM_SECURITY|" + "FILE_WRITE_ATTRIBUTES) failed (%s)\n", + fname, + nt_errstr(status)); + goto fail; + } + + /* + * Write the SACL SD. This should now succeed + * as we have both SEC_FLAG_SYSTEM_SECURITY + * and WRITE_DAC access. + */ + status = cli_set_security_descriptor(cli, + fnum, + SECINFO_DACL|SECINFO_SACL, + sd_sacl); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_set_security_descriptor SACL " + "on file %s failed (%s)\n", + fname, + nt_errstr(status)); + goto fail; + } + + /* And close. */ + cli_smb2_close_fnum(cli, fnum); + fnum = (uint16_t)-1; + + /* We're done with the sacl we made. */ + TALLOC_FREE(sd_sacl); + + /* + * Now try to open with SEC_FLAG_SYSTEM_SECURITY|READ_ATTRIBUTES. + * This gives us access to the SACL. + */ + + status = cli_smb2_create_fnum(cli, + fname, + (struct cli_smb2_create_flags){0}, + SMB2_IMPERSONATION_IMPERSONATION, + SEC_FLAG_SYSTEM_SECURITY| + FILE_READ_ATTRIBUTES, /* desired access */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_NON_DIRECTORY_FILE, /* create_options, */ + NULL, /* in_cblobs. */ + &fnum, /* fnum */ + NULL, /* smb_create_returns */ + talloc_tos(), /* mem_ctx */ + NULL); /* out_cblobs */ + + if (!NT_STATUS_IS_OK(status)) { + printf("Open of %s with (SEC_FLAG_SYSTEM_SECURITY|" + "FILE_READ_ATTRIBUTES) failed (%s)\n", + fname, + nt_errstr(status)); + goto fail; + } + + /* Try and read the SACL - should succeed. */ + status = cli_query_security_descriptor( + cli, fnum, SECINFO_SACL, talloc_tos(), &sd_sacl); + + if (!NT_STATUS_IS_OK(status)) { + printf("Read SACL from file %s failed (%s)\n", + fname, + nt_errstr(status)); + goto fail; + } + + TALLOC_FREE(sd_sacl); + + /* + * Try and read the DACL - should fail as we have + * no READ_DAC access. + */ + status = cli_query_security_descriptor( + cli, fnum, SECINFO_DACL, talloc_tos(), &sd_sacl); + + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("Reading DACL on file %s got (%s) " + "should have failed with ACCESS_DENIED.\n", + fname, + nt_errstr(status)); + goto fail; + } + + if (fnum != (uint16_t)-1) { + cli_smb2_close_fnum(cli, fnum); + fnum = (uint16_t)-1; + } + + TALLOC_FREE(sd_dacl); + TALLOC_FREE(sd_sacl); + + (void)cli_unlink(cli, fname, 0); + return true; + + fail: + + TALLOC_FREE(sd_dacl); + TALLOC_FREE(sd_sacl); + + if (fnum != (uint16_t)-1) { + cli_smb2_close_fnum(cli, fnum); + fnum = (uint16_t)-1; + } + + (void)cli_unlink(cli, fname, 0); + return false; +} + +bool run_smb2_quota1(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + uint16_t fnum = (uint16_t)-1; + SMB_NTQUOTA_STRUCT qt = {0}; + + printf("Starting SMB2-QUOTA1\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_smb2_create_fnum( + cli, + "\\", + (struct cli_smb2_create_flags){0}, + SMB2_IMPERSONATION_IMPERSONATION, + SEC_GENERIC_READ, /* desired access */ + 0, /* file_attributes, */ + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + FILE_DIRECTORY_FILE, /* create_options, */ + NULL, /* in_cblobs. */ + &fnum, /* fnum */ + NULL, /* smb_create_returns */ + NULL, /* mem_ctx */ + NULL); /* out_cblobs */ + if (!NT_STATUS_IS_OK(status)) { + printf("cli_smb2_create_fnum failed: %s\n", nt_errstr(status)); + return false; + } + + status = cli_smb2_get_user_quota(cli, fnum, &qt); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) { + printf("cli_smb2_get_user_quota returned %s, expected " + "NT_STATUS_INVALID_HANDLE\n", + nt_errstr(status)); + return false; + } + + return true; +} + +bool run_smb2_stream_acl(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + uint16_t fnum = (uint16_t)-1; + const char *fname = "stream_acl_test_file"; + const char *sname = "stream_acl_test_file:streamname"; + struct security_descriptor *sd_dacl = NULL; + bool ret = false; + + printf("SMB2 stream acl\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + /* Ensure file doesn't exist. */ + (void)cli_unlink(cli, fname, 0); + + /* Create the file. */ + status = cli_ntcreate(cli, + fname, + 0, + GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_NONE, + FILE_CREATE, + 0, + 0, + &fnum, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("Create of %s failed (%s)\n", + fname, + nt_errstr(status)); + goto fail; + } + + /* Close the handle. */ + cli_smb2_close_fnum(cli, fnum); + fnum = (uint16_t)-1; + + /* Create the stream. */ + status = cli_ntcreate(cli, + sname, + 0, + FILE_READ_DATA| + SEC_STD_READ_CONTROL| + SEC_STD_WRITE_DAC, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_NONE, + FILE_CREATE, + 0, + 0, + &fnum, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("Create of %s failed (%s)\n", + sname, + nt_errstr(status)); + goto fail; + } + + /* Close the handle. */ + cli_smb2_close_fnum(cli, fnum); + fnum = (uint16_t)-1; + + /* + * Open the stream - for Samba this ensures + * we prove we have a pathref fsp. + */ + status = cli_ntcreate(cli, + sname, + 0, + FILE_READ_DATA| + SEC_STD_READ_CONTROL| + SEC_STD_WRITE_DAC, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_NONE, + FILE_OPEN, + 0, + 0, + &fnum, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("Open of %s failed (%s)\n", + sname, + nt_errstr(status)); + goto fail; + } + + /* Read the security descriptor off the stream handle. */ + status = cli_query_security_descriptor(cli, + fnum, + SECINFO_DACL, + talloc_tos(), + &sd_dacl); + + if (!NT_STATUS_IS_OK(status)) { + printf("Reading DACL on stream %s got (%s)\n", + sname, + nt_errstr(status)); + goto fail; + } + + if (sd_dacl == NULL || sd_dacl->dacl == NULL || + sd_dacl->dacl->num_aces < 1) { + printf("Invalid DACL returned on stream %s " + "(this should not happen)\n", + sname); + goto fail; + } + + /* + * Ensure it allows FILE_READ_DATA in the first ace. + * It always should. + */ + if ((sd_dacl->dacl->aces[0].access_mask & FILE_READ_DATA) == 0) { + printf("DACL->ace[0] returned on stream %s " + "doesn't have read access (should not happen)\n", + sname); + goto fail; + } + + /* Remove FILE_READ_DATA from the first ace and set. */ + sd_dacl->dacl->aces[0].access_mask &= ~FILE_READ_DATA; + + status = cli_set_security_descriptor(cli, + fnum, + SECINFO_DACL, + sd_dacl); + + if (!NT_STATUS_IS_OK(status)) { + printf("Setting DACL on stream %s got (%s)\n", + sname, + nt_errstr(status)); + goto fail; + } + + TALLOC_FREE(sd_dacl); + + /* Read again and check it changed. */ + status = cli_query_security_descriptor(cli, + fnum, + SECINFO_DACL, + talloc_tos(), + &sd_dacl); + + if (!NT_STATUS_IS_OK(status)) { + printf("Reading DACL on stream %s got (%s)\n", + sname, + nt_errstr(status)); + goto fail; + } + + if (sd_dacl == NULL || sd_dacl->dacl == NULL || + sd_dacl->dacl->num_aces < 1) { + printf("Invalid DACL (1) returned on stream %s " + "(this should not happen)\n", + sname); + goto fail; + } + + /* FILE_READ_DATA should be gone from the first ace. */ + if ((sd_dacl->dacl->aces[0].access_mask & FILE_READ_DATA) != 0) { + printf("DACL on stream %s did not change\n", + sname); + goto fail; + } + + ret = true; + + fail: + + if (fnum != (uint16_t)-1) { + cli_smb2_close_fnum(cli, fnum); + fnum = (uint16_t)-1; + } + + (void)cli_unlink(cli, fname, 0); + return ret; +} + +static NTSTATUS list_fn(struct file_info *finfo, + const char *name, + void *state) +{ + bool *matched = (bool *)state; + if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) { + *matched = true; + } + return NT_STATUS_OK; +} + +/* + * Must be run against a share with "smbd async dosmode = yes". + * Checks we can return DOS attriutes other than "N". + * BUG: https://bugzilla.samba.org/show_bug.cgi?id=14758 + */ + +bool run_list_dir_async_test(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + const char *dname = "ASYNC_DIR"; + bool ret = false; + bool matched = false; + + printf("SMB2 list dir async\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + /* Ensure directory doesn't exist. */ + (void)cli_rmdir(cli, dname); + + status = cli_mkdir(cli, dname); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_mkdir %s returned %s\n", dname, nt_errstr(status)); + return false; + } + + status = cli_list(cli, + dname, + FILE_ATTRIBUTE_NORMAL|FILE_ATTRIBUTE_DIRECTORY, + list_fn, + &matched); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_list %s returned %s\n", dname, nt_errstr(status)); + goto fail; + } + + if (!matched) { + printf("Failed to find %s\n", dname); + goto fail; + } + + ret = true; + + fail: + + (void)cli_rmdir(cli, dname); + return ret; +} + +/* + * Test delete a directory fails if a file is created + * in a directory after the delete on close is set. + * BUG: https://bugzilla.samba.org/show_bug.cgi?id=14892 + */ + +bool run_delete_on_close_non_empty(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + const char *dname = "DEL_ON_CLOSE_DIR"; + const char *fname = "DEL_ON_CLOSE_DIR\\testfile"; + uint16_t fnum = (uint16_t)-1; + uint16_t fnum1 = (uint16_t)-1; + bool ret = false; + + printf("SMB2 delete on close nonempty\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + /* Ensure directory doesn't exist. */ + (void)cli_unlink(cli, + fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + (void)cli_rmdir(cli, dname); + + /* Create target directory. */ + status = cli_ntcreate(cli, + dname, + 0, + DELETE_ACCESS|FILE_READ_DATA, + FILE_ATTRIBUTE_DIRECTORY, + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_CREATE, + FILE_DIRECTORY_FILE, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ntcreate for directory %s returned %s\n", + dname, + nt_errstr(status)); + goto out; + } + + /* Now set the delete on close bit. */ + status = cli_nt_delete_on_close(cli, fnum, 1); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_cli_nt_delete_on_close set for directory " + "%s returned %s\n", + dname, + nt_errstr(status)); + goto out; + } + + /* Create file inside target directory. */ + /* + * NB. On Windows this will return NT_STATUS_DELETE_PENDING. Only on + * Samba will this succeed by default (the option "check parent + * directory delete on close" configures behaviour), but we're using + * this to test a race condition. + */ + status = cli_ntcreate(cli, + fname, + 0, + FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_CREATE, + 0, + 0, + &fnum1, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ntcreate for file %s returned %s\n", + fname, + nt_errstr(status)); + goto out; + } + cli_close(cli, fnum1); + fnum1 = (uint16_t)-1; + + /* Now the close should fail. */ + status = cli_close(cli, fnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) { + printf("cli_close for directory %s returned %s\n", + dname, + nt_errstr(status)); + goto out; + } + + ret = true; + + out: + + if (fnum1 != (uint16_t)-1) { + cli_close(cli, fnum1); + } + if (fnum != (uint16_t)-1) { + cli_nt_delete_on_close(cli, fnum, 0); + cli_close(cli, fnum); + } + (void)cli_unlink(cli, + fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + (void)cli_rmdir(cli, dname); + return ret; +} + +static NTSTATUS check_empty_fn(struct file_info *finfo, + const char *mask, + void *private_data) +{ + unsigned int *pcount = (unsigned int *)private_data; + + if (ISDOT(finfo->name) || ISDOTDOT(finfo->name)) { + (*pcount)++; + return NT_STATUS_OK; + } + return NT_STATUS_DIRECTORY_NOT_EMPTY; +} + +/* + * Test setting the delete on close bit on a directory + * containing an unwritable file fails or succeeds + * an a share set with "hide unwritable = yes" + * depending on the setting of "delete veto files". + * BUG: https://bugzilla.samba.org/show_bug.cgi?id=15023 + * + * First version. With "delete veto files = yes" + * setting the delete on close should succeed. + */ + +bool run_delete_on_close_nonwrite_delete_yes_test(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + const char *dname = "delete_veto_yes"; + const char *list_dname = "delete_veto_yes\\*"; + uint16_t fnum = (uint16_t)-1; + bool ret = false; + unsigned int list_count = 0; + + printf("SMB2 delete on close nonwrite - delete veto yes\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + /* Ensure target directory is seen as empty. */ + status = cli_list(cli, + list_dname, + FILE_ATTRIBUTE_DIRECTORY | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_SYSTEM, + check_empty_fn, + &list_count); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_list of %s returned %s\n", + dname, + nt_errstr(status)); + return false; + } + if (list_count != 2) { + printf("cli_list of %s returned a count of %u\n", + dname, + list_count); + return false; + } + + /* Open target directory. */ + status = cli_ntcreate(cli, + dname, + 0, + DELETE_ACCESS|FILE_READ_DATA, + FILE_ATTRIBUTE_DIRECTORY, + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, + FILE_DIRECTORY_FILE, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ntcreate for directory %s returned %s\n", + dname, + nt_errstr(status)); + goto out; + } + + /* Now set the delete on close bit. */ + status = cli_nt_delete_on_close(cli, fnum, 1); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_cli_nt_delete_on_close set for directory " + "%s returned %s (should have succeeded)\n", + dname, + nt_errstr(status)); + goto out; + } + + ret = true; + + out: + + if (fnum != (uint16_t)-1) { + (void)cli_nt_delete_on_close(cli, fnum, 0); + (void)cli_close(cli, fnum); + } + return ret; +} + +/* + * Test setting the delete on close bit on a directory + * containing an unwritable file fails or succeeds + * an a share set with "hide unwritable = yes" + * depending on the setting of "delete veto files". + * BUG: https://bugzilla.samba.org/show_bug.cgi?id=15023 + * + * Second version. With "delete veto files = no" + * setting the delete on close should fail. + */ + +bool run_delete_on_close_nonwrite_delete_no_test(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + const char *dname = "delete_veto_no"; + const char *list_dname = "delete_veto_no\\*"; + uint16_t fnum = (uint16_t)-1; + bool ret = false; + unsigned int list_count = 0; + + printf("SMB2 delete on close nonwrite - delete veto yes\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + /* Ensure target directory is seen as empty. */ + status = cli_list(cli, + list_dname, + FILE_ATTRIBUTE_DIRECTORY | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_SYSTEM, + check_empty_fn, + &list_count); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_list of %s returned %s\n", + dname, + nt_errstr(status)); + return false; + } + if (list_count != 2) { + printf("cli_list of %s returned a count of %u\n", + dname, + list_count); + return false; + } + + /* Open target directory. */ + status = cli_ntcreate(cli, + dname, + 0, + DELETE_ACCESS|FILE_READ_DATA, + FILE_ATTRIBUTE_DIRECTORY, + FILE_SHARE_READ| + FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, + FILE_DIRECTORY_FILE, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ntcreate for directory %s returned %s\n", + dname, + nt_errstr(status)); + goto out; + } + + /* Now set the delete on close bit. */ + status = cli_nt_delete_on_close(cli, fnum, 1); + if (NT_STATUS_IS_OK(status)) { + printf("cli_cli_nt_delete_on_close set for directory " + "%s returned NT_STATUS_OK " + "(should have failed)\n", + dname); + goto out; + } + if (!NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) { + printf("cli_cli_nt_delete_on_close set for directory " + "%s returned %s " + "(should have returned " + "NT_STATUS_DIRECTORY_NOT_EMPTY)\n", + dname, + nt_errstr(status)); + goto out; + } + + ret = true; + + out: + + if (fnum != (uint16_t)-1) { + (void)cli_nt_delete_on_close(cli, fnum, 0); + (void)cli_close(cli, fnum); + } + return ret; +} + +/* + * Open an SMB2 file readonly and return the inode number. + */ +static NTSTATUS get_smb2_inode(struct cli_state *cli, + const char *pathname, + uint64_t *ino_ret) +{ + NTSTATUS status; + uint64_t fid_persistent = 0; + uint64_t fid_volatile = 0; + DATA_BLOB outbuf = data_blob_null; + /* + * Open the file. + */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + pathname, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* struct symlink_reparse_struct */ + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + /* + * Get the inode. + */ + status = smb2cli_query_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_FILE, + (SMB_FILE_ALL_INFORMATION - 1000), /* in_file_info_class */ + 1024, /* in_max_output_length */ + NULL, /* in_input_buffer */ + 0, /* in_additional_info */ + 0, /* in_flags */ + fid_persistent, + fid_volatile, + talloc_tos(), + &outbuf); + + if (NT_STATUS_IS_OK(status)) { + *ino_ret = PULL_LE_U64(outbuf.data, 0x40); + } + + (void)smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, + fid_persistent, + fid_volatile); + return status; +} + +/* + * Check an inode matches a given SMB2 path. + */ +static bool smb2_inode_matches(struct cli_state *cli, + const char *match_pathname, + uint64_t ino_tomatch, + const char *test_pathname) +{ + uint64_t test_ino = 0; + NTSTATUS status; + + status = get_smb2_inode(cli, + test_pathname, + &test_ino); + if (!NT_STATUS_IS_OK(status)) { + printf("%s: Failed to get ino " + "number for %s, (%s)\n", + __func__, + test_pathname, + nt_errstr(status)); + return false; + } + if (test_ino != ino_tomatch) { + printf("%s: Inode mismatch, ino_tomatch (%s) " + "ino=%"PRIu64" test (%s) " + "ino=%"PRIu64"\n", + __func__, + match_pathname, + ino_tomatch, + test_pathname, + test_ino); + return false; + } + return true; +} + +/* + * Delete an SMB2 file on a DFS share. + */ +static NTSTATUS smb2_dfs_delete(struct cli_state *cli, + const char *pathname) +{ + NTSTATUS status; + uint64_t fid_persistent = 0; + uint64_t fid_volatile = 0; + uint8_t data[1]; + DATA_BLOB inbuf; + + /* + * Open the file. + */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + pathname, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* struct symlink_reparse_struct */ + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + /* + * Set delete on close. + */ + PUSH_LE_U8(&data[0], 0, 1); + inbuf.data = &data[0]; + inbuf.length = 1; + + status = smb2cli_set_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_FILE, /* info_type. */ + SMB_FILE_DISPOSITION_INFORMATION - 1000, /* info_class */ + &inbuf, + 0, /* additional_info. */ + fid_persistent, + fid_volatile); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + status = smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, + fid_persistent, + fid_volatile); + return status; +} + +/* + * Rename or hardlink an SMB2 file on a DFS share. + */ +static NTSTATUS smb2_dfs_setinfo_name(struct cli_state *cli, + uint64_t fid_persistent, + uint64_t fid_volatile, + const char *newname, + bool do_rename) +{ + NTSTATUS status; + DATA_BLOB inbuf; + smb_ucs2_t *converted_str = NULL; + size_t converted_size_bytes = 0; + size_t inbuf_size; + uint8_t info_class = 0; + bool ok; + + ok = push_ucs2_talloc(talloc_tos(), + &converted_str, + newname, + &converted_size_bytes); + if (!ok) { + return NT_STATUS_INVALID_PARAMETER; + } + /* + * W2K8 insists the dest name is not null terminated. Remove + * the last 2 zero bytes and reduce the name length. + */ + if (converted_size_bytes < 2) { + return NT_STATUS_INVALID_PARAMETER; + } + converted_size_bytes -= 2; + inbuf_size = 20 + converted_size_bytes; + if (inbuf_size < 20) { + /* Integer wrap check. */ + return NT_STATUS_INVALID_PARAMETER; + } + + /* + * The Windows 10 SMB2 server has a minimum length + * for a SMB2_FILE_RENAME_INFORMATION buffer of + * 24 bytes. It returns NT_STATUS_INFO_LENGTH_MISMATCH + * if the length is less. + */ + inbuf_size = MAX(inbuf_size, 24); + inbuf = data_blob_talloc_zero(talloc_tos(), inbuf_size); + if (inbuf.data == NULL) { + return NT_STATUS_NO_MEMORY; + } + PUSH_LE_U32(inbuf.data, 16, converted_size_bytes); + memcpy(inbuf.data + 20, converted_str, converted_size_bytes); + TALLOC_FREE(converted_str); + + if (do_rename == true) { + info_class = SMB_FILE_RENAME_INFORMATION - 1000; + } else { + /* Hardlink. */ + info_class = SMB_FILE_LINK_INFORMATION - 1000; + } + + status = smb2cli_set_info(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + SMB2_0_INFO_FILE, /* info_type. */ + info_class, /* info_class */ + &inbuf, + 0, /* additional_info. */ + fid_persistent, + fid_volatile); + return status; +} + +static NTSTATUS smb2_dfs_rename(struct cli_state *cli, + uint64_t fid_persistent, + uint64_t fid_volatile, + const char *newname) +{ + return smb2_dfs_setinfo_name(cli, + fid_persistent, + fid_volatile, + newname, + true); /* do_rename */ +} + +static NTSTATUS smb2_dfs_hlink(struct cli_state *cli, + uint64_t fid_persistent, + uint64_t fid_volatile, + const char *newname) +{ + return smb2_dfs_setinfo_name(cli, + fid_persistent, + fid_volatile, + newname, + false); /* do_rename */ +} + +/* + * According to: + + * https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-fscc/dc9978d7-6299-4c5a-a22d-a039cdc716ea + * + * (Characters " \ / [ ] : | < > + = ; , * ?, + * and control characters in range 0x00 through + * 0x1F, inclusive, are illegal in a share name) + * + * But Windows server only checks in DFS sharenames ':'. All other + * share names are allowed. + */ + +static bool test_smb2_dfs_sharenames(struct cli_state *cli, + const char *dfs_root_share_name, + uint64_t root_ino) +{ + char test_path[9]; + const char *test_str = "/[]:|<>+=;,*?"; + const char *p; + unsigned int i; + bool ino_matched = false; + + /* Setup template pathname. */ + memcpy(test_path, "SERVER\\X", 9); + + /* Test invalid control characters. */ + for (i = 1; i < 0x20; i++) { + test_path[7] = i; + ino_matched = smb2_inode_matches(cli, + dfs_root_share_name, + root_ino, + test_path); + if (!ino_matched) { + return false; + } + } + + /* Test explicit invalid characters. */ + for (p = test_str; *p != '\0'; p++) { + test_path[7] = *p; + if (*p == ':') { + /* + * Only ':' is treated as an INVALID sharename + * for a DFS SERVER\\SHARE path. + */ + uint64_t test_ino = 0; + NTSTATUS status = get_smb2_inode(cli, + test_path, + &test_ino); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_INVALID)) { + printf("%s:%d Open of %s should get " + "NT_STATUS_OBJECT_NAME_INVALID, got %s\n", + __FILE__, + __LINE__, + test_path, + nt_errstr(status)); + return false; + } + } else { + ino_matched = smb2_inode_matches(cli, + dfs_root_share_name, + root_ino, + test_path); + if (!ino_matched) { + return false; + } + } + } + return true; +} + +/* + * "Raw" test of SMB2 paths to a DFS share. + * We must use the lower level smb2cli_XXXX() interfaces, + * not the cli_XXX() ones here as the ultimate goal is to fix our + * cli_XXX() interfaces to work transparently over DFS. + * + * So here, we're testing the server code, not the client code. + * + * Passes cleanly against Windows. + */ + +bool run_smb2_dfs_paths(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + bool dfs_supported = false; + char *dfs_root_share_name = NULL; + uint64_t root_ino = 0; + uint64_t test_ino = 0; + bool ino_matched = false; + uint64_t fid_persistent = 0; + uint64_t fid_volatile = 0; + bool retval = false; + bool ok = false; + + printf("Starting SMB2-DFS-PATHS\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + /* Ensure this is a DFS share. */ + dfs_supported = smbXcli_conn_dfs_supported(cli->conn); + if (!dfs_supported) { + printf("Server %s does not support DFS\n", + smbXcli_conn_remote_name(cli->conn)); + return false; + } + dfs_supported = smbXcli_tcon_is_dfs_share(cli->smb2.tcon); + if (!dfs_supported) { + printf("Share %s does not support DFS\n", + cli->share); + return false; + } + /* + * Create the "official" DFS share root name. + * No SMB2 paths can start with '\\'. + */ + dfs_root_share_name = talloc_asprintf(talloc_tos(), + "%s\\%s", + smbXcli_conn_remote_name(cli->conn), + cli->share); + if (dfs_root_share_name == NULL) { + printf("Out of memory\n"); + return false; + } + + /* Get the share root inode number. */ + status = get_smb2_inode(cli, + dfs_root_share_name, + &root_ino); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Failed to get ino number for share root %s, (%s)\n", + __FILE__, + __LINE__, + dfs_root_share_name, + nt_errstr(status)); + return false; + } + + /* + * Test the Windows algorithm for parsing DFS names. + */ + /* + * A single "SERVER" element should open and match the share root. + */ + ino_matched = smb2_inode_matches(cli, + dfs_root_share_name, + root_ino, + smbXcli_conn_remote_name(cli->conn)); + if (!ino_matched) { + printf("%s:%d Failed to match ino number for %s\n", + __FILE__, + __LINE__, + smbXcli_conn_remote_name(cli->conn)); + return false; + } + + /* + * An "" DFS empty server name should open and match the share root on + * Windows 2008. Windows 2022 returns NT_STATUS_INVALID_PARAMETER + * for a DFS empty server name. + */ + status = get_smb2_inode(cli, + "", + &test_ino); + if (NT_STATUS_IS_OK(status)) { + /* + * Windows 2008 - open succeeded. Proceed to + * check ino number. + */ + ino_matched = smb2_inode_matches(cli, + dfs_root_share_name, + root_ino, + ""); + if (!ino_matched) { + printf("%s:%d Failed to match ino number for %s\n", + __FILE__, + __LINE__, + ""); + return false; + } + } + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { + /* + * For Windows 2022 we expect to fail with + * NT_STATUS_INVALID_PARAMETER. Anything else is + * unexpected. + */ + printf("%s:%d Unexpected error (%s) getting ino number for %s\n", + __FILE__, + __LINE__, + nt_errstr(status), + ""); + return false; + } + /* A "BAD" server name should open and match the share root. */ + ino_matched = smb2_inode_matches(cli, + dfs_root_share_name, + root_ino, + "BAD"); + if (!ino_matched) { + printf("%s:%d Failed to match ino number for %s\n", + __FILE__, + __LINE__, + "BAD"); + return false; + } + /* + * A "BAD\\BAD" server and share name should open + * and match the share root. + */ + ino_matched = smb2_inode_matches(cli, + dfs_root_share_name, + root_ino, + "BAD\\BAD"); + if (!ino_matched) { + printf("%s:%d Failed to match ino number for %s\n", + __FILE__, + __LINE__, + "BAD\\BAD"); + return false; + } + /* + * Trying to open "BAD\\BAD\\BAD" should get + * NT_STATUS_OBJECT_NAME_NOT_FOUND. + */ + status = get_smb2_inode(cli, + "BAD\\BAD\\BAD", + &test_ino); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + printf("%s:%d Open of %s should get " + "STATUS_OBJECT_NAME_NOT_FOUND, got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\BAD", + nt_errstr(status)); + return false; + } + /* + * Trying to open "BAD\\BAD\\BAD\\BAD" should get + * NT_STATUS_OBJECT_PATH_NOT_FOUND. + */ + status = get_smb2_inode(cli, + "BAD\\BAD\\BAD\\BAD", + &test_ino); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("%s:%d Open of %s should get " + "STATUS_OBJECT_NAME_NOT_FOUND, got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\BAD\\BAD", + nt_errstr(status)); + return false; + } + /* + * Test for invalid pathname characters in the servername. + * They are ignored, and it still opens the share root. + */ + ino_matched = smb2_inode_matches(cli, + dfs_root_share_name, + root_ino, + "::::"); + if (!ino_matched) { + printf("%s:%d Failed to match ino number for %s\n", + __FILE__, + __LINE__, + "::::"); + return false; + } + + /* + * Test for invalid pathname characters in the sharename. + * Invalid sharename characters should still be flagged as + * NT_STATUS_OBJECT_NAME_INVALID. It turns out only ':' + * is considered an invalid sharename character. + */ + ok = test_smb2_dfs_sharenames(cli, + dfs_root_share_name, + root_ino); + if (!ok) { + return false; + } + + /* Now create a file called "file". */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "BAD\\BAD\\file", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* struct symlink_reparse_struct */ + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb2cli_create on %s returned %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\file", + nt_errstr(status)); + return false; + } + + /* + * Trying to open "BAD\\BAD\\file" should now get + * a valid inode. + */ + status = get_smb2_inode(cli, + "BAD\\BAD\\file", + &test_ino); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Open of %s should succeed " + "got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\file", + nt_errstr(status)); + goto err; + } + + /* + * Now show that renames use relative, + * not full DFS paths. + */ + + /* Full DFS path should fail. */ + status = smb2_dfs_rename(cli, + fid_persistent, + fid_volatile, + "ANY\\NAME\\renamed_file"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("%s:%d Rename of %s -> %s should fail " + "with NT_STATUS_OBJECT_PATH_NOT_FOUND. Got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\file", + "ANY\\NAME\\renamed_file", + nt_errstr(status)); + goto err; + } + /* Relative DFS path should succeed. */ + status = smb2_dfs_rename(cli, + fid_persistent, + fid_volatile, + "renamed_file"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d: Rename of %s -> %s should succeed. " + "Got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\file", + "renamed_file", + nt_errstr(status)); + goto err; + } + + /* + * Trying to open "BAD\\BAD\\renamed_file" should now get + * a valid inode. + */ + status = get_smb2_inode(cli, + "BAD\\BAD\\renamed_file", + &test_ino); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d: Open of %s should succeed " + "got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\renamed_file", + nt_errstr(status)); + goto err; + } + + /* + * Now show that hard links use relative, + * not full DFS paths. + */ + + /* Full DFS path should fail. */ + status = smb2_dfs_hlink(cli, + fid_persistent, + fid_volatile, + "ANY\\NAME\\hlink"); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("%s:%d Hlink of %s -> %s should fail " + "with NT_STATUS_OBJECT_PATH_NOT_FOUND. Got %s\n", + __FILE__, + __LINE__, + "ANY\\NAME\\renamed_file", + "ANY\\NAME\\hlink", + nt_errstr(status)); + goto err; + } + /* Relative DFS path should succeed. */ + status = smb2_dfs_hlink(cli, + fid_persistent, + fid_volatile, + "hlink"); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d: Hlink of %s -> %s should succeed. " + "Got %s\n", + __FILE__, + __LINE__, + "ANY\\NAME\\renamed_file", + "hlink", + nt_errstr(status)); + goto err; + } + + /* + * Trying to open "BAD\\BAD\\hlink" should now get + * a valid inode. + */ + status = get_smb2_inode(cli, + "BAD\\BAD\\hlink", + &test_ino); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Open of %s should succeed " + "got %s\n", + __FILE__, + __LINE__, + "BAD\\BAD\\hlink", + nt_errstr(status)); + goto err; + } + + retval = true; + + err: + + if (fid_persistent != 0 || fid_volatile != 0) { + smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, /* flags */ + fid_persistent, + fid_volatile); + } + /* Delete anything we made. */ + (void)smb2_dfs_delete(cli, "BAD\\BAD\\BAD"); + (void)smb2_dfs_delete(cli, "BAD\\BAD\\file"); + (void)smb2_dfs_delete(cli, "BAD\\BAD\\renamed_file"); + (void)smb2_dfs_delete(cli, "BAD\\BAD\\hlink"); + return retval; +} + +/* + * Add a test that sends DFS paths and sets the + * SMB2 flag FLAGS2_DFS_PATHNAMES, but to a non-DFS + * share. Windows passes this (it just treats the + * pathnames as non-DFS and ignores the FLAGS2_DFS_PATHNAMES + * bit). + */ + +bool run_smb2_non_dfs_share(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + bool dfs_supported = false; + uint64_t fid_persistent = 0; + uint64_t fid_volatile = 0; + bool retval = false; + char *dfs_filename = NULL; + + printf("Starting SMB2-DFS-NON-DFS-SHARE\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + dfs_supported = smbXcli_conn_dfs_supported(cli->conn); + if (!dfs_supported) { + printf("Server %s does not support DFS\n", + smbXcli_conn_remote_name(cli->conn)); + return false; + } + /* Ensure this is *NOT* a DFS share. */ + dfs_supported = smbXcli_tcon_is_dfs_share(cli->smb2.tcon); + if (dfs_supported) { + printf("Share %s is a DFS share.\n", + cli->share); + return false; + } + /* + * Force the share to be DFS, as far as the client + * is concerned. + */ + smb2cli_tcon_set_values(cli->smb2.tcon, + cli->smb2.session, + smb2cli_tcon_current_id(cli->smb2.tcon), + 0, + smb2cli_tcon_flags(cli->smb2.tcon), + smb2cli_tcon_capabilities(cli->smb2.tcon) | + SMB2_SHARE_CAP_DFS, + 0); + + /* Come up with a "valid" SMB2 DFS name. */ + dfs_filename = talloc_asprintf(talloc_tos(), + "%s\\%s\\file", + smbXcli_conn_remote_name(cli->conn), + cli->share); + if (dfs_filename == NULL) { + printf("Out of memory\n"); + return false; + } + + /* Now try create dfs_filename. */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + dfs_filename, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs */ + NULL); /* struct symlink_reparse_struct */ + /* + * Should fail with NT_STATUS_OBJECT_PATH_NOT_FOUND, as + * even though we set the FLAGS2_DFS_PATHNAMES the server + * knows this isn't a DFS share and so treats BAD\\BAD as + * part of the filename. + */ + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("%s:%d create of %s should fail " + "with NT_STATUS_OBJECT_PATH_NOT_FOUND. Got %s\n", + __FILE__, + __LINE__, + dfs_filename, + nt_errstr(status)); + goto err; + } + /* + * Prove we can still use non-DFS pathnames, even though + * we are setting the FLAGS2_DFS_PATHNAMES in the SMB2 + * request. + */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "file", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* struct symlink_reparse_struct */ + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb2cli_create on %s returned %s\n", + __FILE__, + __LINE__, + "file", + nt_errstr(status)); + return false; + } + + retval = true; + + err: + + (void)smb2_dfs_delete(cli, dfs_filename); + (void)smb2_dfs_delete(cli, "file"); + return retval; +} + +/* + * Add a test that sends a non-DFS path and does not set the + * SMB2 flag FLAGS2_DFS_PATHNAMES to a DFS + * share. Windows passes this (it just treats the + * pathnames as non-DFS). + */ + +bool run_smb2_dfs_share_non_dfs_path(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + bool dfs_supported = false; + uint64_t fid_persistent = 0; + uint64_t fid_volatile = 0; + bool retval = false; + char *dfs_filename = NULL; + uint64_t root_ino = (uint64_t)-1; + bool ino_matched = false; + + printf("Starting SMB2-DFS-SHARE-NON-DFS-PATH\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + dfs_supported = smbXcli_conn_dfs_supported(cli->conn); + if (!dfs_supported) { + printf("Server %s does not support DFS\n", + smbXcli_conn_remote_name(cli->conn)); + return false; + } + /* Ensure this is a DFS share. */ + dfs_supported = smbXcli_tcon_is_dfs_share(cli->smb2.tcon); + if (!dfs_supported) { + printf("Share %s is not a DFS share.\n", + cli->share); + return false; + } + /* Come up with a "valid" SMB2 DFS name. */ + dfs_filename = talloc_asprintf(talloc_tos(), + "%s\\%s\\file", + smbXcli_conn_remote_name(cli->conn), + cli->share); + if (dfs_filename == NULL) { + printf("Out of memory\n"); + return false; + } + + /* Get the root of the share ino. */ + status = get_smb2_inode(cli, + "SERVER\\SHARE", + &root_ino); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d get_smb2_inode on %s returned %s\n", + __FILE__, + __LINE__, + "SERVER\\SHARE", + nt_errstr(status)); + goto err; + } + + /* Create a dfs_filename. */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + dfs_filename, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* psymlink */ + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb2cli_create on %s returned %s\n", + __FILE__, + __LINE__, + dfs_filename, + nt_errstr(status)); + goto err; + } + + /* Close the handle we just opened. */ + smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, /* flags */ + fid_persistent, + fid_volatile); + + fid_persistent = 0; + fid_volatile = 0; + + /* + * Force the share to be non-DFS, as far as the client + * is concerned. + */ + smb2cli_tcon_set_values(cli->smb2.tcon, + cli->smb2.session, + smb2cli_tcon_current_id(cli->smb2.tcon), + 0, + smb2cli_tcon_flags(cli->smb2.tcon), + smb2cli_tcon_capabilities(cli->smb2.tcon) & + ~SMB2_SHARE_CAP_DFS, + 0); + + /* + * Prove we can still use non-DFS pathnames on a DFS + * share so long as we don't set the FLAGS2_DFS_PATHNAMES + * in the SMB2 request. + */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "file", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* psymlink */ + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb2cli_create on %s returned %s\n", + __FILE__, + __LINE__, + "file", + nt_errstr(status)); + goto err; + } + + /* + * Show that now we're using non-DFS pathnames + * on a DFS share, "" opens the root of the share. + */ + ino_matched = smb2_inode_matches(cli, + "SERVER\\SHARE", + root_ino, + ""); + if (!ino_matched) { + printf("%s:%d Failed to match ino number for %s\n", + __FILE__, + __LINE__, + ""); + goto err; + } + + retval = true; + + err: + + if (fid_volatile != 0) { + smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, /* flags */ + fid_persistent, + fid_volatile); + } + (void)smb2_dfs_delete(cli, "file"); + (void)smb2_dfs_delete(cli, dfs_filename); + return retval; +} + +/* + * "Raw" test of an SMB2 filename with one or more leading + * backslash characters to a DFS share. + * + * BUG: https://bugzilla.samba.org/show_bug.cgi?id=15277 + * + * Once the server passes SMB2-DFS-PATHS we can + * fold this test into that one. + * + * Passes cleanly against Windows. + */ + +bool run_smb2_dfs_filename_leading_backslash(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + bool dfs_supported = false; + char *dfs_filename_slash = NULL; + char *dfs_filename_slash_multi = NULL; + uint64_t file_ino = 0; + bool ino_matched = false; + uint64_t fid_persistent = 0; + uint64_t fid_volatile = 0; + bool retval = false; + + printf("Starting SMB2-DFS-FILENAME-LEADING-BACKSLASH\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, share, "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + /* Ensure this is a DFS share. */ + dfs_supported = smbXcli_conn_dfs_supported(cli->conn); + if (!dfs_supported) { + printf("Server %s does not support DFS\n", + smbXcli_conn_remote_name(cli->conn)); + return false; + } + dfs_supported = smbXcli_tcon_is_dfs_share(cli->smb2.tcon); + if (!dfs_supported) { + printf("Share %s does not support DFS\n", + cli->share); + return false; + } + + /* + * Create the filename with one leading backslash. + */ + dfs_filename_slash = talloc_asprintf(talloc_tos(), + "\\%s\\%s\\file", + smbXcli_conn_remote_name(cli->conn), + cli->share); + if (dfs_filename_slash == NULL) { + printf("Out of memory\n"); + return false; + } + + /* + * Create the filename with many leading backslashes. + */ + dfs_filename_slash_multi = talloc_asprintf(talloc_tos(), + "\\\\\\\\%s\\%s\\file", + smbXcli_conn_remote_name(cli->conn), + cli->share); + if (dfs_filename_slash_multi == NULL) { + printf("Out of memory\n"); + return false; + } + + /* + * Trying to open "\\server\\share\\file" should get + * NT_STATUS_OBJECT_NAME_NOT_FOUND. + */ + status = get_smb2_inode(cli, + dfs_filename_slash, + &file_ino); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + printf("%s:%d Open of %s should get " + "STATUS_OBJECT_NAME_NOT_FOUND, got %s\n", + __FILE__, + __LINE__, + dfs_filename_slash, + nt_errstr(status)); + return false; + } + + /* Now create a file called "\\server\\share\\file". */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + dfs_filename_slash, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_STD_DELETE | + SEC_FILE_READ_DATA| + SEC_FILE_READ_ATTRIBUTE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* struct symlink_reparse_struct */ + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb2cli_create on %s returned %s\n", + __FILE__, + __LINE__, + dfs_filename_slash, + nt_errstr(status)); + return false; + } + + /* + * Trying to open "\\server\\share\\file" should now get + * a valid inode. + */ + status = get_smb2_inode(cli, + dfs_filename_slash, + &file_ino); + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d Open of %s should succeed " + "got %s\n", + __FILE__, + __LINE__, + dfs_filename_slash, + nt_errstr(status)); + goto err; + } + + /* + * Trying to open "\\\\\\server\\share\\file" should now get + * a valid inode that matches. MacOSX-style of DFS name test. + */ + ino_matched = smb2_inode_matches(cli, + dfs_filename_slash, + file_ino, + dfs_filename_slash_multi); + if (!ino_matched) { + printf("%s:%d Failed to match ino number for %s\n", + __FILE__, + __LINE__, + dfs_filename_slash_multi); + goto err; + } + + retval = true; + + err: + + if (fid_persistent != 0 || fid_volatile != 0) { + smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, /* flags */ + fid_persistent, + fid_volatile); + } + /* Delete anything we made. */ + (void)smb2_dfs_delete(cli, dfs_filename_slash); + return retval; +} + +/* + * Ensure a named pipe async read followed by a disconnect + * doesn't crash the server (server crash checked for in + * containing test script: + * source3/script/tests/test_smbtorture_nocrash_s3.sh) + * BUG: https://bugzilla.samba.org/show_bug.cgi?id=15423 + */ + +bool run_smb2_pipe_read_async_disconnect(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + uint64_t fid_persistent = 0; + uint64_t fid_volatile = 0; + struct tevent_context *ev; + struct tevent_req *req; + bool retval = false; + + printf("Starting SMB2-PIPE-READ-ASYNC-DISCONNECT\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect_creds(cli, "IPC$", "IPC", torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect to IPC$ returned %s\n", + nt_errstr(status)); + return false; + } + + /* Open the SAMR pipe. */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + "SAMR", + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_FILE_READ_DATA| + SEC_FILE_WRITE_DATA, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_OPEN, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* psymlink */ + if (!NT_STATUS_IS_OK(status)) { + printf("%s:%d smb2cli_create on SAMR returned %s\n", + __FILE__, + __LINE__, + nt_errstr(status)); + goto err; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + goto err; + } + + /* Start an async read. */ + req = smb2cli_read_send(talloc_tos(), + ev, + cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 16*1024, + 0, /* offset */ + fid_persistent, + fid_volatile, + 0, /* minimum_count */ + 0); /* remaining_bytes */ + if (req == NULL) { + goto err; + } + + /* Force disconnect. */ + smbXcli_conn_disconnect(cli->conn, NT_STATUS_LOCAL_DISCONNECT); + fid_volatile = 0; + retval = true; + + err: + + if (fid_volatile != 0) { + smb2cli_close(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + 0, /* flags */ + fid_persistent, + fid_volatile); + } + return retval; +} + +bool run_smb2_invalid_pipename(int dummy) +{ + struct cli_state *cli = NULL; + NTSTATUS status; + uint64_t fid_persistent = 0; + uint64_t fid_volatile = 0; + const char *unknown_pipe = "badpipe"; + const char *invalid_pipe = "../../../../../../../../../badpipe"; + + printf("Starting SMB2-INVALID-PIPENAME\n"); + + if (!torture_init_connection(&cli)) { + return false; + } + + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_SMB2_02, + PROTOCOL_SMB3_11, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("smbXcli_negprot returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_session_setup_creds(cli, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_session_setup returned %s\n", nt_errstr(status)); + return false; + } + + status = cli_tree_connect(cli, "IPC$", "?????", NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_tree_connect returned %s\n", nt_errstr(status)); + return false; + } + + /* Try and connect to an unknown pipename. */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + unknown_pipe, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_FILE_READ_DATA| + SEC_FILE_WRITE_DATA| + SEC_FILE_READ_ATTRIBUTE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* struct symlink_reparse_struct */ + /* We should get NT_STATUS_OBJECT_NAME_NOT_FOUND */ + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + printf("%s:%d smb2cli_create on name %s returned %s\n", + __FILE__, + __LINE__, + unknown_pipe, + nt_errstr(status)); + return false; + } + + /* Try and connect to an invalid pipename containing unix separators. */ + status = smb2cli_create(cli->conn, + cli->timeout, + cli->smb2.session, + cli->smb2.tcon, + invalid_pipe, + SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */ + SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */ + SEC_STD_SYNCHRONIZE| + SEC_FILE_READ_DATA| + SEC_FILE_WRITE_DATA| + SEC_FILE_READ_ATTRIBUTE, /* desired_access, */ + FILE_ATTRIBUTE_NORMAL, /* file_attributes, */ + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */ + FILE_CREATE, /* create_disposition, */ + 0, /* create_options, */ + NULL, /* smb2_create_blobs *blobs */ + &fid_persistent, + &fid_volatile, + NULL, /* struct smb_create_returns * */ + talloc_tos(), /* mem_ctx. */ + NULL, /* struct smb2_create_blobs * */ + NULL); /* struct symlink_reparse_struct */ + /* + * We should still get NT_STATUS_OBJECT_NAME_NOT_FOUND + * (tested against Windows 2022). + */ + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + printf("%s:%d smb2cli_create on name %s returned %s\n", + __FILE__, + __LINE__, + invalid_pipe, + nt_errstr(status)); + return false; + } + return true; +} diff --git a/source3/torture/test_smbsock_any_connect.c b/source3/torture/test_smbsock_any_connect.c new file mode 100644 index 0000000..a964e0f --- /dev/null +++ b/source3/torture/test_smbsock_any_connect.c @@ -0,0 +1,47 @@ +/* + Unix SMB/CIFS implementation. + Test the smb_any_connect functionality + Copyright (C) Volker Lendecke 2010 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "torture/proto.h" + +bool run_smb_any_connect(int dummy) +{ + int fd; + NTSTATUS status; + struct sockaddr_storage addrs[5]; + size_t chosen_index; + uint16_t port; + + interpret_string_addr(&addrs[0], "192.168.99.5", 0); + interpret_string_addr(&addrs[1], "192.168.99.6", 0); + interpret_string_addr(&addrs[2], "192.168.99.7", 0); + interpret_string_addr(&addrs[3], "192.168.99.8", 0); + interpret_string_addr(&addrs[4], "192.168.99.9", 0); + + status = smbsock_any_connect(addrs, NULL, NULL, NULL, NULL, + ARRAY_SIZE(addrs), 0, 0, + &fd, &chosen_index, &port); + + d_printf("smbsock_any_connect returned %s (fd %d)\n", + nt_errstr(status), NT_STATUS_IS_OK(status) ? fd : -1); + if (NT_STATUS_IS_OK(status)) { + close(fd); + } + return true; +} diff --git a/source3/torture/test_tdb_validate.c b/source3/torture/test_tdb_validate.c new file mode 100644 index 0000000..4768512 --- /dev/null +++ b/source3/torture/test_tdb_validate.c @@ -0,0 +1,68 @@ +/* + * Unix SMB/CIFS implementation. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "source3/include/includes.h" +#include +#include "source3/torture/proto.h" +#include "source3/lib/tdb_validate.h" + +static int validate_fn(struct tdb_context *tdb, TDB_DATA key, TDB_DATA value, + void *private_data) +{ + struct tdb_validation_status *state = private_data; + state->success = false; + printf("validate_fn called\n"); + return -1; +} + +bool run_tdb_validate(int dummy) +{ + const char tdb_name[] = "tdb_validate.tdb"; + bool result = false; + struct tdb_context *tdb = NULL; + char buf[] = "data"; + TDB_DATA data = { .dptr = (uint8_t *)buf, .dsize = sizeof(buf), }; + int ret; + + unlink(tdb_name); + + tdb = tdb_open(tdb_name, 0, 0, O_CREAT|O_EXCL|O_RDWR, 0600); + if (tdb == NULL) { + perror("Could not open tdb"); + goto done; + } + + ret = tdb_store(tdb, data, data, 0); + if (ret == -1) { + perror("tdb_store failed"); + goto done; + } + + ret = tdb_validate(tdb, validate_fn); + if (ret == 0) { + fprintf(stderr, + "tdb_validate succeeded where it should have " + "failed\n"); + goto done; + } + + result = true; +done: + tdb_close(tdb); + unlink(tdb_name); + return result; +} diff --git a/source3/torture/torture.c b/source3/torture/torture.c new file mode 100644 index 0000000..86a6e92 --- /dev/null +++ b/source3/torture/torture.c @@ -0,0 +1,16512 @@ +/* + Unix SMB/CIFS implementation. + SMB torture tester + Copyright (C) Andrew Tridgell 1997-1998 + Copyright (C) Jeremy Allison 2009 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "system/shmem.h" +#include "libsmb/namequery.h" +#include "wbc_async.h" +#include "torture/proto.h" +#include "libcli/security/security.h" +#include "tldap.h" +#include "tldap_util.h" +#include "tldap_gensec_bind.h" +#include "../librpc/gen_ndr/svcctl.h" +#include "../lib/util/memcache.h" +#include "nsswitch/winbind_client.h" +#include "dbwrap/dbwrap.h" +#include "dbwrap/dbwrap_open.h" +#include "dbwrap/dbwrap_rbt.h" +#include "async_smb.h" +#include "libsmb/libsmb.h" +#include "libsmb/clirap.h" +#include "trans2.h" +#include "libsmb/nmblib.h" +#include "../lib/util/tevent_ntstatus.h" +#include "util_tdb.h" +#include "../libcli/smb/read_smb.h" +#include "../libcli/smb/smbXcli_base.h" +#include "lib/util/sys_rw_data.h" +#include "lib/util/base64.h" +#include "lib/util/time.h" +#include "lib/gencache.h" +#include "lib/util/sys_rw.h" +#include "lib/util/asn1.h" +#include "lib/param/param.h" +#include "auth/gensec/gensec.h" +#include "lib/util/string_wrappers.h" +#include "source3/lib/substitute.h" + +#include +#include + +extern char *optarg; +extern int optind; + +fstring host, workgroup, share, password, username, myname; +struct cli_credentials *torture_creds; +static const char *sockops="TCP_NODELAY"; +int torture_nprocs=1; +static int port_to_use=0; +int torture_numops=100; +int torture_blocksize=1024*1024; +static int procnum; /* records process count number when forking */ +static struct cli_state *current_cli; +static fstring randomfname; +static bool use_oplocks; +static bool use_level_II_oplocks; +static const char *client_txt = "client_oplocks.txt"; +static bool disable_spnego; +static bool use_kerberos; +static bool force_dos_errors; +static fstring multishare_conn_fname; +static bool use_multishare_conn = False; +static bool do_encrypt; +static const char *local_path = NULL; +static enum smb_signing_setting signing_state = SMB_SIGNING_DEFAULT; +char *test_filename; + +bool torture_showall = False; + +static double create_procs(bool (*fn)(int), bool *result); + +/******************************************************************** + Ensure a connection is encrypted. +********************************************************************/ + +static bool force_cli_encryption(struct cli_state *c, + const char *sharename) +{ + uint16_t major, minor; + uint32_t caplow, caphigh; + NTSTATUS status; + + if (!SERVER_HAS_UNIX_CIFS(c)) { + d_printf("Encryption required and " + "server that doesn't support " + "UNIX extensions - failing connect\n"); + return false; + } + + status = cli_unix_extensions_version(c, &major, &minor, &caplow, + &caphigh); + if (!NT_STATUS_IS_OK(status)) { + d_printf("Encryption required and " + "can't get UNIX CIFS extensions " + "version from server: %s\n", nt_errstr(status)); + return false; + } + + if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) { + d_printf("Encryption required and " + "share %s doesn't support " + "encryption.\n", sharename); + return false; + } + + status = cli_smb1_setup_encryption(c, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + d_printf("Encryption required and " + "setup failed with error %s.\n", + nt_errstr(status)); + return false; + } + + return true; +} + + +static struct cli_state *open_nbt_connection(void) +{ + struct cli_state *c; + NTSTATUS status; + int flags = 0; + + if (disable_spnego) { + flags |= CLI_FULL_CONNECTION_DONT_SPNEGO; + } + + if (use_oplocks) { + flags |= CLI_FULL_CONNECTION_OPLOCKS; + } + + if (use_level_II_oplocks) { + flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS; + } + + if (force_dos_errors) { + flags |= CLI_FULL_CONNECTION_FORCE_DOS_ERRORS; + } + + status = cli_connect_nb(host, NULL, port_to_use, 0x20, myname, + signing_state, flags, &c); + if (!NT_STATUS_IS_OK(status)) { + printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) ); + return NULL; + } + + cli_set_timeout(c, 120000); /* set a really long timeout (2 minutes) */ + + return c; +} + +/**************************************************************************** + Send a corrupt session request. See rfc1002.txt 4.3 and 4.3.2. +****************************************************************************/ + +static bool cli_bad_session_request(int fd, + struct nmb_name *calling, struct nmb_name *called) +{ + TALLOC_CTX *frame; + uint8_t len_buf[4]; + struct iovec iov[3]; + ssize_t len; + uint8_t *inbuf; + int err; + bool ret = false; + uint8_t message_type; + uint8_t error; + struct tevent_context *ev; + struct tevent_req *req; + + frame = talloc_stackframe(); + + iov[0].iov_base = len_buf; + iov[0].iov_len = sizeof(len_buf); + + /* put in the destination name */ + + iov[1].iov_base = name_mangle(talloc_tos(), called->name, + called->name_type); + if (iov[1].iov_base == NULL) { + goto fail; + } + iov[1].iov_len = name_len((unsigned char *)iov[1].iov_base, + talloc_get_size(iov[1].iov_base)); + + /* and my name */ + + iov[2].iov_base = name_mangle(talloc_tos(), calling->name, + calling->name_type); + if (iov[2].iov_base == NULL) { + goto fail; + } + iov[2].iov_len = name_len((unsigned char *)iov[2].iov_base, + talloc_get_size(iov[2].iov_base)); + + /* Deliberately corrupt the name len (first byte) */ + *((uint8_t *)iov[2].iov_base) = 100; + + /* send a session request (RFC 1002) */ + /* setup the packet length + * Remove four bytes from the length count, since the length + * field in the NBT Session Service header counts the number + * of bytes which follow. The cli_send_smb() function knows + * about this and accounts for those four bytes. + * CRH. + */ + + _smb_setlen(len_buf, iov[1].iov_len + iov[2].iov_len); + SCVAL(len_buf,0,0x81); + + len = write_data_iov(fd, iov, 3); + if (len == -1) { + goto fail; + } + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + goto fail; + } + req = read_smb_send(frame, ev, fd); + if (req == NULL) { + goto fail; + } + if (!tevent_req_poll(req, ev)) { + goto fail; + } + len = read_smb_recv(req, talloc_tos(), &inbuf, &err); + if (len == -1) { + errno = err; + goto fail; + } + TALLOC_FREE(ev); + + message_type = CVAL(inbuf, 0); + if (message_type != 0x83) { + d_fprintf(stderr, "Expected msg type 0x83, got 0x%2.2x\n", + message_type); + goto fail; + } + + if (smb_len(inbuf) != 1) { + d_fprintf(stderr, "Expected smb_len 1, got %d\n", + (int)smb_len(inbuf)); + goto fail; + } + + error = CVAL(inbuf, 4); + if (error != 0x82) { + d_fprintf(stderr, "Expected error 0x82, got %d\n", + (int)error); + goto fail; + } + + ret = true; +fail: + TALLOC_FREE(frame); + return ret; +} + +/* Insert a NULL at the first separator of the given path and return a pointer + * to the remainder of the string. + */ +static char * +terminate_path_at_separator(char * path) +{ + char * p; + + if (!path) { + return NULL; + } + + if ((p = strchr_m(path, '/'))) { + *p = '\0'; + return p + 1; + } + + if ((p = strchr_m(path, '\\'))) { + *p = '\0'; + return p + 1; + } + + /* No separator. */ + return NULL; +} + +/* + parse a //server/share type UNC name +*/ +bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx, + char **hostname, char **sharename) +{ + char *p; + + *hostname = *sharename = NULL; + + if (strncmp(unc_name, "\\\\", 2) && + strncmp(unc_name, "//", 2)) { + return False; + } + + *hostname = talloc_strdup(mem_ctx, &unc_name[2]); + p = terminate_path_at_separator(*hostname); + + if (p && *p) { + *sharename = talloc_strdup(mem_ctx, p); + terminate_path_at_separator(*sharename); + } + + if (*hostname && *sharename) { + return True; + } + + TALLOC_FREE(*hostname); + TALLOC_FREE(*sharename); + return False; +} + +static bool torture_open_connection_share(struct cli_state **c, + const char *hostname, + const char *sharename, + int flags) +{ + NTSTATUS status; + + status = cli_full_connection_creds(c, + myname, + hostname, + NULL, /* dest_ss */ + port_to_use, + sharename, + "?????", + torture_creds, + flags); + if (!NT_STATUS_IS_OK(status)) { + printf("failed to open share connection: //%s/%s port:%d - %s\n", + hostname, sharename, port_to_use, nt_errstr(status)); + return False; + } + + cli_set_timeout(*c, 120000); /* set a really long timeout (2 minutes) */ + + if (do_encrypt) { + return force_cli_encryption(*c, + sharename); + } + return True; +} + +bool torture_open_connection_flags(struct cli_state **c, int conn_index, int flags) +{ + char **unc_list = NULL; + int num_unc_names = 0; + bool result; + + if (use_multishare_conn==True) { + char *h, *s; + unc_list = file_lines_load(multishare_conn_fname, &num_unc_names, 0, NULL); + if (!unc_list || num_unc_names <= 0) { + printf("Failed to load unc names list from '%s'\n", multishare_conn_fname); + exit(1); + } + + if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names], + NULL, &h, &s)) { + printf("Failed to parse UNC name %s\n", + unc_list[conn_index % num_unc_names]); + TALLOC_FREE(unc_list); + exit(1); + } + + result = torture_open_connection_share(c, h, s, flags); + + /* h, s were copied earlier */ + TALLOC_FREE(unc_list); + return result; + } + + return torture_open_connection_share(c, host, share, flags); +} + +bool torture_open_connection(struct cli_state **c, int conn_index) +{ + int flags = CLI_FULL_CONNECTION_FORCE_SMB1; + + if (use_oplocks) { + flags |= CLI_FULL_CONNECTION_OPLOCKS; + } + if (use_level_II_oplocks) { + flags |= CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS; + } + + return torture_open_connection_flags(c, conn_index, flags); +} + +bool torture_init_connection(struct cli_state **pcli) +{ + struct cli_state *cli; + + cli = open_nbt_connection(); + if (cli == NULL) { + return false; + } + + *pcli = cli; + return true; +} + +bool torture_cli_session_setup2(struct cli_state *cli, uint16_t *new_vuid) +{ + uint16_t old_vuid = cli_state_get_uid(cli); + NTSTATUS status; + bool ret; + + cli_state_set_uid(cli, 0); + status = cli_session_setup_creds(cli, torture_creds); + ret = NT_STATUS_IS_OK(status); + *new_vuid = cli_state_get_uid(cli); + cli_state_set_uid(cli, old_vuid); + return ret; +} + + +bool torture_close_connection(struct cli_state *c) +{ + bool ret = True; + NTSTATUS status; + + status = cli_tdis(c); + if (!NT_STATUS_IS_OK(status)) { + printf("tdis failed (%s)\n", nt_errstr(status)); + ret = False; + } + + cli_shutdown(c); + + return ret; +} + +void torture_conn_set_sockopt(struct cli_state *cli) +{ + smbXcli_conn_set_sockopt(cli->conn, sockops); +} + +static NTSTATUS torture_delete_fn(struct file_info *finfo, + const char *pattern, + void *state) +{ + NTSTATUS status; + char *filename = NULL; + char *dirname = NULL; + char *p = NULL; + TALLOC_CTX *frame = talloc_stackframe(); + struct cli_state *cli = (struct cli_state *)state; + + if (ISDOT(finfo->name) || ISDOTDOT(finfo->name)) { + TALLOC_FREE(frame); + return NT_STATUS_OK; + } + + dirname = talloc_strdup(frame, pattern); + if (dirname == NULL) { + TALLOC_FREE(frame); + return NT_STATUS_NO_MEMORY; + } + p = strrchr_m(dirname, '\\'); + if (p != NULL) { + /* Remove the terminating '\' */ + *p = '\0'; + } + if (dirname[0] != '\0') { + filename = talloc_asprintf(frame, + "%s\\%s", + dirname, + finfo->name); + } else { + filename = talloc_asprintf(frame, + "%s", + finfo->name); + } + if (filename == NULL) { + TALLOC_FREE(frame); + return NT_STATUS_NO_MEMORY; + } + if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) { + char *subdirname = talloc_asprintf(frame, + "%s\\*", + filename); + if (subdirname == NULL) { + TALLOC_FREE(frame); + return NT_STATUS_NO_MEMORY; + } + status = cli_list(cli, + subdirname, + FILE_ATTRIBUTE_DIRECTORY | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_SYSTEM, + torture_delete_fn, + cli); + if (!NT_STATUS_IS_OK(status)) { + printf("torture_delete_fn: cli_list " + "of %s failed (%s)\n", + subdirname, + nt_errstr(status)); + TALLOC_FREE(frame); + return status; + } + status = cli_rmdir(cli, filename); + } else { + status = cli_unlink(cli, + filename, + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN); + } + if (!NT_STATUS_IS_OK(status)) { + if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) { + printf("torture_delete_fn: cli_rmdir" + " of %s failed (%s)\n", + filename, + nt_errstr(status)); + } else { + printf("torture_delete_fn: cli_unlink" + " of %s failed (%s)\n", + filename, + nt_errstr(status)); + } + } + TALLOC_FREE(frame); + return status; +} + +void torture_deltree(struct cli_state *cli, const char *dname) +{ + char *mask = NULL; + NTSTATUS status; + + /* It might be a file */ + (void)cli_unlink(cli, + dname, + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN); + + mask = talloc_asprintf(cli, + "%s\\*", + dname); + if (mask == NULL) { + printf("torture_deltree: talloc_asprintf failed\n"); + return; + } + + status = cli_list(cli, + mask, + FILE_ATTRIBUTE_DIRECTORY | + FILE_ATTRIBUTE_HIDDEN| + FILE_ATTRIBUTE_SYSTEM, + torture_delete_fn, + cli); + if (!NT_STATUS_IS_OK(status)) { + printf("torture_deltree: cli_list of %s failed (%s)\n", + mask, + nt_errstr(status)); + } + TALLOC_FREE(mask); + status = cli_rmdir(cli, dname); + if (!NT_STATUS_IS_OK(status)) { + printf("torture_deltree: cli_rmdir of %s failed (%s)\n", + dname, + nt_errstr(status)); + } +} + +/* check if the server produced the expected dos or nt error code */ +static bool check_both_error(int line, NTSTATUS status, + uint8_t eclass, uint32_t ecode, NTSTATUS nterr) +{ + if (NT_STATUS_IS_DOS(status)) { + uint8_t cclass; + uint32_t num; + + /* Check DOS error */ + cclass = NT_STATUS_DOS_CLASS(status); + num = NT_STATUS_DOS_CODE(status); + + if (eclass != cclass || ecode != num) { + printf("unexpected error code class=%d code=%d\n", + (int)cclass, (int)num); + printf(" expected %d/%d %s (line=%d)\n", + (int)eclass, (int)ecode, nt_errstr(nterr), line); + return false; + } + } else { + /* Check NT error */ + if (!NT_STATUS_EQUAL(nterr, status)) { + printf("unexpected error code %s\n", + nt_errstr(status)); + printf(" expected %s (line=%d)\n", + nt_errstr(nterr), line); + return false; + } + } + + return true; +} + + +/* check if the server produced the expected error code */ +static bool check_error(int line, NTSTATUS status, + uint8_t eclass, uint32_t ecode, NTSTATUS nterr) +{ + if (NT_STATUS_IS_DOS(status)) { + uint8_t cclass; + uint32_t num; + + /* Check DOS error */ + + cclass = NT_STATUS_DOS_CLASS(status); + num = NT_STATUS_DOS_CODE(status); + + if (eclass != cclass || ecode != num) { + printf("unexpected error code class=%d code=%d\n", + (int)cclass, (int)num); + printf(" expected %d/%d %s (line=%d)\n", + (int)eclass, (int)ecode, nt_errstr(nterr), + line); + return False; + } + + } else { + /* Check NT error */ + + if (NT_STATUS_V(nterr) != NT_STATUS_V(status)) { + printf("unexpected error code %s\n", + nt_errstr(status)); + printf(" expected %s (line=%d)\n", nt_errstr(nterr), + line); + return False; + } + } + + return True; +} + +NTSTATUS cli_qpathinfo1(struct cli_state *cli, + const char *fname, + time_t *change_time, + time_t *access_time, + time_t *write_time, + off_t *size, + uint32_t *pattr) +{ + int timezone = smb1cli_conn_server_time_zone(cli->conn); + time_t (*date_fn)(const void *buf, int serverzone) = NULL; + uint8_t *rdata = NULL; + uint32_t num_rdata; + NTSTATUS status; + + status = cli_qpathinfo(talloc_tos(), + cli, + fname, + SMB_INFO_STANDARD, + 22, + CLI_BUFFER_SIZE, + &rdata, + &num_rdata); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + if (cli->win95) { + date_fn = make_unix_date; + } else { + date_fn = make_unix_date2; + } + + if (change_time) { + *change_time = date_fn(rdata + 0, timezone); + } + if (access_time) { + *access_time = date_fn(rdata + 4, timezone); + } + if (write_time) { + *write_time = date_fn(rdata + 8, timezone); + } + if (size) { + *size = PULL_LE_U32(rdata, 12); + } + if (pattr) { + *pattr = PULL_LE_U16(rdata, l1_attrFile); + } + return NT_STATUS_OK; +} + +static bool wait_lock(struct cli_state *c, int fnum, uint32_t offset, uint32_t len) +{ + NTSTATUS status; + + status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK); + + while (!NT_STATUS_IS_OK(status)) { + if (!check_both_error(__LINE__, status, ERRDOS, + ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) { + return false; + } + + status = cli_lock32(c, fnum, offset, len, -1, WRITE_LOCK); + } + + return true; +} + + +static bool rw_torture(struct cli_state *c) +{ + const char *lockfname = "\\torture.lck"; + fstring fname; + uint16_t fnum; + uint16_t fnum2; + pid_t pid2, pid = getpid(); + int i, j; + char buf[1024]; + bool correct = True; + size_t nread = 0; + NTSTATUS status; + + memset(buf, '\0', sizeof(buf)); + + status = cli_openx(c, lockfname, O_RDWR | O_CREAT | O_EXCL, + DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + status = cli_openx(c, lockfname, O_RDWR, DENY_NONE, &fnum2); + } + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", + lockfname, nt_errstr(status)); + return False; + } + + for (i=0;iconn, sockops); + + ret = rw_torture(cli); + + if (!torture_close_connection(cli)) { + ret = False; + } + + return ret; +} + +static bool rw_torture3(struct cli_state *c, char *lockfname) +{ + uint16_t fnum = (uint16_t)-1; + unsigned int i = 0; + char buf[131072]; + char buf_rd[131072]; + unsigned count; + unsigned countprev = 0; + size_t sent = 0; + bool correct = True; + NTSTATUS status = NT_STATUS_OK; + + srandom(1); + for (i = 0; i < sizeof(buf); i += sizeof(uint32_t)) + { + SIVAL(buf, i, sys_random()); + } + + if (procnum == 0) + { + status = cli_unlink( + c, lockfname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s) (normal, this file should " + "not exist)\n", nt_errstr(status)); + } + + status = cli_openx(c, lockfname, O_RDWR | O_CREAT | O_EXCL, + DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("first open read/write of %s failed (%s)\n", + lockfname, nt_errstr(status)); + return False; + } + } + else + { + for (i = 0; i < 500 && fnum == (uint16_t)-1; i++) + { + status = cli_openx(c, lockfname, O_RDONLY, + DENY_NONE, &fnum); + if (NT_STATUS_IS_OK(status)) { + break; + } + smb_msleep(10); + } + if (!NT_STATUS_IS_OK(status)) { + printf("second open read-only of %s failed (%s)\n", + lockfname, nt_errstr(status)); + return False; + } + } + + i = 0; + for (count = 0; count < sizeof(buf); count += sent) + { + if (count >= countprev) { + printf("%d %8d\r", i, count); + fflush(stdout); + i++; + countprev += (sizeof(buf) / 20); + } + + if (procnum == 0) + { + sent = ((unsigned)sys_random()%(20))+ 1; + if (sent > sizeof(buf) - count) + { + sent = sizeof(buf) - count; + } + + status = cli_writeall(c, fnum, 0, (uint8_t *)buf+count, + count, sent, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("write failed (%s)\n", + nt_errstr(status)); + correct = False; + } + } + else + { + status = cli_read(c, fnum, buf_rd+count, count, + sizeof(buf)-count, &sent); + if(!NT_STATUS_IS_OK(status)) { + printf("read failed offset:%d size:%ld (%s)\n", + count, (unsigned long)sizeof(buf)-count, + nt_errstr(status)); + correct = False; + sent = 0; + } else if (sent > 0) { + if (memcmp(buf_rd+count, buf+count, sent) != 0) + { + printf("read/write compare failed\n"); + printf("offset: %d req %ld recvd %ld\n", count, (unsigned long)sizeof(buf)-count, (unsigned long)sent); + correct = False; + break; + } + } + } + + } + + status = cli_close(c, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + correct = False; + } + + return correct; +} + +static bool rw_torture2(struct cli_state *c1, struct cli_state *c2) +{ + const char *lockfname = "\\torture2.lck"; + uint16_t fnum1; + uint16_t fnum2; + int i; + char buf[131072]; + char buf_rd[131072]; + bool correct = True; + size_t bytes_read; + NTSTATUS status; + + status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s) (normal, this file should not exist)\n", nt_errstr(status)); + } + + status = cli_openx(c1, lockfname, O_RDWR | O_CREAT | O_EXCL, + DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("first open read/write of %s failed (%s)\n", + lockfname, nt_errstr(status)); + return False; + } + + status = cli_openx(c2, lockfname, O_RDONLY, DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("second open read-only of %s failed (%s)\n", + lockfname, nt_errstr(status)); + cli_close(c1, fnum1); + return False; + } + + for (i = 0; i < torture_numops; i++) + { + size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1; + if (i % 10 == 0) { + printf("%d\r", i); fflush(stdout); + } + + generate_random_buffer((unsigned char *)buf, buf_size); + + status = cli_writeall(c1, fnum1, 0, (uint8_t *)buf, 0, + buf_size, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("write failed (%s)\n", nt_errstr(status)); + correct = False; + break; + } + + status = cli_read(c2, fnum2, buf_rd, 0, buf_size, &bytes_read); + if(!NT_STATUS_IS_OK(status)) { + printf("read failed (%s)\n", nt_errstr(status)); + correct = false; + break; + } else if (bytes_read != buf_size) { + printf("read failed\n"); + printf("read %ld, expected %ld\n", + (unsigned long)bytes_read, + (unsigned long)buf_size); + correct = False; + break; + } + + if (memcmp(buf_rd, buf, buf_size) != 0) + { + printf("read/write compare failed\n"); + correct = False; + break; + } + } + + status = cli_close(c2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + correct = False; + } + + status = cli_close(c1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + correct = False; + } + + status = cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + correct = False; + } + + return correct; +} + +static bool run_readwritetest(int dummy) +{ + struct cli_state *cli1, *cli2; + bool test1, test2 = False; + + if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) { + return False; + } + smbXcli_conn_set_sockopt(cli1->conn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + printf("starting readwritetest\n"); + + test1 = rw_torture2(cli1, cli2); + printf("Passed readwritetest v1: %s\n", BOOLSTR(test1)); + + if (test1) { + test2 = rw_torture2(cli1, cli1); + printf("Passed readwritetest v2: %s\n", BOOLSTR(test2)); + } + + if (!torture_close_connection(cli1)) { + test1 = False; + } + + if (!torture_close_connection(cli2)) { + test2 = False; + } + + return (test1 && test2); +} + +static bool run_readwritemulti(int dummy) +{ + struct cli_state *cli; + bool test; + + cli = current_cli; + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + printf("run_readwritemulti: fname %s\n", randomfname); + test = rw_torture3(cli, randomfname); + + if (!torture_close_connection(cli)) { + test = False; + } + + return test; +} + +static bool run_readwritelarge_internal(void) +{ + static struct cli_state *cli1; + uint16_t fnum1; + const char *lockfname = "\\large.dat"; + off_t fsize; + char buf[126*1024]; + bool correct = True; + NTSTATUS status; + + if (!torture_open_connection(&cli1, 0)) { + return False; + } + smbXcli_conn_set_sockopt(cli1->conn, sockops); + memset(buf,'\0',sizeof(buf)); + + printf("starting readwritelarge_internal\n"); + + cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, + DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status)); + return False; + } + + cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf), NULL); + + status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL, + NULL, NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("qfileinfo failed (%s)\n", nt_errstr(status)); + correct = False; + } + + if (fsize == sizeof(buf)) + printf("readwritelarge_internal test 1 succeeded (size = %lx)\n", + (unsigned long)fsize); + else { + printf("readwritelarge_internal test 1 failed (size = %lx)\n", + (unsigned long)fsize); + correct = False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + correct = False; + } + + status = cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + correct = False; + } + + status = cli_openx(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, + DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open read/write of %s failed (%s)\n", lockfname, nt_errstr(status)); + return False; + } + + cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf), NULL); + + status = cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL, + NULL, NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("qfileinfo failed (%s)\n", nt_errstr(status)); + correct = False; + } + + if (fsize == sizeof(buf)) + printf("readwritelarge_internal test 2 succeeded (size = %lx)\n", + (unsigned long)fsize); + else { + printf("readwritelarge_internal test 2 failed (size = %lx)\n", + (unsigned long)fsize); + correct = False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + correct = False; + } + + if (!torture_close_connection(cli1)) { + correct = False; + } + return correct; +} + +static bool run_readwritelarge(int dummy) +{ + return run_readwritelarge_internal(); +} + +static bool run_readwritelarge_signtest(int dummy) +{ + bool ret; + signing_state = SMB_SIGNING_REQUIRED; + ret = run_readwritelarge_internal(); + signing_state = SMB_SIGNING_DEFAULT; + return ret; +} + +int line_count = 0; +int nbio_id; + +#define ival(s) strtol(s, NULL, 0) + +/* run a test that simulates an approximate netbench client load */ +static bool run_netbench(int client) +{ + struct cli_state *cli; + int i; + char line[1024]; + char cname[20]; + FILE *f; + const char *params[20]; + bool correct = True; + + cli = current_cli; + + nbio_id = client; + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + nb_setup(cli); + + slprintf(cname,sizeof(cname)-1, "client%d", client); + + f = fopen(client_txt, "r"); + + if (!f) { + perror(client_txt); + return False; + } + + while (fgets(line, sizeof(line)-1, f)) { + char *saveptr; + line_count++; + + line[strlen(line)-1] = 0; + + /* printf("[%d] %s\n", line_count, line); */ + + all_string_sub(line,"client1", cname, sizeof(line)); + + /* parse the command parameters */ + params[0] = strtok_r(line, " ", &saveptr); + i = 0; + while (params[i]) params[++i] = strtok_r(NULL, " ", &saveptr); + + params[i] = ""; + + if (i < 2) continue; + + if (!strncmp(params[0],"SMB", 3)) { + printf("ERROR: You are using a dbench 1 load file\n"); + exit(1); + } + + if (!strcmp(params[0],"NTCreateX")) { + nb_createx(params[1], ival(params[2]), ival(params[3]), + ival(params[4])); + } else if (!strcmp(params[0],"Close")) { + nb_close(ival(params[1])); + } else if (!strcmp(params[0],"Rename")) { + nb_rename(params[1], params[2]); + } else if (!strcmp(params[0],"Unlink")) { + nb_unlink(params[1]); + } else if (!strcmp(params[0],"Deltree")) { + nb_deltree(params[1]); + } else if (!strcmp(params[0],"Rmdir")) { + nb_rmdir(params[1]); + } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) { + nb_qpathinfo(params[1]); + } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) { + nb_qfileinfo(ival(params[1])); + } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) { + nb_qfsinfo(ival(params[1])); + } else if (!strcmp(params[0],"FIND_FIRST")) { + nb_findfirst(params[1]); + } else if (!strcmp(params[0],"WriteX")) { + nb_writex(ival(params[1]), + ival(params[2]), ival(params[3]), ival(params[4])); + } else if (!strcmp(params[0],"ReadX")) { + nb_readx(ival(params[1]), + ival(params[2]), ival(params[3]), ival(params[4])); + } else if (!strcmp(params[0],"Flush")) { + nb_flush(ival(params[1])); + } else { + printf("Unknown operation %s\n", params[0]); + exit(1); + } + } + fclose(f); + + nb_cleanup(); + + if (!torture_close_connection(cli)) { + correct = False; + } + + return correct; +} + + +/* run a test that simulates an approximate netbench client load */ +static bool run_nbench(int dummy) +{ + double t; + bool correct = True; + + nbio_shmem(torture_nprocs); + + nbio_id = -1; + + signal(SIGALRM, nb_alarm); + alarm(1); + t = create_procs(run_netbench, &correct); + alarm(0); + + printf("\nThroughput %g MB/sec\n", + 1.0e-6 * nbio_total() / t); + return correct; +} + + +/* + This test checks for two things: + + 1) correct support for retaining locks over a close (ie. the server + must not use posix semantics) + 2) support for lock timeouts + */ +static bool run_locktest1(int dummy) +{ + struct cli_state *cli1, *cli2; + const char *fname = "\\lockt1.lck"; + uint16_t fnum1, fnum2, fnum3; + time_t t1, t2; + unsigned lock_timeout; + NTSTATUS status; + + if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) { + return False; + } + smbXcli_conn_set_sockopt(cli1->conn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + printf("starting locktest1\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, + &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("open2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum3); + if (!NT_STATUS_IS_OK(status)) { + printf("open3 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("lock1 failed (%s)\n", nt_errstr(status)); + return false; + } + + status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK); + if (NT_STATUS_IS_OK(status)) { + printf("lock2 succeeded! This is a locking bug\n"); + return false; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, ERRlock, + NT_STATUS_LOCK_NOT_GRANTED)) { + return false; + } + } + + lock_timeout = (1 + (random() % 20)); + printf("Testing lock timeout with timeout=%u\n", lock_timeout); + t1 = time(NULL); + status = cli_lock32(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK); + if (NT_STATUS_IS_OK(status)) { + printf("lock3 succeeded! This is a locking bug\n"); + return false; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, ERRlock, + NT_STATUS_FILE_LOCK_CONFLICT)) { + return false; + } + } + t2 = time(NULL); + + if (ABS(t2 - t1) < lock_timeout-1) { + printf("error: This server appears not to support timed lock requests\n"); + } + + printf("server slept for %u seconds for a %u second timeout\n", + (unsigned int)(t2-t1), lock_timeout); + + status = cli_close(cli1, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("close1 failed (%s)\n", nt_errstr(status)); + return False; + } + + status = cli_lock32(cli2, fnum3, 0, 4, 0, WRITE_LOCK); + if (NT_STATUS_IS_OK(status)) { + printf("lock4 succeeded! This is a locking bug\n"); + return false; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, ERRlock, + NT_STATUS_FILE_LOCK_CONFLICT)) { + return false; + } + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close2 failed (%s)\n", nt_errstr(status)); + return False; + } + + status = cli_close(cli2, fnum3); + if (!NT_STATUS_IS_OK(status)) { + printf("close3 failed (%s)\n", nt_errstr(status)); + return False; + } + + status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + return False; + } + + + if (!torture_close_connection(cli1)) { + return False; + } + + if (!torture_close_connection(cli2)) { + return False; + } + + printf("Passed locktest1\n"); + return True; +} + +/* + this checks to see if a secondary tconx can use open files from an + earlier tconx + */ +static bool run_tcon_test(int dummy) +{ + static struct cli_state *cli; + const char *fname = "\\tcontest.tmp"; + uint16_t fnum1; + uint32_t cnum1, cnum2, cnum3; + struct smbXcli_tcon *orig_tcon = NULL; + char *orig_share = NULL; + uint16_t vuid1, vuid2; + char buf[4]; + bool ret = True; + NTSTATUS status; + + memset(buf, '\0', sizeof(buf)); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + smbXcli_conn_set_sockopt(cli->conn, sockops); + + printf("starting tcontest\n"); + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + cnum1 = cli_state_get_tid(cli); + vuid1 = cli_state_get_uid(cli); + + status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("initial write failed (%s)", nt_errstr(status)); + return False; + } + + cli_state_save_tcon_share(cli, &orig_tcon, &orig_share); + + status = cli_tree_connect_creds(cli, share, "?????", torture_creds); + if (!NT_STATUS_IS_OK(status)) { + printf("%s refused 2nd tree connect (%s)\n", host, + nt_errstr(status)); + cli_state_restore_tcon_share(cli, orig_tcon, orig_share); + cli_shutdown(cli); + return False; + } + + cnum2 = cli_state_get_tid(cli); + cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */ + vuid2 = cli_state_get_uid(cli) + 1; + + /* try a write with the wrong tid */ + cli_state_set_tid(cli, cnum2); + + status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("* server allows write with wrong TID\n"); + ret = False; + } else { + printf("server fails write with wrong TID : %s\n", + nt_errstr(status)); + } + + + /* try a write with an invalid tid */ + cli_state_set_tid(cli, cnum3); + + status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("* server allows write with invalid TID\n"); + ret = False; + } else { + printf("server fails write with invalid TID : %s\n", + nt_errstr(status)); + } + + /* try a write with an invalid vuid */ + cli_state_set_uid(cli, vuid2); + cli_state_set_tid(cli, cnum1); + + status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("* server allows write with invalid VUID\n"); + ret = False; + } else { + printf("server fails write with invalid VUID : %s\n", + nt_errstr(status)); + } + + cli_state_set_tid(cli, cnum1); + cli_state_set_uid(cli, vuid1); + + status = cli_close(cli, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + cli_state_restore_tcon_share(cli, orig_tcon, orig_share); + cli_shutdown(cli); + return False; + } + + cli_state_set_tid(cli, cnum2); + + status = cli_tdis(cli); + if (!NT_STATUS_IS_OK(status)) { + printf("secondary tdis failed (%s)\n", nt_errstr(status)); + cli_state_restore_tcon_share(cli, orig_tcon, orig_share); + cli_shutdown(cli); + return False; + } + + cli_state_restore_tcon_share(cli, orig_tcon, orig_share); + + cli_state_set_tid(cli, cnum1); + + if (!torture_close_connection(cli)) { + return False; + } + + return ret; +} + + +/* + checks for old style tcon support + */ +static bool run_tcon2_test(int dummy) +{ + static struct cli_state *cli; + uint16_t cnum, max_xmit; + char *service; + NTSTATUS status; + + if (!torture_open_connection(&cli, 0)) { + return False; + } + smbXcli_conn_set_sockopt(cli->conn, sockops); + + printf("starting tcon2 test\n"); + + if (asprintf(&service, "\\\\%s\\%s", host, share) == -1) { + return false; + } + + status = cli_raw_tcon(cli, service, password, "?????", &max_xmit, &cnum); + + SAFE_FREE(service); + + if (!NT_STATUS_IS_OK(status)) { + printf("tcon2 failed : %s\n", nt_errstr(status)); + } else { + printf("tcon OK : max_xmit=%d cnum=%d\n", + (int)max_xmit, (int)cnum); + } + + if (!torture_close_connection(cli)) { + return False; + } + + printf("Passed tcon2 test\n"); + return True; +} + +static bool tcon_devtest(struct cli_state *cli, + const char *myshare, const char *devtype, + const char *return_devtype, + NTSTATUS expected_error) +{ + NTSTATUS status; + bool ret; + + status = cli_tree_connect_creds(cli, myshare, devtype, torture_creds); + + if (NT_STATUS_IS_OK(expected_error)) { + if (NT_STATUS_IS_OK(status)) { + if (return_devtype != NULL && + strequal(cli->dev, return_devtype)) { + ret = True; + } else { + printf("tconX to share %s with type %s " + "succeeded but returned the wrong " + "device type (got [%s] but should have got [%s])\n", + myshare, devtype, cli->dev, return_devtype); + ret = False; + } + } else { + printf("tconX to share %s with type %s " + "should have succeeded but failed\n", + myshare, devtype); + ret = False; + } + cli_tdis(cli); + } else { + if (NT_STATUS_IS_OK(status)) { + printf("tconx to share %s with type %s " + "should have failed but succeeded\n", + myshare, devtype); + ret = False; + } else { + if (NT_STATUS_EQUAL(status, expected_error)) { + ret = True; + } else { + printf("Returned unexpected error\n"); + ret = False; + } + } + } + return ret; +} + +/* + checks for correct tconX support + */ +static bool run_tcon_devtype_test(int dummy) +{ + static struct cli_state *cli1 = NULL; + int flags = CLI_FULL_CONNECTION_FORCE_SMB1; + NTSTATUS status; + bool ret = True; + + status = cli_full_connection_creds(&cli1, + myname, + host, + NULL, /* dest_ss */ + port_to_use, + NULL, /* service */ + NULL, /* service_type */ + torture_creds, + flags); + + if (!NT_STATUS_IS_OK(status)) { + printf("could not open connection\n"); + return False; + } + + if (!tcon_devtest(cli1, "IPC$", "A:", NULL, NT_STATUS_BAD_DEVICE_TYPE)) + ret = False; + + if (!tcon_devtest(cli1, "IPC$", "?????", "IPC", NT_STATUS_OK)) + ret = False; + + if (!tcon_devtest(cli1, "IPC$", "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE)) + ret = False; + + if (!tcon_devtest(cli1, "IPC$", "IPC", "IPC", NT_STATUS_OK)) + ret = False; + + if (!tcon_devtest(cli1, "IPC$", "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE)) + ret = False; + + if (!tcon_devtest(cli1, share, "A:", "A:", NT_STATUS_OK)) + ret = False; + + if (!tcon_devtest(cli1, share, "?????", "A:", NT_STATUS_OK)) + ret = False; + + if (!tcon_devtest(cli1, share, "LPT:", NULL, NT_STATUS_BAD_DEVICE_TYPE)) + ret = False; + + if (!tcon_devtest(cli1, share, "IPC", NULL, NT_STATUS_BAD_DEVICE_TYPE)) + ret = False; + + if (!tcon_devtest(cli1, share, "FOOBA", NULL, NT_STATUS_BAD_DEVICE_TYPE)) + ret = False; + + cli_shutdown(cli1); + + if (ret) + printf("Passed tcondevtest\n"); + + return ret; +} + + +/* + This test checks that + + 1) the server supports multiple locking contexts on the one SMB + connection, distinguished by PID. + + 2) the server correctly fails overlapping locks made by the same PID (this + goes against POSIX behaviour, which is why it is tricky to implement) + + 3) the server denies unlock requests by an incorrect client PID +*/ +static bool run_locktest2(int dummy) +{ + static struct cli_state *cli; + const char *fname = "\\lockt2.lck"; + uint16_t fnum1, fnum2, fnum3; + bool correct = True; + NTSTATUS status; + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + printf("starting locktest2\n"); + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + cli_setpid(cli, 1); + + status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_openx(cli, fname, O_RDWR, DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("open2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + cli_setpid(cli, 2); + + status = cli_openx(cli, fname, O_RDWR, DENY_NONE, &fnum3); + if (!NT_STATUS_IS_OK(status)) { + printf("open3 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + cli_setpid(cli, 1); + + status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("lock1 failed (%s)\n", nt_errstr(status)); + return false; + } + + status = cli_lock32(cli, fnum1, 0, 4, 0, WRITE_LOCK); + if (NT_STATUS_IS_OK(status)) { + printf("WRITE lock1 succeeded! This is a locking bug\n"); + correct = false; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, ERRlock, + NT_STATUS_LOCK_NOT_GRANTED)) { + return false; + } + } + + status = cli_lock32(cli, fnum2, 0, 4, 0, WRITE_LOCK); + if (NT_STATUS_IS_OK(status)) { + printf("WRITE lock2 succeeded! This is a locking bug\n"); + correct = false; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, ERRlock, + NT_STATUS_LOCK_NOT_GRANTED)) { + return false; + } + } + + status = cli_lock32(cli, fnum2, 0, 4, 0, READ_LOCK); + if (NT_STATUS_IS_OK(status)) { + printf("READ lock2 succeeded! This is a locking bug\n"); + correct = false; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, ERRlock, + NT_STATUS_FILE_LOCK_CONFLICT)) { + return false; + } + } + + status = cli_lock32(cli, fnum1, 100, 4, 0, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("lock at 100 failed (%s)\n", nt_errstr(status)); + } + cli_setpid(cli, 2); + if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) { + printf("unlock at 100 succeeded! This is a locking bug\n"); + correct = False; + } + + status = cli_unlock(cli, fnum1, 0, 4); + if (NT_STATUS_IS_OK(status)) { + printf("unlock1 succeeded! This is a locking bug\n"); + correct = false; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, ERRlock, + NT_STATUS_RANGE_NOT_LOCKED)) { + return false; + } + } + + status = cli_unlock(cli, fnum1, 0, 8); + if (NT_STATUS_IS_OK(status)) { + printf("unlock2 succeeded! This is a locking bug\n"); + correct = false; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, ERRlock, + NT_STATUS_RANGE_NOT_LOCKED)) { + return false; + } + } + + status = cli_lock32(cli, fnum3, 0, 4, 0, WRITE_LOCK); + if (NT_STATUS_IS_OK(status)) { + printf("lock3 succeeded! This is a locking bug\n"); + correct = false; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, ERRlock, + NT_STATUS_LOCK_NOT_GRANTED)) { + return false; + } + } + + cli_setpid(cli, 1); + + status = cli_close(cli, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close1 failed (%s)\n", nt_errstr(status)); + return False; + } + + status = cli_close(cli, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("close2 failed (%s)\n", nt_errstr(status)); + return False; + } + + status = cli_close(cli, fnum3); + if (!NT_STATUS_IS_OK(status)) { + printf("close3 failed (%s)\n", nt_errstr(status)); + return False; + } + + if (!torture_close_connection(cli)) { + correct = False; + } + + printf("locktest2 finished\n"); + + return correct; +} + + +/* + This test checks that + + 1) the server supports the full offset range in lock requests +*/ +static bool run_locktest3(int dummy) +{ + static struct cli_state *cli1, *cli2; + const char *fname = "\\lockt3.lck"; + uint16_t fnum1, fnum2; + int i; + uint32_t offset; + bool correct = True; + NTSTATUS status; + +#define NEXT_OFFSET offset += (~(uint32_t)0) / torture_numops + + if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) { + return False; + } + smbXcli_conn_set_sockopt(cli1->conn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + printf("starting locktest3\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, + &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("open2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + for (offset=i=0;iconn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + printf("starting locktest4\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1); + cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2); + + memset(buf, 0, sizeof(buf)); + + status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf), + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Failed to create file: %s\n", nt_errstr(status)); + correct = False; + goto fail; + } + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 2, 4, 0, WRITE_LOCK)); + EXPECTED(ret, False); + printf("the same process %s set overlapping write locks\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 10, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 12, 4, 0, READ_LOCK)); + EXPECTED(ret, True); + printf("the same process %s set overlapping read locks\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 20, 4, 0, WRITE_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 22, 4, 0, WRITE_LOCK)); + EXPECTED(ret, False); + printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 30, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 32, 4, 0, READ_LOCK)); + EXPECTED(ret, True); + printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot"); + + ret = (cli_setpid(cli1, 1), + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 40, 4, 0, WRITE_LOCK))) && + (cli_setpid(cli1, 2), + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 42, 4, 0, WRITE_LOCK))); + EXPECTED(ret, False); + printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot"); + + ret = (cli_setpid(cli1, 1), + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 50, 4, 0, READ_LOCK))) && + (cli_setpid(cli1, 2), + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 52, 4, 0, READ_LOCK))); + EXPECTED(ret, True); + printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 60, 4, 0, READ_LOCK)); + EXPECTED(ret, True); + printf("the same process %s set the same read lock twice\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 70, 4, 0, WRITE_LOCK)); + EXPECTED(ret, False); + printf("the same process %s set the same write lock twice\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 80, 4, 0, WRITE_LOCK)); + EXPECTED(ret, False); + printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, WRITE_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 90, 4, 0, READ_LOCK)); + EXPECTED(ret, True); + printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot"); + + ret = (cli_setpid(cli1, 1), + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, WRITE_LOCK))) && + (cli_setpid(cli1, 2), + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 100, 4, 0, READ_LOCK))); + EXPECTED(ret, False); + printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 110, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 112, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6)); + EXPECTED(ret, False); + printf("the same process %s coalesce read locks\n", ret?"can":"cannot"); + + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 120, 4, 0, WRITE_LOCK)) && + test_cli_read(cli2, fnum2, buf, 120, 4, NULL, 4); + EXPECTED(ret, False); + printf("this server %s strict write locking\n", ret?"doesn't do":"does"); + + status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK); + ret = NT_STATUS_IS_OK(status); + if (ret) { + status = cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, 130, 4, + NULL); + ret = NT_STATUS_IS_OK(status); + } + EXPECTED(ret, False); + printf("this server %s strict read locking\n", ret?"doesn't do":"does"); + + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 140, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)); + EXPECTED(ret, True); + printf("this server %s do recursive read locking\n", ret?"does":"doesn't"); + + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, WRITE_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 150, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) && + test_cli_read(cli2, fnum2, buf, 150, 4, NULL, 4) && + !(NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, + 150, 4, NULL))) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)); + EXPECTED(ret, True); + printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 160, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) && + NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, + 160, 4, NULL)) && + test_cli_read(cli2, fnum2, buf, 160, 4, NULL, 4); + EXPECTED(ret, True); + printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 170, 4, 0, WRITE_LOCK)) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) && + NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, + 170, 4, NULL)) && + test_cli_read(cli2, fnum2, buf, 170, 4, NULL, 4); + EXPECTED(ret, True); + printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot"); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, WRITE_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 190, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) && + !NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0, (uint8_t *)buf, + 190, 4, NULL)) && + test_cli_read(cli2, fnum2, buf, 190, 4, NULL, 4); + EXPECTED(ret, True); + printf("the same process %s remove the first lock first\n", ret?"does":"doesn't"); + + cli_close(cli1, fnum1); + cli_close(cli2, fnum2); + cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1); + cli_openx(cli1, fname, O_RDWR, DENY_NONE, &f); + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, f, 0, 1, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_close(cli1, fnum1)) && + NT_STATUS_IS_OK(cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK)); + cli_close(cli1, f); + cli_close(cli1, fnum1); + EXPECTED(ret, True); + printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't"); + + fail: + cli_close(cli1, fnum1); + cli_close(cli2, fnum2); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + torture_close_connection(cli1); + torture_close_connection(cli2); + + printf("finished locktest4\n"); + return correct; +} + +/* + looks at lock upgrade/downgrade. +*/ +static bool run_locktest5(int dummy) +{ + static struct cli_state *cli1, *cli2; + const char *fname = "\\lockt5.lck"; + uint16_t fnum1, fnum2, fnum3; + bool ret; + char buf[1000]; + bool correct = True; + NTSTATUS status; + + if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) { + return False; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + printf("starting locktest5\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1); + cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2); + cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum3); + + memset(buf, 0, sizeof(buf)); + + status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf), + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Failed to create file: %s\n", nt_errstr(status)); + correct = False; + goto fail; + } + + /* Check for NT bug... */ + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 8, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum3, 0, 1, 0, READ_LOCK)); + cli_close(cli1, fnum1); + cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1); + status = cli_lock32(cli1, fnum1, 7, 1, 0, WRITE_LOCK); + ret = NT_STATUS_IS_OK(status); + EXPECTED(ret, True); + printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has"); + cli_close(cli1, fnum1); + cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1); + cli_unlock(cli1, fnum3, 0, 1); + + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 1, 1, 0, READ_LOCK)); + EXPECTED(ret, True); + printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot"); + + status = cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK); + ret = NT_STATUS_IS_OK(status); + EXPECTED(ret, False); + + printf("a different process %s get a read lock on the first process lock stack\n", ret?"can":"cannot"); + + /* Unlock the process 2 lock. */ + cli_unlock(cli2, fnum2, 0, 4); + + status = cli_lock32(cli1, fnum3, 0, 4, 0, READ_LOCK); + ret = NT_STATUS_IS_OK(status); + EXPECTED(ret, False); + + printf("the same process on a different fnum %s get a read lock\n", ret?"can":"cannot"); + + /* Unlock the process 1 fnum3 lock. */ + cli_unlock(cli1, fnum3, 0, 4); + + /* Stack 2 more locks here. */ + ret = NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK)) && + NT_STATUS_IS_OK(cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK)); + + EXPECTED(ret, True); + printf("the same process %s stack read locks\n", ret?"can":"cannot"); + + /* Unlock the first process lock, then check this was the WRITE lock that was + removed. */ + + ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) && + NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK)); + + EXPECTED(ret, True); + printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ"); + + /* Unlock the process 2 lock. */ + cli_unlock(cli2, fnum2, 0, 4); + + /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */ + + ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) && + NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)); + + EXPECTED(ret, True); + printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot"); + + /* Ensure the next unlock fails. */ + ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)); + EXPECTED(ret, False); + printf("the same process %s count the lock stack\n", !ret?"can":"cannot"); + + /* Ensure connection 2 can get a write lock. */ + status = cli_lock32(cli2, fnum2, 0, 4, 0, WRITE_LOCK); + ret = NT_STATUS_IS_OK(status); + EXPECTED(ret, True); + + printf("a different process %s get a write lock on the unlocked stack\n", ret?"can":"cannot"); + + + fail: + cli_close(cli1, fnum1); + cli_close(cli2, fnum2); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!torture_close_connection(cli1)) { + correct = False; + } + if (!torture_close_connection(cli2)) { + correct = False; + } + + printf("finished locktest5\n"); + + return correct; +} + +/* + tries the unusual lockingX locktype bits +*/ +static bool run_locktest6(int dummy) +{ + static struct cli_state *cli; + const char *fname[1] = { "\\lock6.txt" }; + int i; + uint16_t fnum; + NTSTATUS status; + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + printf("starting locktest6\n"); + + for (i=0;i<1;i++) { + printf("Testing %s\n", fname[i]); + + cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + cli_openx(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); + status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE); + cli_close(cli, fnum); + printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status)); + + cli_openx(cli, fname[i], O_RDWR, DENY_NONE, &fnum); + status = cli_locktype(cli, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK); + cli_close(cli, fnum); + printf("CANCEL_LOCK gave %s\n", nt_errstr(status)); + + cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + } + + torture_close_connection(cli); + + printf("finished locktest6\n"); + return True; +} + +static bool run_locktest7(int dummy) +{ + struct cli_state *cli1; + const char *fname = "\\lockt7.lck"; + uint16_t fnum1; + char buf[200]; + bool correct = False; + size_t nread; + NTSTATUS status; + + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + printf("starting locktest7\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1); + + memset(buf, 0, sizeof(buf)); + + status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf), + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Failed to create file: %s\n", nt_errstr(status)); + goto fail; + } + + cli_setpid(cli1, 1); + + status = cli_lock32(cli1, fnum1, 130, 4, 0, READ_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("Unable to apply read lock on range 130:4, " + "error was %s\n", nt_errstr(status)); + goto fail; + } else { + printf("pid1 successfully locked range 130:4 for READ\n"); + } + + status = cli_read(cli1, fnum1, buf, 130, 4, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("pid1 unable to read the range 130:4, error was %s\n", + nt_errstr(status)); + goto fail; + } else if (nread != 4) { + printf("pid1 unable to read the range 130:4, " + "recv %ld req %d\n", (unsigned long)nread, 4); + goto fail; + } else { + printf("pid1 successfully read the range 130:4\n"); + } + + status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("pid1 unable to write to the range 130:4, error was " + "%s\n", nt_errstr(status)); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) { + printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n"); + goto fail; + } + } else { + printf("pid1 successfully wrote to the range 130:4 (should be denied)\n"); + goto fail; + } + + cli_setpid(cli1, 2); + + status = cli_read(cli1, fnum1, buf, 130, 4, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("pid2 unable to read the range 130:4, error was %s\n", + nt_errstr(status)); + goto fail; + } else if (nread != 4) { + printf("pid2 unable to read the range 130:4, " + "recv %ld req %d\n", (unsigned long)nread, 4); + goto fail; + } else { + printf("pid2 successfully read the range 130:4\n"); + } + + status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("pid2 unable to write to the range 130:4, error was " + "%s\n", nt_errstr(status)); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) { + printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n"); + goto fail; + } + } else { + printf("pid2 successfully wrote to the range 130:4 (should be denied)\n"); + goto fail; + } + + cli_setpid(cli1, 1); + cli_unlock(cli1, fnum1, 130, 4); + + status = cli_lock32(cli1, fnum1, 130, 4, 0, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("Unable to apply write lock on range 130:4, error was %s\n", nt_errstr(status)); + goto fail; + } else { + printf("pid1 successfully locked range 130:4 for WRITE\n"); + } + + status = cli_read(cli1, fnum1, buf, 130, 4, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("pid1 unable to read the range 130:4, error was %s\n", + nt_errstr(status)); + goto fail; + } else if (nread != 4) { + printf("pid1 unable to read the range 130:4, " + "recv %ld req %d\n", (unsigned long)nread, 4); + goto fail; + } else { + printf("pid1 successfully read the range 130:4\n"); + } + + status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("pid1 unable to write to the range 130:4, error was " + "%s\n", nt_errstr(status)); + goto fail; + } else { + printf("pid1 successfully wrote to the range 130:4\n"); + } + + cli_setpid(cli1, 2); + + status = cli_read(cli1, fnum1, buf, 130, 4, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("pid2 unable to read the range 130:4, error was " + "%s\n", nt_errstr(status)); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) { + printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n"); + goto fail; + } + } else { + printf("pid2 successfully read the range 130:4 (should be denied) recv %ld\n", + (unsigned long)nread); + goto fail; + } + + status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 130, 4, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("pid2 unable to write to the range 130:4, error was " + "%s\n", nt_errstr(status)); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) { + printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)\n"); + goto fail; + } + } else { + printf("pid2 successfully wrote to the range 130:4 (should be denied)\n"); + goto fail; + } + + cli_unlock(cli1, fnum1, 130, 0); + correct = True; + +fail: + cli_close(cli1, fnum1); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + torture_close_connection(cli1); + + printf("finished locktest7\n"); + return correct; +} + +/* + * This demonstrates a problem with our use of GPFS share modes: A file + * descriptor sitting in the pending close queue holding a GPFS share mode + * blocks opening a file another time. Happens with Word 2007 temp files. + * With "posix locking = yes" and "gpfs:sharemodes = yes" enabled, the third + * open is denied with NT_STATUS_SHARING_VIOLATION. + */ + +static bool run_locktest8(int dummy) +{ + struct cli_state *cli1; + const char *fname = "\\lockt8.lck"; + uint16_t fnum1, fnum2; + char buf[200]; + bool correct = False; + NTSTATUS status; + + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + printf("starting locktest8\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE, + &fnum1); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status)); + return false; + } + + memset(buf, 0, sizeof(buf)); + + status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_openx second time returned %s\n", + nt_errstr(status)); + goto fail; + } + + status = cli_lock32(cli1, fnum2, 1, 1, 0, READ_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("Unable to apply read lock on range 1:1, error was " + "%s\n", nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status)); + goto fail; + } + + status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_openx third time returned %s\n", + nt_errstr(status)); + goto fail; + } + + correct = true; + +fail: + cli_close(cli1, fnum1); + cli_close(cli1, fnum2); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + torture_close_connection(cli1); + + printf("finished locktest8\n"); + return correct; +} + +/* + * This test is designed to be run in conjunction with + * external NFS or POSIX locks taken in the filesystem. + * It checks that the smbd server will block until the + * lock is released and then acquire it. JRA. + */ + +static bool got_alarm; +static struct cli_state *alarm_cli; + +static void alarm_handler(int dummy) +{ + got_alarm = True; +} + +static void alarm_handler_parent(int dummy) +{ + smbXcli_conn_disconnect(alarm_cli->conn, NT_STATUS_LOCAL_DISCONNECT); +} + +static void do_local_lock(const char *fname, int read_fd, int write_fd) +{ + int fd; + char c = '\0'; + struct flock lock; + const char *local_pathname = NULL; + int ret; + + local_pathname = talloc_asprintf(talloc_tos(), + "%s/%s", local_path, fname); + if (!local_pathname) { + printf("child: alloc fail\n"); + exit(1); + } + + unlink(local_pathname); + fd = open(local_pathname, O_RDWR|O_CREAT, 0666); + if (fd == -1) { + printf("child: open of %s failed %s.\n", + local_pathname, strerror(errno)); + exit(1); + } + + /* Now take a fcntl lock. */ + lock.l_type = F_WRLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0; + lock.l_len = 4; + lock.l_pid = getpid(); + + ret = fcntl(fd,F_SETLK,&lock); + if (ret == -1) { + printf("child: failed to get lock 0:4 on file %s. Error %s\n", + local_pathname, strerror(errno)); + exit(1); + } else { + printf("child: got lock 0:4 on file %s.\n", + local_pathname ); + fflush(stdout); + } + + CatchSignal(SIGALRM, alarm_handler); + alarm(5); + /* Signal the parent. */ + if (write(write_fd, &c, 1) != 1) { + printf("child: start signal fail %s.\n", + strerror(errno)); + exit(1); + } + alarm(0); + + alarm(10); + /* Wait for the parent to be ready. */ + if (read(read_fd, &c, 1) != 1) { + printf("child: reply signal fail %s.\n", + strerror(errno)); + exit(1); + } + alarm(0); + + sleep(5); + close(fd); + printf("child: released lock 0:4 on file %s.\n", + local_pathname ); + fflush(stdout); + exit(0); +} + +static bool _run_locktest9X(const char *fname, int timeout) +{ + struct cli_state *cli1; + char *fpath = talloc_asprintf(talloc_tos(), "\\%s", fname); + uint16_t fnum; + bool correct = False; + int pipe_in[2], pipe_out[2]; + pid_t child_pid; + char c = '\0'; + int ret; + struct timeval start; + double seconds; + NTSTATUS status; + + printf("starting locktest9X: %s\n", fname); + + if (local_path == NULL) { + d_fprintf(stderr, "locktest9X must be given a local path via -l \n"); + return false; + } + + if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) { + return false; + } + + child_pid = fork(); + if (child_pid == -1) { + return false; + } + + if (child_pid == 0) { + /* Child. */ + do_local_lock(fname, pipe_out[0], pipe_in[1]); + exit(0); + } + + close(pipe_out[0]); + close(pipe_in[1]); + pipe_out[0] = -1; + pipe_in[1] = -1; + + /* Parent. */ + ret = read(pipe_in[0], &c, 1); + if (ret != 1) { + d_fprintf(stderr, "failed to read start signal from child. %s\n", + strerror(errno)); + return false; + } + + if (!torture_open_connection(&cli1, 0)) { + return false; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + status = cli_openx(cli1, fpath, O_RDWR, DENY_NONE, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status)); + return false; + } + + /* Ensure the child has the lock. */ + status = cli_lock32(cli1, fnum, 0, 4, 0, WRITE_LOCK); + if (NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n"); + goto fail; + } else { + d_printf("Child has the lock.\n"); + } + + /* Tell the child to wait 5 seconds then exit. */ + ret = write(pipe_out[1], &c, 1); + if (ret != 1) { + d_fprintf(stderr, "failed to send exit signal to child. %s\n", + strerror(errno)); + goto fail; + } + + /* Wait 20 seconds for the lock. */ + alarm_cli = cli1; + CatchSignal(SIGALRM, alarm_handler_parent); + alarm(20); + + start = timeval_current(); + + status = cli_lock32(cli1, fnum, 0, 4, timeout, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was " + "%s\n", nt_errstr(status)); + goto fail_nofd; + } + alarm(0); + + seconds = timeval_elapsed(&start); + + printf("Parent got the lock after %.2f seconds.\n", + seconds); + + status = cli_close(cli1, fnum); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status)); + goto fail; + } + + correct = true; + +fail: + cli_close(cli1, fnum); + torture_close_connection(cli1); + +fail_nofd: + + printf("finished locktest9X: %s\n", fname); + return correct; +} + +static bool run_locktest9a(int dummy) +{ + return _run_locktest9X("lock9a.dat", -1); +} + +static bool run_locktest9b(int dummy) +{ + return _run_locktest9X("lock9b.dat", 10000); +} + +struct locktest10_state { + bool ok; + bool done; +}; + +static void locktest10_lockingx_done(struct tevent_req *subreq); +static void locktest10_read_andx_done(struct tevent_req *subreq); + +static bool run_locktest10(int dummy) +{ + struct tevent_context *ev = NULL; + struct cli_state *cli1 = NULL; + struct cli_state *cli2 = NULL; + struct smb1_lock_element lck = { 0 }; + struct tevent_req *reqs[2] = { NULL }; + struct tevent_req *smbreqs[2] = { NULL }; + const char fname[] = "\\lockt10.lck"; + uint16_t fnum1, fnum2; + bool ret = false; + bool ok; + uint8_t data = 1; + struct locktest10_state state = { .ok = true }; + NTSTATUS status; + + printf("starting locktest10\n"); + + ev = samba_tevent_context_init(NULL); + if (ev == NULL) { + d_fprintf(stderr, "samba_tevent_context_init failed\n"); + goto done; + } + + ok = torture_open_connection(&cli1, 0); + if (!ok) { + goto done; + } + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + ok = torture_open_connection(&cli2, 1); + if (!ok) { + goto done; + } + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + status = cli_openx(cli1, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_openx failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = cli_writeall(cli1, fnum1, 0, &data, 0, sizeof(data), NULL); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_writeall failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = cli_openx(cli2, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_openx failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = cli_locktype( + cli2, fnum2, 0, 1, 0, LOCKING_ANDX_EXCLUSIVE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_locktype failed: %s\n", + nt_errstr(status)); + goto done; + } + + lck = (struct smb1_lock_element) { + .pid = cli_getpid(cli1), .offset = 0, .length = 1, + }; + + reqs[0] = cli_lockingx_create( + ev, /* mem_ctx */ + ev, /* tevent_context */ + cli1, /* cli */ + fnum1, /* fnum */ + LOCKING_ANDX_EXCLUSIVE_LOCK, /* typeoflock */ + 0, /* newoplocklevel */ + 1, /* timeout */ + 0, /* num_unlocks */ + NULL, /* unlocks */ + 1, /* num_locks */ + &lck, /* locks */ + &smbreqs[0]); /* psmbreq */ + if (reqs[0] == NULL) { + d_fprintf(stderr, "cli_lockingx_create failed\n"); + goto done; + } + tevent_req_set_callback(reqs[0], locktest10_lockingx_done, &state); + + reqs[1] = cli_read_andx_create( + ev, /* mem_ctx */ + ev, /* ev */ + cli1, /* cli */ + fnum1, /* fnum */ + 0, /* offset */ + 1, /* size */ + &smbreqs[1]); /* psmbreq */ + if (reqs[1] == NULL) { + d_fprintf(stderr, "cli_read_andx_create failed\n"); + goto done; + } + tevent_req_set_callback(reqs[1], locktest10_read_andx_done, &state); + + status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs)); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "smb1cli_req_chain_submit failed: %s\n", + nt_errstr(status)); + goto done; + } + + while (!state.done) { + tevent_loop_once(ev); + } + + torture_close_connection(cli1); + + if (state.ok) { + ret = true; + } +done: + return ret; +} + +static void locktest10_lockingx_done(struct tevent_req *subreq) +{ + struct locktest10_state *state = tevent_req_callback_data_void(subreq); + NTSTATUS status; + + status = cli_lockingx_recv(subreq); + TALLOC_FREE(subreq); + + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) { + d_printf("cli_lockingx returned %s\n", nt_errstr(status)); + state->ok = false; + } +} + +static void locktest10_read_andx_done(struct tevent_req *subreq) +{ + struct locktest10_state *state = tevent_req_callback_data_void(subreq); + ssize_t received = -1; + uint8_t *rcvbuf = NULL; + NTSTATUS status; + + status = cli_read_andx_recv(subreq, &received, &rcvbuf); + + if (!NT_STATUS_EQUAL(status, NT_STATUS_REQUEST_ABORTED)) { + d_printf("cli_read_andx returned %s\n", nt_errstr(status)); + state->ok = false; + } + + state->done = true; + TALLOC_FREE(subreq); +} + +static bool run_locktest11(int dummy) +{ + struct cli_state *cli1; + const char *fname = "\\lockt11.lck"; + NTSTATUS status; + uint16_t fnum; + bool ret = false; + + if (!torture_open_connection(&cli1, 0)) { + return false; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli1, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_openx returned %s\n", + nt_errstr(status)); + return false; + } + + /* + * Test that LOCKING_ANDX_CANCEL_LOCK without any locks + * returns NT_STATUS_OK + */ + + status = cli_lockingx( + cli1, /* cli */ + fnum, /* fnum */ + LOCKING_ANDX_CANCEL_LOCK, /* typeoflock */ + 0, /* newoplocklevel */ + 0, /* timeout */ + 0, /* num_unlocks */ + NULL, /* unlocks */ + 0, /* num_locks */ + NULL); /* locks */ + + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_lockingX returned %s\n", nt_errstr(status)); + goto fail; + } + + ret = true; +fail: + cli_close(cli1, fnum); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + return ret; +} + +struct deferred_close_state { + struct tevent_context *ev; + struct cli_state *cli; + uint16_t fnum; +}; + +static void deferred_close_waited(struct tevent_req *subreq); +static void deferred_close_done(struct tevent_req *subreq); + +static struct tevent_req *deferred_close_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + int wait_secs, + struct cli_state *cli, + uint16_t fnum) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct deferred_close_state *state = NULL; + struct timeval wakeup_time = timeval_current_ofs(wait_secs, 0); + + req = tevent_req_create( + mem_ctx, &state, struct deferred_close_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + state->fnum = fnum; + + subreq = tevent_wakeup_send(state, state->ev, wakeup_time); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, deferred_close_waited, req); + return req; +} + +static void deferred_close_waited(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct deferred_close_state *state = tevent_req_data( + req, struct deferred_close_state); + bool ok; + + ok = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (!ok) { + tevent_req_oom(req); + return; + } + + subreq = cli_close_send(state, state->ev, state->cli, state->fnum, 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, deferred_close_done, req); +} + +static void deferred_close_done(struct tevent_req *subreq) +{ + NTSTATUS status = cli_close_recv(subreq); + tevent_req_simple_finish_ntstatus(subreq, status); +} + +static NTSTATUS deferred_close_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +struct lockread_state { + struct smb1_lock_element lck; + struct tevent_req *reqs[2]; + struct tevent_req *smbreqs[2]; + NTSTATUS lock_status; + NTSTATUS read_status; + uint8_t *readbuf; +}; + +static void lockread_lockingx_done(struct tevent_req *subreq); +static void lockread_read_andx_done(struct tevent_req *subreq); + +static struct tevent_req *lockread_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + uint16_t fnum) +{ + struct tevent_req *req = NULL; + struct lockread_state *state = NULL; + NTSTATUS status; + + req = tevent_req_create(mem_ctx, &state, struct lockread_state); + if (req == NULL) { + return NULL; + } + + state->lck = (struct smb1_lock_element) { + .pid = cli_getpid(cli), .offset = 0, .length = 1, + }; + + state->reqs[0] = cli_lockingx_create( + ev, /* mem_ctx */ + ev, /* tevent_context */ + cli, /* cli */ + fnum, /* fnum */ + LOCKING_ANDX_EXCLUSIVE_LOCK, /* typeoflock */ + 0, /* newoplocklevel */ + 10000, /* timeout */ + 0, /* num_unlocks */ + NULL, /* unlocks */ + 1, /* num_locks */ + &state->lck, /* locks */ + &state->smbreqs[0]); /* psmbreq */ + if (tevent_req_nomem(state->reqs[0], req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback( + state->reqs[0], lockread_lockingx_done, req); + + state->reqs[1] = cli_read_andx_create( + ev, /* mem_ctx */ + ev, /* ev */ + cli, /* cli */ + fnum, /* fnum */ + 0, /* offset */ + 1, /* size */ + &state->smbreqs[1]); /* psmbreq */ + if (tevent_req_nomem(state->reqs[1], req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback( + state->reqs[1], lockread_read_andx_done, req); + + status = smb1cli_req_chain_submit(state->smbreqs, 2); + if (tevent_req_nterror(req, status)) { + return tevent_req_post(req, ev); + } + return req; +} + +static void lockread_lockingx_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct lockread_state *state = tevent_req_data( + req, struct lockread_state); + state->lock_status = cli_lockingx_recv(subreq); + TALLOC_FREE(subreq); + d_fprintf(stderr, + "lockingx returned %s\n", + nt_errstr(state->lock_status)); +} + +static void lockread_read_andx_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct lockread_state *state = tevent_req_data( + req, struct lockread_state); + ssize_t received = -1; + uint8_t *rcvbuf = NULL; + + state->read_status = cli_read_andx_recv(subreq, &received, &rcvbuf); + + d_fprintf(stderr, + "read returned %s\n", + nt_errstr(state->read_status)); + + if (!NT_STATUS_IS_OK(state->read_status)) { + TALLOC_FREE(subreq); + tevent_req_done(req); + return; + } + + if (received > 0) { + state->readbuf = talloc_memdup(state, rcvbuf, received); + TALLOC_FREE(subreq); + if (tevent_req_nomem(state->readbuf, req)) { + return; + } + } + TALLOC_FREE(subreq); + tevent_req_done(req); +} + +static NTSTATUS lockread_recv( + struct tevent_req *req, + NTSTATUS *lock_status, + NTSTATUS *read_status, + TALLOC_CTX *mem_ctx, + uint8_t **read_buf) +{ + struct lockread_state *state = tevent_req_data( + req, struct lockread_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + return status; + } + + *lock_status = state->lock_status; + *read_status = state->read_status; + if (state->readbuf != NULL) { + *read_buf = talloc_move(mem_ctx, &state->readbuf); + } else { + *read_buf = NULL; + } + + return NT_STATUS_OK; +} + +struct lock12_state { + uint8_t dummy; +}; + +static void lock12_closed(struct tevent_req *subreq); +static void lock12_read(struct tevent_req *subreq); + +static struct tevent_req *lock12_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + uint16_t fnum1, + uint16_t fnum2) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct lock12_state *state = NULL; + + req = tevent_req_create(mem_ctx, &state, struct lock12_state); + if (req == NULL) { + return NULL; + } + + subreq = deferred_close_send(state, ev, 1, cli, fnum1); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, lock12_closed, req); + + subreq = lockread_send(state, ev, cli, fnum2); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, lock12_read, req); + + return req; +} + +static void lock12_closed(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + + status = deferred_close_recv(subreq); + TALLOC_FREE(subreq); + DBG_DEBUG("close returned %s\n", nt_errstr(status)); + if (tevent_req_nterror(req, status)) { + return; + } +} + +static void lock12_read(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct lock12_state *state = tevent_req_data( + req, struct lock12_state); + NTSTATUS status, lock_status, read_status; + uint8_t *buf = NULL; + + status = lockread_recv( + subreq, &lock_status, &read_status, state, &buf); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status) || + tevent_req_nterror(req, lock_status) || + tevent_req_nterror(req, read_status)) { + return; + } + tevent_req_done(req); +} + +static NTSTATUS lock12_recv(struct tevent_req *req) + +{ + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + return status; + } + return NT_STATUS_OK; +} + +static bool run_locktest12(int dummy) +{ + struct tevent_context *ev = NULL; + struct tevent_req *req = NULL; + struct cli_state *cli = NULL; + const char fname[] = "\\lockt12.lck"; + uint16_t fnum1, fnum2; + bool ret = false; + bool ok; + uint8_t data = 1; + NTSTATUS status; + + printf("starting locktest12\n"); + + ev = samba_tevent_context_init(NULL); + if (ev == NULL) { + d_fprintf(stderr, "samba_tevent_context_init failed\n"); + goto done; + } + + ok = torture_open_connection(&cli, 0); + if (!ok) { + goto done; + } + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = cli_openx(cli, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_openx failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = cli_openx(cli, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_openx failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = cli_writeall(cli, fnum1, 0, &data, 0, sizeof(data), NULL); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_writeall failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = cli_locktype( + cli, fnum1, 0, 1, 0, LOCKING_ANDX_EXCLUSIVE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_locktype failed: %s\n", + nt_errstr(status)); + goto done; + } + + req = lock12_send(ev, ev, cli, fnum1, fnum2); + if (req == NULL) { + d_fprintf(stderr, "lock12_send failed\n"); + goto done; + } + + ok = tevent_req_poll_ntstatus(req, ev, &status); + if (!ok) { + d_fprintf(stderr, "tevent_req_poll_ntstatus failed\n"); + goto done; + } + + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "tevent_req_poll_ntstatus returned %s\n", + nt_errstr(status)); + goto done; + } + + status = lock12_recv(req); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "lock12 returned %s\n", nt_errstr(status)); + goto done; + } + + ret = true; +done: + if (cli != NULL) { + torture_close_connection(cli); + } + return ret; +} + +struct lock_ntcancel_state { + struct timeval start; + struct smb1_lock_element lck; + struct tevent_req *subreq; +}; + +static void lock_ntcancel_waited(struct tevent_req *subreq); +static void lock_ntcancel_done(struct tevent_req *subreq); + +static struct tevent_req *lock_ntcancel_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + uint16_t fnum) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct lock_ntcancel_state *state = NULL; + + req = tevent_req_create(mem_ctx, &state, struct lock_ntcancel_state); + if (req == NULL) { + return NULL; + } + state->lck = (struct smb1_lock_element) { + .pid = cli_getpid(cli), .offset = 0, .length = 1, + }; + state->start = timeval_current(); + + state->subreq = cli_lockingx_send( + state, /* mem_ctx */ + ev, /* tevent_context */ + cli, /* cli */ + fnum, /* fnum */ + LOCKING_ANDX_EXCLUSIVE_LOCK, /* typeoflock */ + 0, /* newoplocklevel */ + 10000, /* timeout */ + 0, /* num_unlocks */ + NULL, /* unlocks */ + 1, /* num_locks */ + &state->lck); /* locks */ + if (tevent_req_nomem(state->subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(state->subreq, lock_ntcancel_done, req); + + subreq = tevent_wakeup_send(state, ev, timeval_current_ofs(1, 0)); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, lock_ntcancel_waited, req); + return req; +} + +static void lock_ntcancel_waited(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct lock_ntcancel_state *state = tevent_req_data( + req, struct lock_ntcancel_state); + bool ok; + + ok = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (!ok) { + tevent_req_oom(req); + return; + } + + ok = tevent_req_cancel(state->subreq); + if (!ok) { + d_fprintf(stderr, "Could not cancel subreq\n"); + tevent_req_oom(req); + return; + } +} + +static void lock_ntcancel_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct lock_ntcancel_state *state = tevent_req_data( + req, struct lock_ntcancel_state); + NTSTATUS status; + double elapsed; + + status = cli_lockingx_recv(subreq); + TALLOC_FREE(subreq); + + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) { + d_printf("cli_lockingx returned %s\n", nt_errstr(status)); + tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL); + return; + } + + elapsed = timeval_elapsed(&state->start); + + if (elapsed > 3) { + d_printf("cli_lockingx was too slow, cancel did not work\n"); + tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL); + return; + } + + tevent_req_done(req); +} + +static NTSTATUS lock_ntcancel_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static bool run_locktest13(int dummy) +{ + struct tevent_context *ev = NULL; + struct tevent_req *req = NULL; + struct cli_state *cli = NULL; + const char fname[] = "\\lockt13.lck"; + uint16_t fnum1, fnum2; + bool ret = false; + bool ok; + uint8_t data = 1; + NTSTATUS status; + + printf("starting locktest13\n"); + + ev = samba_tevent_context_init(NULL); + if (ev == NULL) { + d_fprintf(stderr, "samba_tevent_context_init failed\n"); + goto done; + } + + ok = torture_open_connection(&cli, 0); + if (!ok) { + goto done; + } + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = cli_openx(cli, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_openx failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = cli_openx(cli, fname, O_CREAT|O_RDWR, DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_openx failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = cli_writeall(cli, fnum1, 0, &data, 0, sizeof(data), NULL); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_writeall failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = cli_locktype( + cli, fnum1, 0, 1, 0, LOCKING_ANDX_EXCLUSIVE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_locktype failed: %s\n", + nt_errstr(status)); + goto done; + } + + req = lock_ntcancel_send(ev, ev, cli, fnum2); + if (req == NULL) { + d_fprintf(stderr, "lock_ntcancel_send failed\n"); + goto done; + } + + ok = tevent_req_poll_ntstatus(req, ev, &status); + if (!ok) { + d_fprintf(stderr, "tevent_req_poll_ntstatus failed\n"); + goto done; + } + + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "tevent_req_poll_ntstatus returned %s\n", + nt_errstr(status)); + goto done; + } + + status = lock_ntcancel_recv(req); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "lock_ntcancel returned %s\n", + nt_errstr(status)); + goto done; + } + + ret = true; +done: + if (cli != NULL) { + torture_close_connection(cli); + } + return ret; +} + +/* +test whether fnums and tids open on one VC are available on another (a major +security hole) +*/ +static bool run_fdpasstest(int dummy) +{ + struct cli_state *cli1, *cli2; + const char *fname = "\\fdpass.tst"; + uint16_t fnum1; + char buf[1024]; + NTSTATUS status; + + if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) { + return False; + } + smbXcli_conn_set_sockopt(cli1->conn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + printf("starting fdpasstest\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, + &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"hello world\n", 0, + 13, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("write failed (%s)\n", nt_errstr(status)); + return False; + } + + cli_state_set_uid(cli2, cli_state_get_uid(cli1)); + cli_state_set_tid(cli2, cli_state_get_tid(cli1)); + cli_setpid(cli2, cli_getpid(cli1)); + + if (test_cli_read(cli2, fnum1, buf, 0, 13, NULL, 13)) { + printf("read succeeded! nasty security hole [%s]\n", buf); + return false; + } + + cli_close(cli1, fnum1); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + torture_close_connection(cli1); + torture_close_connection(cli2); + + printf("finished fdpasstest\n"); + return True; +} + +static bool run_fdsesstest(int dummy) +{ + struct cli_state *cli; + uint16_t new_vuid; + uint16_t saved_vuid; + uint32_t new_cnum; + uint32_t saved_cnum; + const char *fname = "\\fdsess.tst"; + const char *fname1 = "\\fdsess1.tst"; + uint16_t fnum1; + uint16_t fnum2; + char buf[1024]; + bool ret = True; + NTSTATUS status; + + if (!torture_open_connection(&cli, 0)) + return False; + smbXcli_conn_set_sockopt(cli->conn, sockops); + + if (!torture_cli_session_setup2(cli, &new_vuid)) + return False; + + saved_cnum = cli_state_get_tid(cli); + if (!NT_STATUS_IS_OK(cli_tree_connect(cli, share, "?????", NULL))) + return False; + new_cnum = cli_state_get_tid(cli); + cli_state_set_tid(cli, saved_cnum); + + printf("starting fdsesstest\n"); + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_writeall(cli, fnum1, 0, (const uint8_t *)"hello world\n", 0, 13, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("write failed (%s)\n", nt_errstr(status)); + return False; + } + + saved_vuid = cli_state_get_uid(cli); + cli_state_set_uid(cli, new_vuid); + + if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) { + printf("read succeeded with different vuid! " + "nasty security hole [%s]\n", buf); + ret = false; + } + /* Try to open a file with different vuid, samba cnum. */ + if (NT_STATUS_IS_OK(cli_openx(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) { + printf("create with different vuid, same cnum succeeded.\n"); + cli_close(cli, fnum2); + cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + } else { + printf("create with different vuid, same cnum failed.\n"); + printf("This will cause problems with service clients.\n"); + ret = False; + } + + cli_state_set_uid(cli, saved_vuid); + + /* Try with same vuid, different cnum. */ + cli_state_set_tid(cli, new_cnum); + + if (test_cli_read(cli, fnum1, buf, 0, 13, NULL, 13)) { + printf("read succeeded with different cnum![%s]\n", buf); + ret = false; + } + + cli_state_set_tid(cli, saved_cnum); + cli_close(cli, fnum1); + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + torture_close_connection(cli); + + printf("finished fdsesstest\n"); + return ret; +} + +/* + This test checks that + + 1) the server does not allow an unlink on a file that is open +*/ +static bool run_unlinktest(int dummy) +{ + struct cli_state *cli; + const char *fname = "\\unlink.tst"; + uint16_t fnum; + bool correct = True; + NTSTATUS status; + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + printf("starting unlink test\n"); + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + cli_setpid(cli, 1); + + status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_unlink(cli, fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (NT_STATUS_IS_OK(status)) { + printf("error: server allowed unlink on an open file\n"); + correct = False; + } else { + correct = check_error(__LINE__, status, ERRDOS, ERRbadshare, + NT_STATUS_SHARING_VIOLATION); + } + + cli_close(cli, fnum); + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + if (!torture_close_connection(cli)) { + correct = False; + } + + printf("unlink test finished\n"); + + return correct; +} + + +/* +test how many open files this server supports on the one socket +*/ +static bool run_maxfidtest(int dummy) +{ + struct cli_state *cli; + fstring fname; + uint16_t fnums[0x11000]; + int i; + int retries=4; + bool correct = True; + NTSTATUS status; + + cli = current_cli; + + if (retries <= 0) { + printf("failed to connect\n"); + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + for (i=0; i<0x11000; i++) { + slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid()); + status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, + &fnums[i]); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", + fname, nt_errstr(status)); + printf("maximum fnum is %d\n", i); + break; + } + printf("%6d\r", i); + } + printf("%6d\n", i); + i--; + + printf("cleaning up\n"); + for (;i>=0;i--) { + slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid()); + cli_close(cli, fnums[i]); + + status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink of %s failed (%s)\n", + fname, nt_errstr(status)); + correct = False; + } + printf("%6d\r", i); + } + printf("%6d\n", 0); + + printf("maxfid test finished\n"); + if (!torture_close_connection(cli)) { + correct = False; + } + return correct; +} + +/* generate a random buffer */ +static void rand_buf(char *buf, int len) +{ + while (len--) { + *buf = (char)sys_random(); + buf++; + } +} + +/* send smb negprot commands, not reading the response */ +static bool run_negprot_nowait(int dummy) +{ + struct tevent_context *ev; + int i; + struct cli_state *cli; + bool correct = True; + + printf("starting negprot nowait test\n"); + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + return false; + } + + if (!(cli = open_nbt_connection())) { + TALLOC_FREE(ev); + return False; + } + + for (i=0;i<50000;i++) { + struct tevent_req *req; + + req = smbXcli_negprot_send( + ev, + ev, + cli->conn, + cli->timeout, + PROTOCOL_CORE, + PROTOCOL_NT1, + 0, + NULL); + if (req == NULL) { + TALLOC_FREE(ev); + return false; + } + if (!tevent_req_poll(req, ev)) { + d_fprintf(stderr, "tevent_req_poll failed: %s\n", + strerror(errno)); + TALLOC_FREE(ev); + return false; + } + TALLOC_FREE(req); + } + + if (torture_close_connection(cli)) { + correct = False; + } + + printf("finished negprot nowait test\n"); + + return correct; +} + +/* send smb negprot commands, not reading the response */ +static bool run_bad_nbt_session(int dummy) +{ + struct nmb_name called, calling; + struct sockaddr_storage ss; + NTSTATUS status; + int fd; + bool ret; + + printf("starting bad nbt session test\n"); + + make_nmb_name(&calling, myname, 0x0); + make_nmb_name(&called , host, 0x20); + + if (!resolve_name(host, &ss, 0x20, true)) { + d_fprintf(stderr, "Could not resolve name %s\n", host); + return false; + } + + status = open_socket_out(&ss, NBT_SMB_PORT, 10000, &fd); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "open_socket_out failed: %s\n", + nt_errstr(status)); + return false; + } + + ret = cli_bad_session_request(fd, &calling, &called); + close(fd); + if (!ret) { + d_fprintf(stderr, "open_socket_out failed: %s\n", + nt_errstr(status)); + return false; + } + + printf("finished bad nbt session test\n"); + return true; +} + +/* send random IPC commands */ +static bool run_randomipc(int dummy) +{ + char *rparam = NULL; + char *rdata = NULL; + unsigned int rdrcnt,rprcnt; + char param[1024]; + int api, param_len, i; + struct cli_state *cli; + bool correct = True; + int count = 50000; + + printf("starting random ipc test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + for (i=0;iserver_domain, + SV_TYPE_DOMAIN_ENUM, + browse_callback, NULL); + + printf("machine list:\n"); + cli_NetServerEnum(cli, cli->server_domain, + SV_TYPE_ALL, + browse_callback, NULL); + + if (!torture_close_connection(cli)) { + correct = False; + } + + printf("browse test finished\n"); + + return correct; + +} + +static bool check_attributes(struct cli_state *cli, + const char *fname, + uint32_t expected_attrs) +{ + uint32_t attrs = 0; + NTSTATUS status = cli_getatr(cli, + fname, + &attrs, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_getatr failed with %s\n", + nt_errstr(status)); + return false; + } + if (attrs != expected_attrs) { + printf("Attributes incorrect 0x%x, should be 0x%x\n", + (unsigned int)attrs, + (unsigned int)expected_attrs); + return false; + } + return true; +} + +/* + This checks how the getatr calls works +*/ +static bool run_attrtest(int dummy) +{ + struct cli_state *cli; + uint16_t fnum; + time_t t, t2; + const char *fname = "\\attrib123456789.tst"; + bool correct = True; + NTSTATUS status; + + printf("starting attrib test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + /* Ensure we can't unlink with out-of-range (unknown) attribute. */ + status = cli_unlink(cli, fname, 0x20000); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { + correct = false; + goto out; + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_openx(cli, fname, + O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum); + cli_close(cli, fnum); + + status = cli_getatr(cli, fname, NULL, NULL, &t); + if (!NT_STATUS_IS_OK(status)) { + printf("getatr failed (%s)\n", nt_errstr(status)); + correct = False; + } + + if (labs(t - time(NULL)) > 60*60*24*10) { + printf("ERROR: SMBgetatr bug. time is %s", + ctime(&t)); + t = time(NULL); + correct = True; + } + + t2 = t-60*60*24; /* 1 day ago */ + + /* Ensure we can't set with out-of-range (unknown) attribute. */ + status = cli_setatr(cli, fname, 0x20000, t2); + if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) { + correct = false; + goto out; + } + + status = cli_setatr(cli, fname, 0, t2); + if (!NT_STATUS_IS_OK(status)) { + printf("setatr failed (%s)\n", nt_errstr(status)); + correct = True; + } + + status = cli_getatr(cli, fname, NULL, NULL, &t); + if (!NT_STATUS_IS_OK(status)) { + printf("getatr failed (%s)\n", nt_errstr(status)); + correct = True; + } + + if (t != t2) { + printf("ERROR: getatr/setatr bug. times are\n%s", + ctime(&t)); + printf("%s", ctime(&t2)); + correct = True; + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Check cli_setpathinfo_ext() */ + /* Re-create the file. */ + status = cli_openx(cli, fname, + O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("Failed to recreate %s (%s)\n", + fname, nt_errstr(status)); + correct = false; + } + cli_close(cli, fnum); + + status = cli_setpathinfo_ext( + cli, + fname, + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* create */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* access */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* write */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* change */ + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_READONLY); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_setpathinfo_ext failed with %s\n", + nt_errstr(status)); + correct = false; + } + + /* Check attributes are correct. */ + correct = check_attributes(cli, + fname, + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_READONLY); + if (correct == false) { + goto out; + } + + /* Setting to FILE_ATTRIBUTE_NORMAL should be ignored. */ + status = cli_setpathinfo_ext( + cli, + fname, + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* create */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* access */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* write */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* change */ + FILE_ATTRIBUTE_NORMAL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_setpathinfo_ext failed with %s\n", + nt_errstr(status)); + correct = false; + } + + /* Check attributes are correct. */ + correct = check_attributes(cli, + fname, + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_READONLY); + if (correct == false) { + goto out; + } + + /* Setting to (uint16_t)-1 should also be ignored. */ + status = cli_setpathinfo_ext( + cli, + fname, + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* create */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* access */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* write */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* change */ + (uint32_t)-1); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_setpathinfo_ext failed with %s\n", + nt_errstr(status)); + correct = false; + } + + /* Check attributes are correct. */ + correct = check_attributes(cli, + fname, + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN | + FILE_ATTRIBUTE_READONLY); + if (correct == false) { + goto out; + } + + /* Setting to 0 should clear them all. */ + status = cli_setpathinfo_ext( + cli, + fname, + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* create */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* access */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* write */ + (struct timespec) { .tv_nsec = SAMBA_UTIME_OMIT }, /* change */ + 0); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_setpathinfo_ext failed with %s\n", + nt_errstr(status)); + correct = false; + } + + /* Check attributes are correct. */ + correct = check_attributes(cli, + fname, + FILE_ATTRIBUTE_NORMAL); + if (correct == false) { + goto out; + } + + out: + + cli_unlink(cli, + fname, + FILE_ATTRIBUTE_SYSTEM | + FILE_ATTRIBUTE_HIDDEN| + FILE_ATTRIBUTE_READONLY); + + if (!torture_close_connection(cli)) { + correct = False; + } + + printf("attrib test finished\n"); + + return correct; +} + +static NTSTATUS cli_qfilename( + struct cli_state *cli, + uint16_t fnum, + TALLOC_CTX *mem_ctx, + char **_name) +{ + uint16_t recv_flags2; + uint8_t *rdata; + uint32_t num_rdata; + NTSTATUS status; + char *name = NULL; + uint32_t namelen; + + status = cli_qfileinfo(talloc_tos(), cli, fnum, + SMB_QUERY_FILE_NAME_INFO, + 4, CLI_BUFFER_SIZE, &recv_flags2, + &rdata, &num_rdata); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + namelen = IVAL(rdata, 0); + if (namelen > (num_rdata - 4)) { + TALLOC_FREE(rdata); + return NT_STATUS_INVALID_NETWORK_RESPONSE; + } + + pull_string_talloc(mem_ctx, + (const char *)rdata, + recv_flags2, + &name, + rdata + 4, + namelen, + STR_UNICODE); + if (name == NULL) { + status = map_nt_error_from_unix(errno); + TALLOC_FREE(rdata); + return status; + } + + *_name = name; + TALLOC_FREE(rdata); + return NT_STATUS_OK; +} + +/* + This checks a couple of trans2 calls +*/ +static bool run_trans2test(int dummy) +{ + struct cli_state *cli; + uint16_t fnum; + off_t size; + time_t c_time, a_time, m_time; + struct timespec c_time_ts, a_time_ts, m_time_ts, w_time_ts, m_time2_ts; + const char *fname = "\\trans2.tst"; + const char *dname = "\\trans2"; + const char *fname2 = "\\trans2\\trans2.tst"; + char *pname = NULL; + bool correct = True; + NTSTATUS status; + uint32_t fs_attr; + uint64_t ino; + + printf("starting trans2 test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) { + /* Ensure ino is zero, SMB2 gets a real one. */ + ino = 0; + } else { + /* Ensure ino is -1, SMB1 never gets a real one. */ + ino = (uint64_t)-1; + } + + status = cli_get_fs_attr_info(cli, &fs_attr); + if (!NT_STATUS_IS_OK(status)) { + printf("ERROR: cli_get_fs_attr_info returned %s\n", + nt_errstr(status)); + correct = false; + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum); + status = cli_qfileinfo_basic(cli, fnum, NULL, &size, &c_time_ts, + &a_time_ts, &w_time_ts, &m_time_ts, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("ERROR: qfileinfo failed (%s)\n", nt_errstr(status)); + correct = False; + } + + status = cli_qfilename(cli, fnum, talloc_tos(), &pname); + if (!NT_STATUS_IS_OK(status)) { + printf("ERROR: qfilename failed (%s)\n", nt_errstr(status)); + correct = False; + } + else if (strcmp(pname, fname)) { + printf("qfilename gave different name? [%s] [%s]\n", + fname, pname); + correct = False; + } + + cli_close(cli, fnum); + + sleep(2); + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + cli_close(cli, fnum); + + status = cli_qpathinfo1(cli, fname, &c_time, &a_time, &m_time, &size, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("ERROR: qpathinfo failed (%s)\n", nt_errstr(status)); + correct = False; + } else { + time_t t = time(NULL); + + if (c_time != m_time) { + printf("create time=%s", ctime(&c_time)); + printf("modify time=%s", ctime(&m_time)); + printf("This system appears to have sticky create times\n"); + } + if ((labs(a_time - t) > 60) && (a_time % (60*60) == 0)) { + printf("access time=%s", ctime(&a_time)); + printf("This system appears to set a midnight access time\n"); + correct = False; + } + + if (labs(m_time - t) > 60*60*24*7) { + printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time)); + correct = False; + } + } + + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_openx(cli, fname, + O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum); + cli_close(cli, fnum); + status = cli_qpathinfo2(cli, + fname, + &c_time_ts, + &a_time_ts, + &w_time_ts, + &m_time_ts, + &size, + NULL, + &ino, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status)); + correct = False; + } else { + if (w_time_ts.tv_sec < 60*60*24*2) { + printf("write time=%s", ctime(&w_time_ts.tv_sec)); + printf("This system appears to set a initial 0 write time\n"); + correct = False; + } + if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) { + /* SMB2 should always return an inode. */ + if (ino == 0) { + printf("SMB2 bad inode (0)\n"); + correct = false; + } + } else { + /* SMB1 must always return zero here. */ + if (ino != 0) { + printf("SMB1 bad inode (!0)\n"); + correct = false; + } + } + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + + /* check if the server updates the directory modification time + when creating a new file */ + status = cli_mkdir(cli, dname); + if (!NT_STATUS_IS_OK(status)) { + printf("ERROR: mkdir failed (%s)\n", nt_errstr(status)); + correct = False; + } + sleep(3); + status = cli_qpathinfo2(cli, + "\\trans2\\", + &c_time_ts, + &a_time_ts, + &w_time_ts, + &m_time_ts, + &size, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status)); + correct = False; + } + + cli_openx(cli, fname2, + O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum); + cli_writeall(cli, fnum, 0, (uint8_t *)&fnum, 0, sizeof(fnum), NULL); + cli_close(cli, fnum); + status = cli_qpathinfo2(cli, + "\\trans2\\", + &c_time_ts, + &a_time_ts, + &w_time_ts, + &m_time2_ts, + &size, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status)); + correct = False; + } else { + if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec)) + == 0) { + printf("This system does not update directory modification times\n"); + correct = False; + } + } + cli_unlink(cli, fname2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_rmdir(cli, dname); + + if (!torture_close_connection(cli)) { + correct = False; + } + + printf("trans2 test finished\n"); + + return correct; +} + +/* + This checks new W2K calls. +*/ + +static NTSTATUS new_trans(struct cli_state *pcli, int fnum, int level) +{ + uint8_t *buf = NULL; + uint32_t len; + NTSTATUS status; + + status = cli_qfileinfo(talloc_tos(), pcli, fnum, level, 0, + CLI_BUFFER_SIZE, NULL, &buf, &len); + if (!NT_STATUS_IS_OK(status)) { + printf("ERROR: qfileinfo (%d) failed (%s)\n", level, + nt_errstr(status)); + } else { + printf("qfileinfo: level %d, len = %u\n", level, len); + dump_data(0, (uint8_t *)buf, len); + printf("\n"); + } + TALLOC_FREE(buf); + return status; +} + +static bool run_w2ktest(int dummy) +{ + struct cli_state *cli; + uint16_t fnum; + const char *fname = "\\w2ktest\\w2k.tst"; + int level; + bool correct = True; + + printf("starting w2k test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + cli_openx(cli, fname, + O_RDWR | O_CREAT , DENY_NONE, &fnum); + + for (level = 1004; level < 1040; level++) { + new_trans(cli, fnum, level); + } + + cli_close(cli, fnum); + + if (!torture_close_connection(cli)) { + correct = False; + } + + printf("w2k test finished\n"); + + return correct; +} + + +/* + this is a harness for some oplock tests + */ +static bool run_oplock1(int dummy) +{ + struct cli_state *cli1; + const char *fname = "\\lockt1.lck"; + uint16_t fnum1; + bool correct = True; + NTSTATUS status; + + printf("starting oplock test 1\n"); + + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + cli1->use_oplocks = True; + + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, + &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + cli1->use_oplocks = False; + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close2 failed (%s)\n", nt_errstr(status)); + return False; + } + + status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + return False; + } + + if (!torture_close_connection(cli1)) { + correct = False; + } + + printf("finished oplock test 1\n"); + + return correct; +} + +static bool run_oplock2(int dummy) +{ + struct cli_state *cli1, *cli2; + const char *fname = "\\lockt2.lck"; + uint16_t fnum1, fnum2; + int saved_use_oplocks = use_oplocks; + char buf[4]; + bool correct = True; + volatile bool *shared_correct; + size_t nread; + NTSTATUS status; + + shared_correct = (volatile bool *)anonymous_shared_allocate(sizeof(bool)); + *shared_correct = True; + + use_level_II_oplocks = True; + use_oplocks = True; + + printf("starting oplock test 2\n"); + + if (!torture_open_connection(&cli1, 0)) { + use_level_II_oplocks = False; + use_oplocks = saved_use_oplocks; + return False; + } + + if (!torture_open_connection(&cli2, 1)) { + use_level_II_oplocks = False; + use_oplocks = saved_use_oplocks; + return False; + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, + &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + /* Don't need the globals any more. */ + use_level_II_oplocks = False; + use_oplocks = saved_use_oplocks; + + if (fork() == 0) { + /* Child code */ + status = cli_openx(cli2, fname, O_RDWR, DENY_NONE, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("second open of %s failed (%s)\n", fname, nt_errstr(status)); + *shared_correct = False; + exit(0); + } + + sleep(2); + + status = cli_close(cli2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("close2 failed (%s)\n", nt_errstr(status)); + *shared_correct = False; + } + + exit(0); + } + + sleep(2); + + /* Ensure cli1 processes the break. Empty file should always return 0 + * bytes. */ + status = cli_read(cli1, fnum1, buf, 0, 4, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("read on fnum1 failed (%s)\n", nt_errstr(status)); + correct = false; + } else if (nread != 0) { + printf("read on empty fnum1 failed. recv %ld expected %d\n", + (unsigned long)nread, 0); + correct = false; + } + + /* Should now be at level II. */ + /* Test if sending a write locks causes a break to none. */ + status = cli_lock32(cli1, fnum1, 0, 4, 0, READ_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("lock failed (%s)\n", nt_errstr(status)); + correct = False; + } + + cli_unlock(cli1, fnum1, 0, 4); + + sleep(2); + + status = cli_lock32(cli1, fnum1, 0, 4, 0, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("lock failed (%s)\n", nt_errstr(status)); + correct = False; + } + + cli_unlock(cli1, fnum1, 0, 4); + + sleep(2); + + cli_read(cli1, fnum1, buf, 0, 4, NULL); + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close1 failed (%s)\n", nt_errstr(status)); + correct = False; + } + + sleep(4); + + status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + correct = False; + } + + if (!torture_close_connection(cli1)) { + correct = False; + } + + if (!*shared_correct) { + correct = False; + } + + printf("finished oplock test 2\n"); + + return correct; +} + +struct oplock4_state { + struct tevent_context *ev; + struct cli_state *cli; + bool *got_break; + uint16_t *fnum2; +}; + +static void oplock4_got_break(struct tevent_req *req); +static void oplock4_got_open(struct tevent_req *req); + +static bool run_oplock4(int dummy) +{ + struct tevent_context *ev; + struct cli_state *cli1, *cli2; + struct tevent_req *oplock_req, *open_req; + const char *fname = "\\lockt4.lck"; + const char *fname_ln = "\\lockt4_ln.lck"; + uint16_t fnum1, fnum2; + int saved_use_oplocks = use_oplocks; + NTSTATUS status; + bool correct = true; + + bool got_break; + + struct oplock4_state *state; + + printf("starting oplock test 4\n"); + + if (!torture_open_connection(&cli1, 0)) { + use_level_II_oplocks = false; + use_oplocks = saved_use_oplocks; + return false; + } + + if (!torture_open_connection(&cli2, 1)) { + use_level_II_oplocks = false; + use_oplocks = saved_use_oplocks; + return false; + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + /* Create the file. */ + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, + &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close1 failed (%s)\n", nt_errstr(status)); + return false; + } + + /* Now create a hardlink. */ + status = cli_hardlink(cli1, fname, fname_ln); + if (!NT_STATUS_IS_OK(status)) { + printf("nt hardlink failed (%s)\n", nt_errstr(status)); + return false; + } + + /* Prove that opening hardlinks cause deny modes to conflict. */ + status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + + status = cli_openx(cli1, fname_ln, O_RDWR, DENY_NONE, &fnum2); + if (NT_STATUS_IS_OK(status)) { + printf("open of %s succeeded - should fail with sharing violation.\n", + fname_ln); + return false; + } + + if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) { + printf("open of %s should fail with sharing violation. Got %s\n", + fname_ln, nt_errstr(status)); + return false; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close1 failed (%s)\n", nt_errstr(status)); + return false; + } + + cli1->use_oplocks = true; + cli2->use_oplocks = true; + + status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + printf("tevent_context_init failed\n"); + return false; + } + + state = talloc(ev, struct oplock4_state); + if (state == NULL) { + printf("talloc failed\n"); + return false; + } + state->ev = ev; + state->cli = cli1; + state->got_break = &got_break; + state->fnum2 = &fnum2; + + oplock_req = cli_smb_oplock_break_waiter_send( + talloc_tos(), ev, cli1); + if (oplock_req == NULL) { + printf("cli_smb_oplock_break_waiter_send failed\n"); + return false; + } + tevent_req_set_callback(oplock_req, oplock4_got_break, state); + + open_req = cli_openx_send( + talloc_tos(), ev, cli2, fname_ln, O_RDWR, DENY_NONE); + if (open_req == NULL) { + printf("cli_openx_send failed\n"); + return false; + } + tevent_req_set_callback(open_req, oplock4_got_open, state); + + got_break = false; + fnum2 = 0xffff; + + while (!got_break || fnum2 == 0xffff) { + int ret; + ret = tevent_loop_once(ev); + if (ret == -1) { + printf("tevent_loop_once failed: %s\n", + strerror(errno)); + return false; + } + } + + status = cli_close(cli2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("close2 failed (%s)\n", nt_errstr(status)); + correct = false; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close1 failed (%s)\n", nt_errstr(status)); + correct = false; + } + + status = cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + correct = false; + } + + status = cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + correct = false; + } + + if (!torture_close_connection(cli1)) { + correct = false; + } + + if (!got_break) { + correct = false; + } + + printf("finished oplock test 4\n"); + + return correct; +} + +static void oplock4_got_break(struct tevent_req *req) +{ + struct oplock4_state *state = tevent_req_callback_data( + req, struct oplock4_state); + uint16_t fnum; + uint8_t level; + NTSTATUS status; + + status = cli_smb_oplock_break_waiter_recv(req, &fnum, &level); + TALLOC_FREE(req); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_smb_oplock_break_waiter_recv returned %s\n", + nt_errstr(status)); + return; + } + *state->got_break = true; + + req = cli_oplock_ack_send(state, state->ev, state->cli, fnum, + NO_OPLOCK); + if (req == NULL) { + printf("cli_oplock_ack_send failed\n"); + return; + } +} + +static void oplock4_got_open(struct tevent_req *req) +{ + struct oplock4_state *state = tevent_req_callback_data( + req, struct oplock4_state); + NTSTATUS status; + + status = cli_openx_recv(req, state->fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_openx_recv returned %s\n", nt_errstr(status)); + *state->fnum2 = 0xffff; + } +} + +#ifdef HAVE_KERNEL_OPLOCKS_LINUX + +struct oplock5_state { + int pipe_down_fd; +}; + +/* + * Async open the file that has a kernel oplock, do an echo to get + * that 100% across, close the file to signal to the child fd that the + * oplock can be dropped, wait for the open reply. + */ + +static void oplock5_opened(struct tevent_req *subreq); +static void oplock5_pong(struct tevent_req *subreq); +static void oplock5_timedout(struct tevent_req *subreq); + +static struct tevent_req *oplock5_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *fname, + int pipe_down_fd) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct oplock5_state *state = NULL; + static uint8_t data = 0; + + req = tevent_req_create(mem_ctx, &state, struct oplock5_state); + if (req == NULL) { + return NULL; + } + state->pipe_down_fd = pipe_down_fd; + + subreq = cli_ntcreate_send( + state, + ev, + cli, + fname, + 0, /* CreatFlags */ + SEC_FILE_READ_DATA, /* DesiredAccess */ + FILE_ATTRIBUTE_NORMAL, /* FileAttributes */ + FILE_SHARE_WRITE|FILE_SHARE_READ, /* ShareAccess */ + FILE_OPEN, /* CreateDisposition */ + FILE_NON_DIRECTORY_FILE, /* CreateOptions */ + 0, /* Impersonation */ + 0); /* SecurityFlags */ + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, oplock5_opened, req); + + subreq = cli_echo_send( + state, + ev, + cli, + 1, + (DATA_BLOB) { .data = &data, .length = sizeof(data) }); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, oplock5_pong, req); + + subreq = tevent_wakeup_send(state, ev, timeval_current_ofs(20, 0)); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, oplock5_timedout, req); + + return req; +} + +static void oplock5_opened(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + uint16_t fnum; + + status = cli_ntcreate_recv(subreq, &fnum, NULL); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + tevent_req_done(req); +} + +static void oplock5_pong(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct oplock5_state *state = tevent_req_data( + req, struct oplock5_state); + NTSTATUS status; + + status = cli_echo_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + + close(state->pipe_down_fd); +} + +static void oplock5_timedout(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + bool ok; + + ok = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (!ok) { + tevent_req_oom(req); + return; + } + tevent_req_nterror(req, NT_STATUS_TIMEOUT); +} + +static NTSTATUS oplock5_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static bool run_oplock5(int dummy) +{ + struct tevent_context *ev = NULL; + struct tevent_req *req = NULL; + struct cli_state *cli = NULL; + const char *fname = "oplock5.txt"; + int pipe_down[2], pipe_up[2]; + pid_t child_pid; + uint8_t c = '\0'; + NTSTATUS status; + int ret; + bool ok; + + printf("starting oplock5\n"); + + if (local_path == NULL) { + d_fprintf(stderr, "oplock5 must be given a local path via " + "-l \n"); + return false; + } + + ret = pipe(pipe_down); + if (ret == -1) { + d_fprintf(stderr, "pipe() failed: %s\n", strerror(errno)); + return false; + } + ret = pipe(pipe_up); + if (ret == -1) { + d_fprintf(stderr, "pipe() failed: %s\n", strerror(errno)); + return false; + } + + child_pid = fork(); + if (child_pid == -1) { + d_fprintf(stderr, "fork() failed: %s\n", strerror(errno)); + return false; + } + + if (child_pid == 0) { + char *local_file = NULL; + int fd; + + close(pipe_down[1]); + close(pipe_up[0]); + + local_file = talloc_asprintf( + talloc_tos(), "%s/%s", local_path, fname); + if (local_file == 0) { + c = 1; + goto do_write; + } + fd = open(local_file, O_RDWR|O_CREAT, 0644); + if (fd == -1) { + d_fprintf(stderr, + "open(%s) in child failed: %s\n", + local_file, + strerror(errno)); + c = 2; + goto do_write; + } + + signal(SIGIO, SIG_IGN); + + ret = fcntl(fd, F_SETLEASE, F_WRLCK); + if (ret == -1) { + d_fprintf(stderr, + "SETLEASE in child failed: %s\n", + strerror(errno)); + c = 3; + goto do_write; + } + + do_write: + ret = sys_write(pipe_up[1], &c, sizeof(c)); + if (ret == -1) { + d_fprintf(stderr, + "sys_write failed: %s\n", + strerror(errno)); + exit(4); + } + ret = sys_read(pipe_down[0], &c, sizeof(c)); + if (ret == -1) { + d_fprintf(stderr, + "sys_read failed: %s\n", + strerror(errno)); + exit(5); + } + exit(0); + } + + close(pipe_up[1]); + close(pipe_down[0]); + + ret = sys_read(pipe_up[0], &c, sizeof(c)); + if (ret != 1) { + d_fprintf(stderr, + "sys_read failed: %s\n", + strerror(errno)); + return false; + } + if (c != 0) { + d_fprintf(stderr, "got error code %"PRIu8"\n", c); + return false; + } + + ok = torture_open_connection(&cli, 0); + if (!ok) { + d_fprintf(stderr, "torture_open_connection failed\n"); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + d_fprintf(stderr, "samba_tevent_context_init failed\n"); + return false; + } + + req = oplock5_send(ev, ev, cli, fname, pipe_down[1]); + if (req == NULL) { + d_fprintf(stderr, "oplock5_send failed\n"); + return false; + } + + ok = tevent_req_poll_ntstatus(req, ev, &status); + if (!ok) { + d_fprintf(stderr, + "tevent_req_poll_ntstatus failed: %s\n", + nt_errstr(status)); + return false; + } + + status = oplock5_recv(req); + TALLOC_FREE(req); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "oplock5 failed: %s\n", + nt_errstr(status)); + return false; + } + + return true; +} + +#endif /* HAVE_KERNEL_OPLOCKS_LINUX */ + +/* + Test delete on close semantics. + */ +static bool run_deletetest(int dummy) +{ + struct cli_state *cli1 = NULL; + struct cli_state *cli2 = NULL; + const char *fname = "\\delete.file"; + uint16_t fnum1 = (uint16_t)-1; + uint16_t fnum2 = (uint16_t)-1; + bool correct = false; + NTSTATUS status; + + printf("starting delete test\n"); + + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + /* Test 1 - this should delete the file on close. */ + + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[1] open of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[1] close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1); + if (NT_STATUS_IS_OK(status)) { + printf("[1] open of %s succeeded (should fail)\n", fname); + goto fail; + } + + printf("first delete on close test succeeded.\n"); + + /* Test 2 - this should delete the file on close. */ + + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[2] open of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_nt_delete_on_close(cli1, fnum1, true); + if (!NT_STATUS_IS_OK(status)) { + printf("[2] setting delete_on_close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[2] close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1); + if (NT_STATUS_IS_OK(status)) { + printf("[2] open of %s succeeded should have been deleted on close !\n", fname); + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[2] close failed (%s)\n", nt_errstr(status)); + } + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + goto fail; + } + + printf("second delete on close test succeeded.\n"); + + /* Test 3 - ... */ + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[3] open - 1 of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + /* This should fail with a sharing violation - open for delete is only compatible + with SHARE_DELETE. */ + + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("[3] open - 2 of %s succeeded - should have failed.\n", fname); + goto fail; + } + + /* This should succeed. */ + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[3] open - 3 of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_nt_delete_on_close(cli1, fnum1, true); + if (!NT_STATUS_IS_OK(status)) { + printf("[3] setting delete_on_close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[3] close 1 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("[3] close 2 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + /* This should fail - file should no longer be there. */ + + status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1); + if (NT_STATUS_IS_OK(status)) { + printf("[3] open of %s succeeded should have been deleted on close !\n", fname); + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[3] close failed (%s)\n", nt_errstr(status)); + } + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + goto fail; + } + + printf("third delete on close test succeeded.\n"); + + /* Test 4 ... */ + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, + FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[4] open of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + /* This should succeed. */ + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[4] open - 2 of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("[4] close - 1 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_nt_delete_on_close(cli1, fnum1, true); + if (!NT_STATUS_IS_OK(status)) { + printf("[4] setting delete_on_close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + /* This should fail - no more opens once delete on close set. */ + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("[4] open - 3 of %s succeeded ! Should have failed.\n", fname ); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[4] close - 2 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + printf("fourth delete on close test succeeded.\n"); + + /* Test 5 ... */ + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[5] open of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + /* This should fail - only allowed on NT opens with DELETE access. */ + + status = cli_nt_delete_on_close(cli1, fnum1, true); + if (NT_STATUS_IS_OK(status)) { + printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n"); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[5] close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + printf("fifth delete on close test succeeded.\n"); + + /* Test 6 ... */ + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[6] open of %s failed (%s)\n", fname, + nt_errstr(status)); + goto fail; + } + + /* This should fail - only allowed on NT opens with DELETE access. */ + + status = cli_nt_delete_on_close(cli1, fnum1, true); + if (NT_STATUS_IS_OK(status)) { + printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n"); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[6] close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + printf("sixth delete on close test succeeded.\n"); + + /* Test 7 ... */ + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, + FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_nt_delete_on_close(cli1, fnum1, true); + if (!NT_STATUS_IS_OK(status)) { + printf("[7] setting delete_on_close on file failed !\n"); + goto fail; + } + + status = cli_nt_delete_on_close(cli1, fnum1, false); + if (!NT_STATUS_IS_OK(status)) { + printf("[7] unsetting delete_on_close on file failed !\n"); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[7] close - 1 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + /* This next open should succeed - we reset the flag. */ + status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[7] open of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[7] close - 2 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + printf("seventh delete on close test succeeded.\n"); + + /* Test 8 ... */ + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + if (!torture_open_connection(&cli2, 1)) { + printf("[8] failed to open second connection.\n"); + goto fail; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + status = cli_ntcreate(cli1, fname, 0, + FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[8] open 1 of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_ntcreate(cli2, fname, 0, + FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[8] open 2 of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_nt_delete_on_close(cli1, fnum1, true); + if (!NT_STATUS_IS_OK(status)) { + printf("[8] setting delete_on_close on file failed !\n"); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[8] close - 1 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_close(cli2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("[8] close - 2 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + /* This should fail.. */ + status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1); + if (NT_STATUS_IS_OK(status)) { + printf("[8] open of %s succeeded should have been deleted on close !\n", fname); + goto fail; + } + + printf("eighth delete on close test succeeded.\n"); + + /* Test 9 ... */ + + /* This should fail - we need to set DELETE_ACCESS. */ + status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_NONE, + FILE_OVERWRITE_IF, + FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("[9] open of %s succeeded should have failed!\n", fname); + goto fail; + } + + printf("ninth delete on close test succeeded.\n"); + + /* Test 10 ... */ + + status = cli_ntcreate(cli1, fname, 0, + FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, FILE_DELETE_ON_CLOSE, + 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[10] open of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + /* This should delete the file. */ + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[10] close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + /* This should fail.. */ + status = cli_openx(cli1, fname, O_RDONLY, DENY_NONE, &fnum1); + if (NT_STATUS_IS_OK(status)) { + printf("[10] open of %s succeeded should have been deleted on close !\n", fname); + goto fail; + } + + printf("tenth delete on close test succeeded.\n"); + + /* Test 11 ... */ + + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Can we open a read-only file with delete access? */ + + /* Create a readonly file. */ + status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, + FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[11] open of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[11] close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + /* Now try open for delete access. */ + status = cli_ntcreate(cli1, fname, 0, + FILE_READ_ATTRIBUTES|DELETE_ACCESS, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[11] open of %s failed: %s\n", fname, nt_errstr(status)); + goto fail; + } + + cli_close(cli1, fnum1); + + printf("eleventh delete on close test succeeded.\n"); + + /* + * Test 12 + * like test 4 but with initial delete on close + */ + + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, + FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_OVERWRITE_IF, + FILE_DELETE_ON_CLOSE, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[12] open 1 of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[12] open 2 of %s failed(%s).\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("[12] close 1 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_nt_delete_on_close(cli1, fnum1, true); + if (!NT_STATUS_IS_OK(status)) { + printf("[12] setting delete_on_close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + /* This should fail - no more opens once delete on close set. */ + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("[12] open 3 of %s succeeded - should fail).\n", fname); + goto fail; + } + + status = cli_nt_delete_on_close(cli1, fnum1, false); + if (!NT_STATUS_IS_OK(status)) { + printf("[12] unsetting delete_on_close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("[12] open 4 of %s failed (%s)\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("[12] close 2 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("[12] close 3 failed (%s)\n", nt_errstr(status)); + goto fail; + } + + /* + * setting delete on close on the handle does + * not unset the initial delete on close... + */ + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0, 0, &fnum2, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("[12] open 5 of %s succeeded - should fail).\n", fname); + goto fail; + } else if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + printf("ntcreate returned %s, expected " + "NT_STATUS_OBJECT_NAME_NOT_FOUND\n", + nt_errstr(status)); + goto fail; + } + + printf("twelfth delete on close test succeeded.\n"); + + + printf("finished delete test\n"); + + correct = true; + + fail: + /* FIXME: This will crash if we aborted before cli2 got + * initialized, because these functions don't handle + * uninitialized connections. */ + + if (fnum1 != (uint16_t)-1) cli_close(cli1, fnum1); + if (fnum2 != (uint16_t)-1) cli_close(cli1, fnum2); + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + if (cli1 && !torture_close_connection(cli1)) { + correct = False; + } + if (cli2 && !torture_close_connection(cli2)) { + correct = False; + } + return correct; +} + +struct delete_stream_state { + bool closed; +}; + +static void delete_stream_unlinked(struct tevent_req *subreq); +static void delete_stream_closed(struct tevent_req *subreq); + +static struct tevent_req *delete_stream_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *base_fname, + uint16_t stream_fnum) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct delete_stream_state *state = NULL; + + req = tevent_req_create( + mem_ctx, &state, struct delete_stream_state); + if (req == NULL) { + return NULL; + } + + subreq = cli_unlink_send( + state, + ev, + cli, + base_fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, delete_stream_unlinked, req); + + subreq = cli_close_send(state, ev, cli, stream_fnum, 0); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, delete_stream_closed, req); + + return req; +} + +static void delete_stream_unlinked(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct delete_stream_state *state = tevent_req_data( + req, struct delete_stream_state); + NTSTATUS status; + + status = cli_unlink_recv(subreq); + TALLOC_FREE(subreq); + if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) { + printf("cli_unlink returned %s\n", + nt_errstr(status)); + tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL); + return; + } + if (!state->closed) { + /* close reply should have come in first */ + printf("Not closed\n"); + tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL); + return; + } + tevent_req_done(req); +} + +static void delete_stream_closed(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct delete_stream_state *state = tevent_req_data( + req, struct delete_stream_state); + NTSTATUS status; + + status = cli_close_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + /* also waiting for the unlink to come back */ + state->closed = true; +} + +static NTSTATUS delete_stream_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static bool run_delete_stream(int dummy) +{ + struct tevent_context *ev = NULL; + struct tevent_req *req = NULL; + struct cli_state *cli = NULL; + const char fname[] = "delete_stream"; + const char fname_stream[] = "delete_stream:Zone.Identifier:$DATA"; + uint16_t fnum1, fnum2; + NTSTATUS status; + bool ok; + + printf("Starting stream delete test\n"); + + ok = torture_open_connection(&cli, 0); + if (!ok) { + return false; + } + + cli_setatr(cli, fname, 0, 0); + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Create the file. */ + status = cli_ntcreate( + cli, + fname, + 0, + READ_CONTROL_ACCESS, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_CREATE, + 0x0, + 0x0, + &fnum1, + NULL); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_ntcreate of %s failed (%s)\n", + fname, + nt_errstr(status)); + return false; + } + status = cli_close(cli, fnum1); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_close of %s failed (%s)\n", + fname, + nt_errstr(status)); + return false; + } + + /* Now create the stream. */ + status = cli_ntcreate( + cli, + fname_stream, + 0, + FILE_WRITE_DATA, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, + 0x0, + 0x0, + &fnum1, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "cli_ntcreate of %s failed (%s)\n", + fname_stream, + nt_errstr(status)); + return false; + } + + /* open it a second time */ + + status = cli_ntcreate( + cli, + fname_stream, + 0, + FILE_WRITE_DATA, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_OPEN, + 0x0, + 0x0, + &fnum2, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "2nd cli_ntcreate of %s failed (%s)\n", + fname_stream, + nt_errstr(status)); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + d_fprintf(stderr, "samba_tevent_context_init failed\n"); + return false; + } + + req = delete_stream_send(ev, ev, cli, fname, fnum1); + if (req == NULL) { + d_fprintf(stderr, "delete_stream_send failed\n"); + return false; + } + + ok = tevent_req_poll_ntstatus(req, ev, &status); + if (!ok) { + d_fprintf(stderr, + "tevent_req_poll_ntstatus failed: %s\n", + nt_errstr(status)); + return false; + } + + status = delete_stream_recv(req); + TALLOC_FREE(req); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "delete_stream failed: %s\n", + nt_errstr(status)); + return false; + } + + status = cli_close(cli, fnum2); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "close failed: %s\n", + nt_errstr(status)); + return false; + } + + status = cli_unlink( + cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, + "unlink failed: %s\n", + nt_errstr(status)); + return false; + } + + return true; +} + +/* + Exercise delete on close semantics - use on the PRINT1 share in torture + testing. + */ +static bool run_delete_print_test(int dummy) +{ + struct cli_state *cli1 = NULL; + const char *fname = "print_delete.file"; + uint16_t fnum1 = (uint16_t)-1; + bool correct = false; + const char *buf = "print file data\n"; + NTSTATUS status; + + printf("starting print delete test\n"); + + if (!torture_open_connection(&cli1, 0)) { + return false; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", + fname, + nt_errstr(status)); + goto fail; + } + + status = cli_writeall(cli1, + fnum1, + 0, + (const uint8_t *)buf, + 0, /* offset */ + strlen(buf), /* size */ + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("writing print file data failed (%s)\n", + nt_errstr(status)); + goto fail; + } + + status = cli_nt_delete_on_close(cli1, fnum1, true); + if (!NT_STATUS_IS_OK(status)) { + printf("setting delete_on_close failed (%s)\n", + nt_errstr(status)); + goto fail; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + printf("finished print delete test\n"); + + correct = true; + + fail: + + if (fnum1 != (uint16_t)-1) { + cli_close(cli1, fnum1); + } + + if (cli1 && !torture_close_connection(cli1)) { + correct = false; + } + return correct; +} + +static bool run_deletetest_ln(int dummy) +{ + struct cli_state *cli; + const char *fname = "\\delete1"; + const char *fname_ln = "\\delete1_ln"; + uint16_t fnum; + uint16_t fnum1; + NTSTATUS status; + bool correct = true; + time_t t; + + printf("starting deletetest-ln\n"); + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + /* Create the file. */ + status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close1 failed (%s)\n", nt_errstr(status)); + return false; + } + + /* Now create a hardlink. */ + status = cli_hardlink(cli, fname, fname_ln); + if (!NT_STATUS_IS_OK(status)) { + printf("nt hardlink failed (%s)\n", nt_errstr(status)); + return false; + } + + /* Open the original file. */ + status = cli_ntcreate(cli, fname, 0, FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN_IF, 0, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("ntcreate of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + + /* Unlink the hard link path. */ + status = cli_ntcreate(cli, fname_ln, 0, DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("ntcreate of %s failed (%s)\n", fname_ln, nt_errstr(status)); + return false; + } + status = cli_nt_delete_on_close(cli, fnum1, true); + if (!NT_STATUS_IS_OK(status)) { + d_printf("(%s) failed to set delete_on_close %s: %s\n", + __location__, fname_ln, nt_errstr(status)); + return false; + } + + status = cli_close(cli, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close %s failed (%s)\n", + fname_ln, nt_errstr(status)); + return false; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close %s failed (%s)\n", + fname, nt_errstr(status)); + return false; + } + + /* Ensure the original file is still there. */ + status = cli_getatr(cli, fname, NULL, NULL, &t); + if (!NT_STATUS_IS_OK(status)) { + printf("%s getatr on file %s failed (%s)\n", + __location__, + fname, + nt_errstr(status)); + correct = False; + } + + /* Ensure the link path is gone. */ + status = cli_getatr(cli, fname_ln, NULL, NULL, &t); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + printf("%s, getatr for file %s returned wrong error code %s " + "- should have been deleted\n", + __location__, + fname_ln, nt_errstr(status)); + correct = False; + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + if (!torture_close_connection(cli)) { + correct = false; + } + + printf("finished deletetest-ln\n"); + + return correct; +} + +/* + print out server properties + */ +static bool run_properties(int dummy) +{ + struct cli_state *cli; + bool correct = True; + + printf("starting properties test\n"); + + ZERO_STRUCT(cli); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + d_printf("Capabilities 0x%08x\n", smb1cli_conn_capabilities(cli->conn)); + + if (!torture_close_connection(cli)) { + correct = False; + } + + return correct; +} + + + +/* FIRST_DESIRED_ACCESS 0xf019f */ +#define FIRST_DESIRED_ACCESS FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|\ + FILE_READ_EA| /* 0xf */ \ + FILE_WRITE_EA|FILE_READ_ATTRIBUTES| /* 0x90 */ \ + FILE_WRITE_ATTRIBUTES| /* 0x100 */ \ + DELETE_ACCESS|READ_CONTROL_ACCESS|\ + WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS /* 0xf0000 */ +/* SECOND_DESIRED_ACCESS 0xe0080 */ +#define SECOND_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \ + READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\ + WRITE_OWNER_ACCESS /* 0xe0000 */ + +#if 0 +#define THIRD_DESIRED_ACCESS FILE_READ_ATTRIBUTES| /* 0x80 */ \ + READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|\ + FILE_READ_DATA|\ + WRITE_OWNER_ACCESS /* */ +#endif + +/* + Test ntcreate calls made by xcopy + */ +static bool run_xcopy(int dummy) +{ + static struct cli_state *cli1; + const char *fname = "\\test.txt"; + bool correct = True; + uint16_t fnum1, fnum2; + NTSTATUS status; + + printf("starting xcopy test\n"); + + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + status = cli_ntcreate(cli1, fname, 0, FIRST_DESIRED_ACCESS, + FILE_ATTRIBUTE_ARCHIVE, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0x4044, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("First open failed - %s\n", nt_errstr(status)); + return False; + } + + status = cli_ntcreate(cli1, fname, 0, SECOND_DESIRED_ACCESS, 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, 0x200000, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("second open failed - %s\n", nt_errstr(status)); + return False; + } + + if (!torture_close_connection(cli1)) { + correct = False; + } + + return correct; +} + +/* + Test rename on files open with share delete and no share delete. + */ +static bool run_rename(int dummy) +{ + static struct cli_state *cli1; + const char *fname = "\\test.txt"; + const char *fname1 = "\\test1.txt"; + bool correct = True; + uint16_t fnum1; + uint32_t attr; + NTSTATUS status; + + printf("starting rename test\n"); + + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("First open failed - %s\n", nt_errstr(status)); + return False; + } + + status = cli_rename(cli1, fname, fname1, false); + if (!NT_STATUS_IS_OK(status)) { + printf("First rename failed (SHARE_READ) (this is correct) - %s\n", nt_errstr(status)); + } else { + printf("First rename succeeded (SHARE_READ) - this should have failed !\n"); + correct = False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close - 1 failed (%s)\n", nt_errstr(status)); + return False; + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL, +#if 0 + FILE_SHARE_DELETE|FILE_SHARE_NONE, +#else + FILE_SHARE_DELETE|FILE_SHARE_READ, +#endif + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Second open failed - %s\n", nt_errstr(status)); + return False; + } + + status = cli_rename(cli1, fname, fname1, false); + if (!NT_STATUS_IS_OK(status)) { + printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", nt_errstr(status)); + correct = False; + } else { + printf("Second rename succeeded (SHARE_DELETE | SHARE_READ)\n"); + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close - 2 failed (%s)\n", nt_errstr(status)); + return False; + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Third open failed - %s\n", nt_errstr(status)); + return False; + } + + + status = cli_rename(cli1, fname, fname1, false); + if (!NT_STATUS_IS_OK(status)) { + printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status)); + correct = False; + } else { + printf("Third rename succeeded (SHARE_NONE)\n"); + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close - 3 failed (%s)\n", nt_errstr(status)); + return False; + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /*----*/ + + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ | FILE_SHARE_WRITE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Fourth open failed - %s\n", nt_errstr(status)); + return False; + } + + status = cli_rename(cli1, fname, fname1, false); + if (!NT_STATUS_IS_OK(status)) { + printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", nt_errstr(status)); + } else { + printf("Fourth rename succeeded (SHARE_READ | SHARE_WRITE) - this should have failed !\n"); + correct = False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close - 4 failed (%s)\n", nt_errstr(status)); + return False; + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /*--*/ + + status = cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Fifth open failed - %s\n", nt_errstr(status)); + return False; + } + + status = cli_rename(cli1, fname, fname1, false); + if (!NT_STATUS_IS_OK(status)) { + printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n", nt_errstr(status)); + correct = False; + } else { + printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", nt_errstr(status)); + } + + /*--*/ + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close - 5 failed (%s)\n", nt_errstr(status)); + return False; + } + + /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */ + status = cli_getatr(cli1, fname1, &attr, NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("getatr on file %s failed - %s ! \n", + fname1, nt_errstr(status)); + correct = False; + } else { + if (attr != FILE_ATTRIBUTE_ARCHIVE) { + printf("Renamed file %s has wrong attr 0x%x " + "(should be 0x%x)\n", + fname1, + attr, + (unsigned int)FILE_ATTRIBUTE_ARCHIVE); + correct = False; + } else { + printf("Renamed file %s has archive bit set\n", fname1); + } + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + if (!torture_close_connection(cli1)) { + correct = False; + } + + return correct; +} + +/* + Test rename into a directory with an ACL denying it. + */ +static bool run_rename_access(int dummy) +{ + static struct cli_state *cli = NULL; + static struct cli_state *posix_cli = NULL; + const char *src = "test.txt"; + const char *dname = "dir"; + const char *dst = "dir\\test.txt"; + const char *dsrc = "test.dir"; + const char *ddst = "dir\\test.dir"; + uint16_t fnum = (uint16_t)-1; + struct security_descriptor *sd = NULL; + struct security_descriptor *newsd = NULL; + NTSTATUS status; + TALLOC_CTX *frame = NULL; + + frame = talloc_stackframe(); + printf("starting rename access test\n"); + + /* Windows connection. */ + if (!torture_open_connection(&cli, 0)) { + goto fail; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + /* Posix connection. */ + if (!torture_open_connection(&posix_cli, 0)) { + goto fail; + } + + smbXcli_conn_set_sockopt(posix_cli->conn, sockops); + + status = torture_setup_unix_extensions(posix_cli); + if (!NT_STATUS_IS_OK(status)) { + goto fail; + } + + /* Start with a clean slate. */ + cli_unlink(cli, src, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli, dst, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_rmdir(cli, dsrc); + cli_rmdir(cli, ddst); + cli_rmdir(cli, dname); + + /* + * Setup the destination directory with a DENY ACE to + * prevent new files within it. + */ + status = cli_ntcreate(cli, + dname, + 0, + FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS| + WRITE_DAC_ACCESS|FILE_READ_DATA| + WRITE_OWNER_ACCESS, + FILE_ATTRIBUTE_DIRECTORY, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, + FILE_DIRECTORY_FILE, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Create of %s - %s\n", dname, nt_errstr(status)); + goto fail; + } + + status = cli_query_secdesc(cli, + fnum, + frame, + &sd); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_query_secdesc failed for %s (%s)\n", + dname, nt_errstr(status)); + goto fail; + } + + newsd = security_descriptor_dacl_create(frame, + 0, + NULL, + NULL, + SID_WORLD, + SEC_ACE_TYPE_ACCESS_DENIED, + SEC_DIR_ADD_FILE|SEC_DIR_ADD_SUBDIR, + 0, + NULL); + if (newsd == NULL) { + goto fail; + } + sd->dacl = security_acl_concatenate(frame, + newsd->dacl, + sd->dacl); + if (sd->dacl == NULL) { + goto fail; + } + status = cli_set_secdesc(cli, fnum, sd); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_set_secdesc failed for %s (%s)\n", + dname, nt_errstr(status)); + goto fail; + } + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed for %s (%s)\n", + dname, nt_errstr(status)); + goto fail; + } + /* Now go around the back and chmod to 777 via POSIX. */ + status = cli_posix_chmod(posix_cli, dname, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_chmod failed for %s (%s)\n", + dname, nt_errstr(status)); + goto fail; + } + + /* Check we can't create a file within dname via Windows. */ + status = cli_openx(cli, dst, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + cli_close(posix_cli, fnum); + printf("Create of %s should be ACCESS denied, was %s\n", + dst, nt_errstr(status)); + goto fail; + } + + /* Make the sample file/directory. */ + status = cli_openx(cli, src, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", src, nt_errstr(status)); + goto fail; + } + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed (%s)\n", nt_errstr(status)); + goto fail; + } + + status = cli_mkdir(cli, dsrc); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_mkdir of %s failed (%s)\n", + dsrc, nt_errstr(status)); + goto fail; + } + + /* + * OK - renames of the new file and directory into the + * dst directory should fail. + */ + + status = cli_rename(cli, src, dst, false); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("rename of %s -> %s should be ACCESS denied, was %s\n", + src, dst, nt_errstr(status)); + goto fail; + } + status = cli_rename(cli, dsrc, ddst, false); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("rename of %s -> %s should be ACCESS denied, was %s\n", + src, dst, nt_errstr(status)); + goto fail; + } + + TALLOC_FREE(frame); + return true; + + fail: + + if (posix_cli) { + torture_close_connection(posix_cli); + } + + if (cli) { + if (fnum != (uint16_t)-1) { + cli_close(cli, fnum); + } + cli_unlink(cli, src, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli, dst, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_rmdir(cli, dsrc); + cli_rmdir(cli, ddst); + cli_rmdir(cli, dname); + + torture_close_connection(cli); + } + + TALLOC_FREE(frame); + return false; +} + +/* + Test owner rights ACE. + */ +static bool run_owner_rights(int dummy) +{ + static struct cli_state *cli = NULL; + const char *fname = "owner_rights.txt"; + uint16_t fnum = (uint16_t)-1; + struct security_descriptor *sd = NULL; + struct security_descriptor *newsd = NULL; + NTSTATUS status; + TALLOC_CTX *frame = NULL; + + frame = talloc_stackframe(); + printf("starting owner rights test\n"); + + /* Windows connection. */ + if (!torture_open_connection(&cli, 0)) { + goto fail; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + /* Start with a clean slate. */ + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Create the test file. */ + /* Now try and open for read and write-dac. */ + status = cli_ntcreate(cli, + fname, + 0, + GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_CREATE, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Create of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + /* Get the original SD. */ + status = cli_query_secdesc(cli, + fnum, + frame, + &sd); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_query_secdesc failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + + /* + * Add an "owner-rights" ACE denying WRITE_DATA, + * and an "owner-rights" ACE allowing READ_DATA. + */ + + newsd = security_descriptor_dacl_create(frame, + 0, + NULL, + NULL, + SID_OWNER_RIGHTS, + SEC_ACE_TYPE_ACCESS_DENIED, + FILE_WRITE_DATA, + 0, + SID_OWNER_RIGHTS, + SEC_ACE_TYPE_ACCESS_ALLOWED, + FILE_READ_DATA, + 0, + NULL); + if (newsd == NULL) { + goto fail; + } + sd->dacl = security_acl_concatenate(frame, + newsd->dacl, + sd->dacl); + if (sd->dacl == NULL) { + goto fail; + } + status = cli_set_secdesc(cli, fnum, sd); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_set_secdesc failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + fnum = (uint16_t)-1; + + /* Try and open for FILE_WRITE_DATA */ + status = cli_ntcreate(cli, + fname, + 0, + FILE_WRITE_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("Open of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + /* Now try and open for FILE_READ_DATA */ + status = cli_ntcreate(cli, + fname, + 0, + FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Open of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + + /* Restore clean slate. */ + TALLOC_FREE(sd); + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Create the test file. */ + status = cli_ntcreate(cli, + fname, + 0, + GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_CREATE, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Create of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + /* Get the original SD. */ + status = cli_query_secdesc(cli, + fnum, + frame, + &sd); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_query_secdesc failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + + /* + * Add an "owner-rights ACE denying WRITE_DATA, + * and an "owner-rights ACE allowing READ_DATA|WRITE_DATA. + */ + + newsd = security_descriptor_dacl_create(frame, + 0, + NULL, + NULL, + SID_OWNER_RIGHTS, + SEC_ACE_TYPE_ACCESS_DENIED, + FILE_WRITE_DATA, + 0, + SID_OWNER_RIGHTS, + SEC_ACE_TYPE_ACCESS_ALLOWED, + FILE_READ_DATA|FILE_WRITE_DATA, + 0, + NULL); + if (newsd == NULL) { + goto fail; + } + sd->dacl = security_acl_concatenate(frame, + newsd->dacl, + sd->dacl); + if (sd->dacl == NULL) { + goto fail; + } + status = cli_set_secdesc(cli, fnum, sd); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_set_secdesc failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + fnum = (uint16_t)-1; + + /* Try and open for FILE_WRITE_DATA */ + status = cli_ntcreate(cli, + fname, + 0, + FILE_WRITE_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("Open of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + /* Now try and open for FILE_READ_DATA */ + status = cli_ntcreate(cli, + fname, + 0, + FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Open of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + + /* Restore clean slate. */ + TALLOC_FREE(sd); + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + + /* Create the test file. */ + status = cli_ntcreate(cli, + fname, + 0, + GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_CREATE, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Create of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + /* Get the original SD. */ + status = cli_query_secdesc(cli, + fnum, + frame, + &sd); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_query_secdesc failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + + /* + * Add an "authenticated users" ACE allowing READ_DATA, + * add an "owner-rights" denying READ_DATA, + * and an "authenticated users" ACE allowing WRITE_DATA. + */ + + newsd = security_descriptor_dacl_create(frame, + 0, + NULL, + NULL, + SID_NT_AUTHENTICATED_USERS, + SEC_ACE_TYPE_ACCESS_ALLOWED, + FILE_READ_DATA, + 0, + SID_OWNER_RIGHTS, + SEC_ACE_TYPE_ACCESS_DENIED, + FILE_READ_DATA, + 0, + SID_NT_AUTHENTICATED_USERS, + SEC_ACE_TYPE_ACCESS_ALLOWED, + FILE_WRITE_DATA, + 0, + NULL); + if (newsd == NULL) { + printf("newsd == NULL\n"); + goto fail; + } + sd->dacl = security_acl_concatenate(frame, + newsd->dacl, + sd->dacl); + if (sd->dacl == NULL) { + printf("sd->dacl == NULL\n"); + goto fail; + } + status = cli_set_secdesc(cli, fnum, sd); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_set_secdesc failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + fnum = (uint16_t)-1; + + /* Now try and open for FILE_READ_DATA|FILE_WRITE_DATA */ + status = cli_ntcreate(cli, + fname, + 0, + FILE_READ_DATA|FILE_WRITE_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Open of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed for %s (%s)\n", + fname, nt_errstr(status)); + goto fail; + } + + cli_unlink(cli, fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + TALLOC_FREE(frame); + return true; + + fail: + + if (cli) { + if (fnum != (uint16_t)-1) { + cli_close(cli, fnum); + } + cli_unlink(cli, fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + torture_close_connection(cli); + } + + TALLOC_FREE(frame); + return false; +} + +/* + * Test SMB1-specific open with SEC_FLAG_SYSTEM_SECURITY. + * Note this test only works with a user with SeSecurityPrivilege set. + * + * NB. This is also tested in samba3.base.createx_access + * but this makes it very explicit what we're looking for. + */ +static bool run_smb1_system_security(int dummy) +{ + static struct cli_state *cli = NULL; + const char *fname = "system_security.txt"; + uint16_t fnum = (uint16_t)-1; + NTSTATUS status; + TALLOC_CTX *frame = NULL; + + frame = talloc_stackframe(); + printf("starting smb1 system security test\n"); + + /* SMB1 connection - torture_open_connection() forces this. */ + if (!torture_open_connection(&cli, 0)) { + goto fail; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + /* Start with a clean slate. */ + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Create the test file. */ + status = cli_ntcreate(cli, + fname, + 0, + GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_CREATE, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Create of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli, fnum); + + /* Open with SEC_FLAG_SYSTEM_SECURITY only. */ + /* + * On SMB1 this succeeds - SMB2 it fails, + * see the SMB2-SACL test. + */ + status = cli_ntcreate(cli, + fname, + 0, + SEC_FLAG_SYSTEM_SECURITY, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE| + FILE_SHARE_DELETE, + FILE_OPEN, + 0, + 0, + &fnum, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Open of %s - %s\n", fname, nt_errstr(status)); + goto fail; + } + + status = cli_close(cli, fnum); + + cli_unlink(cli, fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + torture_close_connection(cli); + TALLOC_FREE(frame); + return true; + + fail: + + if (cli) { + if (fnum != (uint16_t)-1) { + cli_close(cli, fnum); + } + cli_unlink(cli, fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + torture_close_connection(cli); + } + + TALLOC_FREE(frame); + return false; +} + +static bool run_pipe_number(int dummy) +{ + struct cli_state *cli1; + const char *pipe_name = "\\SPOOLSS"; + uint16_t fnum; + int num_pipes = 0; + NTSTATUS status; + + printf("starting pipenumber test\n"); + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + while(1) { + status = cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_OPEN_IF, 0, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Open of pipe %s failed with error (%s)\n", pipe_name, nt_errstr(status)); + break; + } + num_pipes++; + printf("\r%6d", num_pipes); + } + + printf("pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name ); + torture_close_connection(cli1); + return True; +} + +/* + Test open mode returns on read-only files. + */ +static bool run_opentest(int dummy) +{ + static struct cli_state *cli1; + static struct cli_state *cli2; + const char *fname = "\\readonly.file"; + uint16_t fnum1, fnum2; + char buf[20]; + off_t fsize; + bool correct = True; + char *tmp_path; + NTSTATUS status; + + printf("starting open test\n"); + + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close2 failed (%s)\n", nt_errstr(status)); + return False; + } + + status = cli_setatr(cli1, fname, FILE_ATTRIBUTE_READONLY, 0); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_setatr failed (%s)\n", nt_errstr(status)); + return False; + } + + status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + /* This will fail - but the error should be ERRnoaccess, not ERRbadshare. */ + status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2); + + if (check_error(__LINE__, status, ERRDOS, ERRnoaccess, + NT_STATUS_ACCESS_DENIED)) { + printf("correct error code ERRDOS/ERRnoaccess returned\n"); + } + + printf("finished open test 1\n"); + + cli_close(cli1, fnum1); + + /* Now try not readonly and ensure ERRbadshare is returned. */ + + cli_setatr(cli1, fname, 0, 0); + + status = cli_openx(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + /* This will fail - but the error should be ERRshare. */ + status = cli_openx(cli1, fname, O_RDWR, DENY_ALL, &fnum2); + + if (check_error(__LINE__, status, ERRDOS, ERRbadshare, + NT_STATUS_SHARING_VIOLATION)) { + printf("correct error code ERRDOS/ERRbadshare returned\n"); + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close2 failed (%s)\n", nt_errstr(status)); + return False; + } + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + printf("finished open test 2\n"); + + /* Test truncate open disposition on file opened for read. */ + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("(3) open (1) of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + /* write 20 bytes. */ + + memset(buf, '\0', 20); + + status = cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, 20, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("write failed (%s)\n", nt_errstr(status)); + correct = False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("(3) close1 failed (%s)\n", nt_errstr(status)); + return False; + } + + /* Ensure size == 20. */ + status = cli_getatr(cli1, fname, NULL, &fsize, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("(3) getatr failed (%s)\n", nt_errstr(status)); + return False; + } + + if (fsize != 20) { + printf("(3) file size != 20\n"); + return False; + } + + /* Now test if we can truncate a file opened for readonly. */ + status = cli_openx(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("(3) open (2) of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close2 failed (%s)\n", nt_errstr(status)); + return False; + } + + /* Ensure size == 0. */ + status = cli_getatr(cli1, fname, NULL, &fsize, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("(3) getatr failed (%s)\n", nt_errstr(status)); + return False; + } + + if (fsize != 0) { + printf("(3) file size != 0\n"); + return False; + } + printf("finished open test 3\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + printf("Do ctemp tests\n"); + status = cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path); + if (!NT_STATUS_IS_OK(status)) { + printf("ctemp failed (%s)\n", nt_errstr(status)); + return False; + } + + printf("ctemp gave path %s\n", tmp_path); + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close of temp failed (%s)\n", nt_errstr(status)); + } + + status = cli_unlink(cli1, tmp_path, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink of temp failed (%s)\n", nt_errstr(status)); + } + + /* Test the non-io opens... */ + + if (!torture_open_connection(&cli2, 1)) { + return False; + } + + cli_setatr(cli2, fname, 0, 0); + cli_unlink(cli2, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + printf("TEST #1 testing 2 non-io opens (no delete)\n"); + status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #1 open 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OPEN_IF, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #1 open 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #1 close 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #1 close 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + printf("non-io open test #1 passed.\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + printf("TEST #2 testing 2 non-io opens (first with delete)\n"); + + status = cli_ntcreate(cli1, fname, 0, + DELETE_ACCESS|FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #2 open 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OPEN_IF, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #2 open 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #2 close 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #2 close 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + printf("non-io open test #2 passed.\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + printf("TEST #3 testing 2 non-io opens (second with delete)\n"); + + status = cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #3 open 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_ntcreate(cli2, fname, 0, + DELETE_ACCESS|FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OPEN_IF, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #3 open 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #3 close 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #3 close 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + printf("non-io open test #3 passed.\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + printf("TEST #4 testing 2 non-io opens (both with delete)\n"); + + status = cli_ntcreate(cli1, fname, 0, + DELETE_ACCESS|FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #4 open 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_ntcreate(cli2, fname, 0, + DELETE_ACCESS|FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OPEN_IF, 0, 0, &fnum2, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation"); + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #4 close 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + printf("non-io open test #4 passed.\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n"); + + status = cli_ntcreate(cli1, fname, 0, + DELETE_ACCESS|FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #5 open 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_ntcreate(cli2, fname, 0, + DELETE_ACCESS|FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE, + FILE_OPEN_IF, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #5 open 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #5 close 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #5 close 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + printf("non-io open test #5 passed.\n"); + + printf("TEST #6 testing 1 non-io open, one io open\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #6 open 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, + FILE_OPEN_IF, 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #6 open 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #6 close 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #6 close 2 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + printf("non-io open test #6 passed.\n"); + + printf("TEST #7 testing 1 non-io open, one io open with delete\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #7 open 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_ntcreate(cli2, fname, 0, + DELETE_ACCESS|FILE_READ_ATTRIBUTES, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_DELETE, + FILE_OPEN_IF, 0, 0, &fnum2, NULL); + if (NT_STATUS_IS_OK(status)) { + printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname, nt_errstr(status), "sharing violation"); + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #7 close 1 of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + printf("non-io open test #7 passed.\n"); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + printf("TEST #8 testing open without WRITE_ATTRIBUTES, updating close write time.\n"); + status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #8 open of %s failed (%s)\n", fname, nt_errstr(status)); + correct = false; + goto out; + } + + /* Write to ensure we have to update the file time. */ + status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #8 cli_write failed: %s\n", nt_errstr(status)); + correct = false; + goto out; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("TEST #8 close of %s failed (%s)\n", fname, nt_errstr(status)); + correct = false; + } + + out: + + if (!torture_close_connection(cli1)) { + correct = False; + } + if (!torture_close_connection(cli2)) { + correct = False; + } + + return correct; +} + +NTSTATUS torture_setup_unix_extensions(struct cli_state *cli) +{ + uint16_t major, minor; + uint32_t caplow, caphigh; + NTSTATUS status; + + if (!SERVER_HAS_UNIX_CIFS(cli)) { + printf("Server doesn't support UNIX CIFS extensions.\n"); + return NT_STATUS_NOT_SUPPORTED; + } + + status = cli_unix_extensions_version(cli, &major, &minor, &caplow, + &caphigh); + if (!NT_STATUS_IS_OK(status)) { + printf("Server didn't return UNIX CIFS extensions: %s\n", + nt_errstr(status)); + return status; + } + + status = cli_set_unix_extensions_capabilities(cli, major, minor, + caplow, caphigh); + if (!NT_STATUS_IS_OK(status)) { + printf("Server doesn't support setting UNIX CIFS extensions: " + "%s.\n", nt_errstr(status)); + return status; + } + + return NT_STATUS_OK; +} + +/* + Test POSIX open /mkdir calls. + */ +static bool run_simple_posix_open_test(int dummy) +{ + static struct cli_state *cli1; + const char *fname = "posix:file"; + const char *hname = "posix:hlink"; + const char *sname = "posix:symlink"; + const char *dname = "posix:dir"; + char buf[10]; + char *target = NULL; + uint16_t fnum1 = (uint16_t)-1; + SMB_STRUCT_STAT sbuf; + bool correct = false; + NTSTATUS status; + size_t nread; + const char *fname_windows = "windows_file"; + uint16_t fnum2 = (uint16_t)-1; + bool ok; + + printf("Starting simple POSIX open test\n"); + + if (!torture_open_connection(&cli1, 0)) { + return false; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + status = torture_setup_unix_extensions(cli1); + if (!NT_STATUS_IS_OK(status)) { + return false; + } + + cli_setatr(cli1, fname, 0, 0); + cli_posix_unlink(cli1, fname); + cli_setatr(cli1, dname, 0, 0); + cli_posix_rmdir(cli1, dname); + cli_setatr(cli1, hname, 0, 0); + cli_posix_unlink(cli1, hname); + cli_setatr(cli1, sname, 0, 0); + cli_posix_unlink(cli1, sname); + cli_setatr(cli1, fname_windows, 0, 0); + cli_posix_unlink(cli1, fname_windows); + + /* Create a directory. */ + status = cli_posix_mkdir(cli1, dname, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status)); + goto out; + } + + status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, + 0600, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status)); + goto out; + } + + /* Test ftruncate - set file size. */ + status = cli_ftruncate(cli1, fnum1, 1000); + if (!NT_STATUS_IS_OK(status)) { + printf("ftruncate failed (%s)\n", nt_errstr(status)); + goto out; + } + + /* Ensure st_size == 1000 */ + status = cli_posix_stat(cli1, fname, &sbuf); + if (!NT_STATUS_IS_OK(status)) { + printf("stat failed (%s)\n", nt_errstr(status)); + goto out; + } + + if (sbuf.st_ex_size != 1000) { + printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size); + goto out; + } + + /* Ensure st_mode == 0600 */ + if ((sbuf.st_ex_mode & 07777) != 0600) { + printf("posix_open - bad permissions 0%o != 0600\n", + (unsigned int)(sbuf.st_ex_mode & 07777)); + goto out; + } + + /* Test ftruncate - set file size back to zero. */ + status = cli_ftruncate(cli1, fnum1, 0); + if (!NT_STATUS_IS_OK(status)) { + printf("ftruncate failed (%s)\n", nt_errstr(status)); + goto out; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + goto out; + } + + /* Now open the file again for read only. */ + status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX open of %s failed (%s)\n", fname, nt_errstr(status)); + goto out; + } + + /* Now unlink while open. */ + status = cli_posix_unlink(cli1, fname); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status)); + goto out; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close(2) failed (%s)\n", nt_errstr(status)); + goto out; + } + + /* Ensure the file has gone. */ + status = cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1); + if (NT_STATUS_IS_OK(status)) { + printf("POSIX open of %s succeeded, should have been deleted.\n", fname); + goto out; + } + + /* Create again to test open with O_TRUNC. */ + status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status)); + goto out; + } + + /* Test ftruncate - set file size. */ + status = cli_ftruncate(cli1, fnum1, 1000); + if (!NT_STATUS_IS_OK(status)) { + printf("ftruncate failed (%s)\n", nt_errstr(status)); + goto out; + } + + /* Ensure st_size == 1000 */ + status = cli_posix_stat(cli1, fname, &sbuf); + if (!NT_STATUS_IS_OK(status)) { + printf("stat failed (%s)\n", nt_errstr(status)); + goto out; + } + + if (sbuf.st_ex_size != 1000) { + printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size); + goto out; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close(2) failed (%s)\n", nt_errstr(status)); + goto out; + } + + /* Re-open with O_TRUNC. */ + status = cli_posix_open(cli1, fname, O_WRONLY|O_TRUNC, 0600, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status)); + goto out; + } + + /* Ensure st_size == 0 */ + status = cli_posix_stat(cli1, fname, &sbuf); + if (!NT_STATUS_IS_OK(status)) { + printf("stat failed (%s)\n", nt_errstr(status)); + goto out; + } + + if (sbuf.st_ex_size != 0) { + printf("O_TRUNC - stat size (%u) != 0\n", (unsigned int)sbuf.st_ex_size); + goto out; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + goto out; + } + + status = cli_posix_unlink(cli1, fname); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX unlink of %s failed (%s)\n", fname, nt_errstr(status)); + goto out; + } + + status = cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX open directory O_RDONLY of %s failed (%s)\n", + dname, nt_errstr(status)); + goto out; + } + + cli_close(cli1, fnum1); + + /* What happens when we try and POSIX open a directory for write ? */ + status = cli_posix_open(cli1, dname, O_RDWR, 0, &fnum1); + if (NT_STATUS_IS_OK(status)) { + printf("POSIX open of directory %s succeeded, " + "should have failed.\n", + dname); + goto out; + } else { + if (!check_both_error(__LINE__, status, ERRDOS, EISDIR, + NT_STATUS_FILE_IS_A_DIRECTORY)) { + goto out; + } + } + + /* Create the file. */ + status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, + 0600, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX create of %s failed (%s)\n", fname, nt_errstr(status)); + goto out; + } + + /* Write some data into it. */ + status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_write failed: %s\n", nt_errstr(status)); + goto out; + } + + cli_close(cli1, fnum1); + + /* Now create a hardlink. */ + status = cli_posix_hardlink(cli1, fname, hname); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX hardlink of %s failed (%s)\n", hname, nt_errstr(status)); + goto out; + } + + /* Now create a symlink. */ + status = cli_posix_symlink(cli1, fname, sname); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX symlink of %s failed (%s)\n", sname, nt_errstr(status)); + goto out; + } + + /* Open the hardlink for read. */ + status = cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX open of %s failed (%s)\n", hname, nt_errstr(status)); + goto out; + } + + status = cli_read(cli1, fnum1, buf, 0, 10, &nread); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX read of %s failed (%s)\n", hname, + nt_errstr(status)); + goto out; + } else if (nread != 10) { + printf("POSIX read of %s failed. Received %ld, expected %d\n", + hname, (unsigned long)nread, 10); + goto out; + } + + if (memcmp(buf, "TEST DATA\n", 10)) { + printf("invalid data read from hardlink\n"); + goto out; + } + + /* Do a POSIX lock/unlock. */ + status = cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX lock failed %s\n", nt_errstr(status)); + goto out; + } + + /* Punch a hole in the locked area. */ + status = cli_posix_unlock(cli1, fnum1, 10, 80); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX unlock failed %s\n", nt_errstr(status)); + goto out; + } + + cli_close(cli1, fnum1); + + /* Open the symlink for read - this should fail. A POSIX + client should not be doing opens on a symlink. */ + status = cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1); + if (NT_STATUS_IS_OK(status)) { + printf("POSIX open of %s succeeded (should have failed)\n", sname); + goto out; + } + ok = check_both_error( + __LINE__, status, ERRDOS, ERRbadpath, + NT_STATUS_OBJECT_NAME_NOT_FOUND); + if (!ok) { + printf("POSIX open of %s should have failed " + "with NT_STATUS_OBJECT_NAME_NOT_FOUND, " + "failed with %s instead.\n", + sname, nt_errstr(status)); + goto out; + } + + status = cli_readlink(cli1, sname, talloc_tos(), &target, NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX readlink on %s failed (%s)\n", sname, nt_errstr(status)); + goto out; + } + + if (strcmp(target, fname) != 0) { + printf("POSIX readlink on %s failed to match name %s (read %s)\n", + sname, fname, target); + goto out; + } + + status = cli_posix_rmdir(cli1, dname); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX rmdir failed (%s)\n", nt_errstr(status)); + goto out; + } + + /* Check directory opens with a specific permission. */ + status = cli_posix_mkdir(cli1, dname, 0700); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX mkdir of %s failed (%s)\n", dname, nt_errstr(status)); + goto out; + } + + /* Ensure st_mode == 0700 */ + status = cli_posix_stat(cli1, dname, &sbuf); + if (!NT_STATUS_IS_OK(status)) { + printf("stat failed (%s)\n", nt_errstr(status)); + goto out; + } + + if ((sbuf.st_ex_mode & 07777) != 0700) { + printf("posix_mkdir - bad permissions 0%o != 0700\n", + (unsigned int)(sbuf.st_ex_mode & 07777)); + goto out; + } + + /* + * Now create a Windows file, and attempt a POSIX unlink. + * This should fail with a sharing violation but due to: + * + * [Bug 9571] Unlink after open causes smbd to panic + * + * ensure we've fixed the lock ordering violation. + */ + + status = cli_ntcreate(cli1, fname_windows, 0, + FILE_READ_DATA|FILE_WRITE_DATA, 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_CREATE, + 0x0, 0x0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("Windows create of %s failed (%s)\n", fname_windows, + nt_errstr(status)); + goto out; + } + + /* Now try posix_unlink. */ + status = cli_posix_unlink(cli1, fname_windows); + if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) { + printf("POSIX unlink of %s should fail " + "with NT_STATUS_SHARING_VIOLATION " + "got %s instead !\n", + fname_windows, + nt_errstr(status)); + goto out; + } + + cli_close(cli1, fnum2); + + printf("Simple POSIX open test passed\n"); + correct = true; + + out: + + if (fnum1 != (uint16_t)-1) { + cli_close(cli1, fnum1); + fnum1 = (uint16_t)-1; + } + + if (fnum2 != (uint16_t)-1) { + cli_close(cli1, fnum2); + fnum2 = (uint16_t)-1; + } + + cli_setatr(cli1, sname, 0, 0); + cli_posix_unlink(cli1, sname); + cli_setatr(cli1, hname, 0, 0); + cli_posix_unlink(cli1, hname); + cli_setatr(cli1, fname, 0, 0); + cli_posix_unlink(cli1, fname); + cli_setatr(cli1, dname, 0, 0); + cli_posix_rmdir(cli1, dname); + cli_setatr(cli1, fname_windows, 0, 0); + cli_posix_unlink(cli1, fname_windows); + + if (!torture_close_connection(cli1)) { + correct = false; + } + + return correct; +} + +/* + Test POSIX and Windows ACLs are rejected on symlinks. + */ +static bool run_acl_symlink_test(int dummy) +{ + static struct cli_state *cli; + const char *fname = "posix_file"; + const char *sname = "posix_symlink"; + uint16_t fnum = (uint16_t)-1; + bool correct = false; + NTSTATUS status; + char *posix_acl = NULL; + size_t posix_acl_len = 0; + char *posix_acl_sym = NULL; + size_t posix_acl_len_sym = 0; + struct security_descriptor *sd = NULL; + TALLOC_CTX *frame = NULL; + + frame = talloc_stackframe(); + + printf("Starting acl symlink test\n"); + + if (!torture_open_connection(&cli, 0)) { + TALLOC_FREE(frame); + return false; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = torture_setup_unix_extensions(cli); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + cli_setatr(cli, fname, 0, 0); + cli_posix_unlink(cli, fname); + cli_setatr(cli, sname, 0, 0); + cli_posix_unlink(cli, sname); + + status = cli_ntcreate(cli, + fname, + 0, + READ_CONTROL_ACCESS, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_CREATE, + 0x0, + 0x0, + &fnum, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ntcreate of %s failed (%s)\n", + fname, + nt_errstr(status)); + goto out; + } + + /* Get the Windows ACL on the file. */ + status = cli_query_secdesc(cli, + fnum, + frame, + &sd); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_query_secdesc failed (%s)\n", + nt_errstr(status)); + goto out; + } + + /* Get the POSIX ACL on the file. */ + status = cli_posix_getacl(cli, + fname, + frame, + &posix_acl_len, + &posix_acl); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_getacl failed (%s)\n", + nt_errstr(status)); + goto out; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + /* Now create a symlink. */ + status = cli_posix_symlink(cli, fname, sname); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed (%s)\n", + sname, + fname, + nt_errstr(status)); + goto out; + } + + /* Open a handle on the symlink for SD set/get should fail. */ + status = cli_ntcreate(cli, + sname, + 0, + READ_CONTROL_ACCESS|SEC_STD_WRITE_DAC, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, + 0x0, + 0x0, + &fnum, + NULL); + + if (NT_STATUS_IS_OK(status)) { + printf("Symlink open for getsd/setsd of %s " + "succeeded (should fail)\n", + sname); + goto out; + } + + /* Try a stat-open on the symlink, should also fail. */ + status = cli_ntcreate(cli, + sname, + 0, + FILE_READ_ATTRIBUTES|FILE_WRITE_ATTRIBUTES, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, + 0x0, + 0x0, + &fnum, + NULL); + + if (NT_STATUS_IS_OK(status)) { + printf("Stat-open of symlink succeeded (should fail)\n"); + goto out; + } + + /* Get the POSIX ACL on the symlink pathname. Should fail. */ + status = cli_posix_getacl(cli, + sname, + frame, + &posix_acl_len_sym, + &posix_acl_sym); + + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("cli_posix_getacl on a symlink gave %s. " + "Should be NT_STATUS_ACCESS_DENIED.\n", + nt_errstr(status)); + goto out; + } + + /* Set the POSIX ACL on the symlink pathname. Should fail. */ + status = cli_posix_setacl(cli, + sname, + posix_acl, + posix_acl_len); + + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("cli_posix_setacl on a symlink gave %s. " + "Should be NT_STATUS_ACCESS_DENIED.\n", + nt_errstr(status)); + goto out; + } + + printf("ACL symlink test passed\n"); + correct = true; + + out: + + if (fnum != (uint16_t)-1) { + cli_close(cli, fnum); + fnum = (uint16_t)-1; + } + + cli_setatr(cli, sname, 0, 0); + cli_posix_unlink(cli, sname); + cli_setatr(cli, fname, 0, 0); + cli_posix_unlink(cli, fname); + + if (!torture_close_connection(cli)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* + Test POSIX can delete a file containing streams. + */ +static bool run_posix_stream_delete(int dummy) +{ + struct cli_state *cli1 = NULL; + struct cli_state *cli2 = NULL; + const char *fname = "streamfile"; + const char *stream_fname = "streamfile:Zone.Identifier:$DATA"; + uint16_t fnum1 = (uint16_t)-1; + bool correct = false; + NTSTATUS status; + TALLOC_CTX *frame = NULL; + + frame = talloc_stackframe(); + + printf("Starting POSIX stream delete test\n"); + + if (!torture_open_connection(&cli1, 0) || + !torture_open_connection(&cli2, 1)) { + TALLOC_FREE(frame); + return false; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + status = torture_setup_unix_extensions(cli2); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Create the file. */ + status = cli_ntcreate(cli1, + fname, + 0, + READ_CONTROL_ACCESS, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_CREATE, + 0x0, + 0x0, + &fnum1, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ntcreate of %s failed (%s)\n", + fname, + nt_errstr(status)); + goto out; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close of %s failed (%s)\n", + fname, + nt_errstr(status)); + goto out; + } + fnum1 = (uint16_t)-1; + + /* Now create the stream. */ + status = cli_ntcreate(cli1, + stream_fname, + 0, + FILE_WRITE_DATA, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, + 0x0, + 0x0, + &fnum1, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ntcreate of %s failed (%s)\n", + stream_fname, + nt_errstr(status)); + goto out; + } + + /* Leave the stream handle open... */ + + /* POSIX unlink should fail. */ + status = cli_posix_unlink(cli2, fname); + if (NT_STATUS_IS_OK(status)) { + printf("cli_posix_unlink of %s succeeded, should have failed\n", + fname); + goto out; + } + + if (!NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) { + printf("cli_posix_unlink of %s failed with (%s) " + "should have been NT_STATUS_SHARING_VIOLATION\n", + fname, + nt_errstr(status)); + goto out; + } + + /* Close the stream handle. */ + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close of %s failed (%s)\n", + stream_fname, + nt_errstr(status)); + goto out; + } + fnum1 = (uint16_t)-1; + + /* POSIX unlink after stream handle closed should succeed. */ + status = cli_posix_unlink(cli2, fname); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_unlink of %s failed (%s)\n", + fname, + nt_errstr(status)); + goto out; + } + + printf("POSIX stream delete test passed\n"); + correct = true; + + out: + + if (fnum1 != (uint16_t)-1) { + cli_close(cli1, fnum1); + fnum1 = (uint16_t)-1; + } + + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + if (!torture_close_connection(cli1)) { + correct = false; + } + if (!torture_close_connection(cli2)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +/* + Test setting EA's are rejected on symlinks. + */ +static bool run_ea_symlink_test(int dummy) +{ + static struct cli_state *cli; + const char *fname = "posix_file_ea"; + const char *sname = "posix_symlink_ea"; + const char *ea_name = "testea_name"; + const char *ea_value = "testea_value"; + uint16_t fnum = (uint16_t)-1; + bool correct = false; + NTSTATUS status; + size_t i, num_eas; + struct ea_struct *eas = NULL; + TALLOC_CTX *frame = NULL; + + frame = talloc_stackframe(); + + printf("Starting EA symlink test\n"); + + if (!torture_open_connection(&cli, 0)) { + TALLOC_FREE(frame); + return false; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = torture_setup_unix_extensions(cli); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + cli_setatr(cli, fname, 0, 0); + cli_posix_unlink(cli, fname); + cli_setatr(cli, sname, 0, 0); + cli_posix_unlink(cli, sname); + + status = cli_ntcreate(cli, + fname, + 0, + READ_CONTROL_ACCESS, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_CREATE, + 0x0, + 0x0, + &fnum, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_ntcreate of %s failed (%s)\n", + fname, + nt_errstr(status)); + goto out; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", + nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + /* Set an EA on the path. */ + status = cli_set_ea_path(cli, + fname, + ea_name, + ea_value, + strlen(ea_value)+1); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_set_ea_path failed (%s)\n", + nt_errstr(status)); + goto out; + } + + /* Now create a symlink. */ + status = cli_posix_symlink(cli, fname, sname); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed (%s)\n", + sname, + fname, + nt_errstr(status)); + goto out; + } + + /* Get the EA list on the path. Should return value set. */ + status = cli_get_ea_list_path(cli, + fname, + frame, + &num_eas, + &eas); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_get_ea_list_path failed (%s)\n", + nt_errstr(status)); + goto out; + } + + /* Ensure the EA we set is there. */ + for (i=0; iconn, sockops); + + status = torture_setup_unix_extensions(cli); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + cli_setatr(cli, fname, 0, 0); + cli_posix_unlink(cli, fname); + + /* Open the file twice. */ + status = cli_posix_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, + 0600, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("First POSIX open of %s failed\n", fname); + goto out; + } + + status = cli_posix_open(cli, fname, O_RDWR, 0, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("First POSIX open of %s failed\n", fname); + goto out; + } + + /* Set a 0-50 lock on fnum1. */ + status = cli_posix_lock(cli, fnum1, 0, 50, false, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX lock (1) failed %s\n", nt_errstr(status)); + goto out; + } + + /* Set a 60-100 lock on fnum2. */ + status = cli_posix_lock(cli, fnum2, 60, 100, false, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX lock (2) failed %s\n", nt_errstr(status)); + goto out; + } + + /* close fnum1 - 0-50 lock should go away. */ + status = cli_close(cli, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", + nt_errstr(status)); + goto out; + } + fnum1 = (uint16_t)-1; + + /* Change the lock context. */ + cli_setpid(cli, cli_getpid(cli) + 1); + + /* Re-open fnum1. */ + status = cli_posix_open(cli, fname, O_RDWR, 0, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("Third POSIX open of %s failed\n", fname); + goto out; + } + + /* 60-100 lock should still be there. */ + status = cli_posix_lock(cli, fnum1, 60, 100, false, WRITE_LOCK); + if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) { + printf("POSIX lock 60-100 not there %s\n", nt_errstr(status)); + goto out; + } + + /* 0-50 lock should be gone. */ + status = cli_posix_lock(cli, fnum1, 0, 50, false, WRITE_LOCK); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX lock 0-50 failed %s\n", nt_errstr(status)); + goto out; + } + + printf("POSIX OFD lock test passed\n"); + correct = true; + + out: + + if (fnum1 != (uint16_t)-1) { + cli_close(cli, fnum1); + fnum1 = (uint16_t)-1; + } + if (fnum2 != (uint16_t)-1) { + cli_close(cli, fnum2); + fnum2 = (uint16_t)-1; + } + + cli_setatr(cli, fname, 0, 0); + cli_posix_unlink(cli, fname); + + if (!torture_close_connection(cli)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +struct posix_blocking_state { + struct tevent_context *ev; + struct cli_state *cli1; + uint16_t fnum1; + struct cli_state *cli2; + uint16_t fnum2; + bool gotblocked; + bool gotecho; +}; + +static void posix_blocking_locked(struct tevent_req *subreq); +static void posix_blocking_gotblocked(struct tevent_req *subreq); +static void posix_blocking_gotecho(struct tevent_req *subreq); +static void posix_blocking_unlocked(struct tevent_req *subreq); + +static struct tevent_req *posix_blocking_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli1, + uint16_t fnum1, + struct cli_state *cli2, + uint16_t fnum2) +{ + struct tevent_req *req = NULL, *subreq = NULL; + struct posix_blocking_state *state = NULL; + + req = tevent_req_create(mem_ctx, &state, struct posix_blocking_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli1 = cli1; + state->fnum1 = fnum1; + state->cli2 = cli2; + state->fnum2 = fnum2; + + subreq = cli_posix_lock_send( + state, + state->ev, + state->cli1, + state->fnum1, + 0, + 1, + false, + WRITE_LOCK); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, posix_blocking_locked, req); + return req; +} + +static void posix_blocking_locked(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct posix_blocking_state *state = tevent_req_data( + req, struct posix_blocking_state); + NTSTATUS status; + + status = cli_posix_lock_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + + subreq = cli_posix_lock_send( + state, + state->ev, + state->cli2, + state->fnum2, + 0, + 1, + true, + WRITE_LOCK); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, posix_blocking_gotblocked, req); + + /* Make sure the blocking request is delivered */ + subreq = cli_echo_send( + state, + state->ev, + state->cli2, + 1, + (DATA_BLOB) { .data = (uint8_t *)state, .length = 1 }); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, posix_blocking_gotecho, req); +} + +static void posix_blocking_gotblocked(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct posix_blocking_state *state = tevent_req_data( + req, struct posix_blocking_state); + NTSTATUS status; + + status = cli_posix_lock_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + if (!state->gotecho) { + printf("blocked req got through before echo\n"); + tevent_req_nterror(req, NT_STATUS_INVALID_LOCK_SEQUENCE); + return; + } + tevent_req_done(req); +} + +static void posix_blocking_gotecho(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct posix_blocking_state *state = tevent_req_data( + req, struct posix_blocking_state); + NTSTATUS status; + + status = cli_echo_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + if (state->gotblocked) { + printf("blocked req got through before echo\n"); + tevent_req_nterror(req, NT_STATUS_INVALID_LOCK_SEQUENCE); + return; + } + state->gotecho = true; + + subreq = cli_posix_lock_send( + state, + state->ev, + state->cli1, + state->fnum1, + 0, + 1, + false, + UNLOCK_LOCK); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, posix_blocking_unlocked, req); +} + +static void posix_blocking_unlocked(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + + status = cli_posix_lock_recv(subreq); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + /* tevent_req_done in posix_blocking_gotlocked */ +} + +static NTSTATUS posix_blocking_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static bool run_posix_blocking_lock(int dummy) +{ + struct tevent_context *ev = NULL; + struct cli_state *cli1 = NULL, *cli2 = NULL; + const char *fname = "posix_blocking"; + uint16_t fnum1 = UINT16_MAX, fnum2 = UINT16_MAX; + struct tevent_req *req = NULL; + NTSTATUS status; + bool ret = false; + bool ok; + + printf("Starting posix blocking lock test\n"); + + ev = samba_tevent_context_init(NULL); + if (ev == NULL) { + return false; + } + + ok = torture_open_connection(&cli1, 0); + if (!ok) { + goto fail; + } + ok = torture_open_connection(&cli2, 0); + if (!ok) { + goto fail; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + status = torture_setup_unix_extensions(cli1); + if (!NT_STATUS_IS_OK(status)) { + return false; + } + + status = torture_setup_unix_extensions(cli2); + if (!NT_STATUS_IS_OK(status)) { + return false; + } + + cli_setatr(cli1, fname, 0, 0); + cli_posix_unlink(cli1, fname); + + status = cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, + 0600, &fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("First POSIX open of %s failed: %s\n", + fname, + nt_errstr(status)); + goto fail; + } + + status = cli_posix_open(cli2, fname, O_RDWR, 0600, &fnum2); + if (!NT_STATUS_IS_OK(status)) { + printf("Second POSIX open of %s failed: %s\n", + fname, + nt_errstr(status)); + goto fail; + } + + req = posix_blocking_send(ev, ev, cli1, fnum1, cli2, fnum2); + if (req == NULL) { + printf("cli_posix_blocking failed\n"); + goto fail; + } + + ok = tevent_req_poll_ntstatus(req, ev, &status); + if (!ok) { + printf("tevent_req_poll_ntstatus failed: %s\n", + nt_errstr(status)); + goto fail; + } + status = posix_blocking_recv(req); + TALLOC_FREE(req); + if (!NT_STATUS_IS_OK(status)) { + printf("posix_blocking_recv returned %s\n", + nt_errstr(status)); + goto fail; + } + + ret = true; +fail: + + if (fnum1 != UINT16_MAX) { + cli_close(cli1, fnum1); + fnum1 = UINT16_MAX; + } + if (fnum2 != UINT16_MAX) { + cli_close(cli2, fnum2); + fnum2 = UINT16_MAX; + } + + if (cli1 != NULL) { + cli_setatr(cli1, fname, 0, 0); + cli_posix_unlink(cli1, fname); + } + + ok = true; + + if (cli1 != NULL) { + ok &= torture_close_connection(cli1); + cli1 = NULL; + } + if (cli2 != NULL) { + ok &= torture_close_connection(cli2); + cli2 = NULL; + } + + if (!ok) { + ret = false; + } + TALLOC_FREE(ev); + return ret; +} + +/* + Test POSIX mkdir is case-sensitive. + */ +static bool run_posix_mkdir_test(int dummy) +{ + static struct cli_state *cli; + const char *fname_foo = "POSIX_foo"; + const char *fname_foo_Foo = "POSIX_foo/Foo"; + const char *fname_foo_foo = "POSIX_foo/foo"; + const char *fname_Foo = "POSIX_Foo"; + const char *fname_Foo_Foo = "POSIX_Foo/Foo"; + const char *fname_Foo_foo = "POSIX_Foo/foo"; + bool correct = false; + NTSTATUS status; + TALLOC_CTX *frame = NULL; + uint16_t fnum = (uint16_t)-1; + + frame = talloc_stackframe(); + + printf("Starting POSIX mkdir test\n"); + + if (!torture_open_connection(&cli, 0)) { + TALLOC_FREE(frame); + return false; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = torture_setup_unix_extensions(cli); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + cli_posix_rmdir(cli, fname_foo_foo); + cli_posix_rmdir(cli, fname_foo_Foo); + cli_posix_rmdir(cli, fname_foo); + + cli_posix_rmdir(cli, fname_Foo_foo); + cli_posix_rmdir(cli, fname_Foo_Foo); + cli_posix_rmdir(cli, fname_Foo); + + /* + * Create a file POSIX_foo then try + * and use it in a directory path by + * doing mkdir POSIX_foo/bar. + * The mkdir should fail with + * NT_STATUS_OBJECT_PATH_NOT_FOUND + */ + + status = cli_posix_open(cli, + fname_foo, + O_RDWR|O_CREAT, + 0666, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open of %s failed error %s\n", + fname_foo, + nt_errstr(status)); + goto out; + } + + status = cli_posix_mkdir(cli, fname_foo_foo, 0777); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("cli_posix_mkdir of %s should fail with " + "NT_STATUS_OBJECT_PATH_NOT_FOUND got " + "%s instead\n", + fname_foo_foo, + nt_errstr(status)); + goto out; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_close failed %s\n", nt_errstr(status)); + goto out; + } + fnum = (uint16_t)-1; + + status = cli_posix_unlink(cli, fname_foo); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_unlink of %s failed error %s\n", + fname_foo, + nt_errstr(status)); + goto out; + } + + /* + * Now we've deleted everything, posix_mkdir, posix_rmdir, + * posix_open, posix_unlink, on + * POSIX_foo/foo should return NT_STATUS_OBJECT_PATH_NOT_FOUND + * not silently create POSIX_foo/foo. + */ + + status = cli_posix_mkdir(cli, fname_foo_foo, 0777); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("cli_posix_mkdir of %s should fail with " + "NT_STATUS_OBJECT_PATH_NOT_FOUND got " + "%s instead\n", + fname_foo_foo, + nt_errstr(status)); + goto out; + } + + status = cli_posix_rmdir(cli, fname_foo_foo); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("cli_posix_rmdir of %s should fail with " + "NT_STATUS_OBJECT_PATH_NOT_FOUND got " + "%s instead\n", + fname_foo_foo, + nt_errstr(status)); + goto out; + } + + status = cli_posix_open(cli, + fname_foo_foo, + O_RDWR|O_CREAT, + 0666, + &fnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("cli_posix_open of %s should fail with " + "NT_STATUS_OBJECT_PATH_NOT_FOUND got " + "%s instead\n", + fname_foo_foo, + nt_errstr(status)); + goto out; + } + + status = cli_posix_unlink(cli, fname_foo_foo); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) { + printf("cli_posix_unlink of %s should fail with " + "NT_STATUS_OBJECT_PATH_NOT_FOUND got " + "%s instead\n", + fname_foo_foo, + nt_errstr(status)); + goto out; + } + + status = cli_posix_mkdir(cli, fname_foo, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s failed\n", fname_foo); + goto out; + } + + status = cli_posix_mkdir(cli, fname_Foo, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s failed\n", fname_Foo); + goto out; + } + + status = cli_posix_mkdir(cli, fname_foo_foo, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s failed\n", fname_foo_foo); + goto out; + } + + status = cli_posix_mkdir(cli, fname_foo_Foo, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s failed\n", fname_foo_Foo); + goto out; + } + + status = cli_posix_mkdir(cli, fname_Foo_foo, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s failed\n", fname_Foo_foo); + goto out; + } + + status = cli_posix_mkdir(cli, fname_Foo_Foo, 0777); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s failed\n", fname_Foo_Foo); + goto out; + } + + printf("POSIX mkdir test passed\n"); + correct = true; + + out: + + if (fnum != (uint16_t)-1) { + cli_close(cli, fnum); + fnum = (uint16_t)-1; + } + + cli_posix_rmdir(cli, fname_foo_foo); + cli_posix_rmdir(cli, fname_foo_Foo); + cli_posix_rmdir(cli, fname_foo); + + cli_posix_rmdir(cli, fname_Foo_foo); + cli_posix_rmdir(cli, fname_Foo_Foo); + cli_posix_rmdir(cli, fname_Foo); + + if (!torture_close_connection(cli)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +struct posix_acl_oplock_state { + struct tevent_context *ev; + struct cli_state *cli; + bool *got_break; + bool *acl_ret; + NTSTATUS status; +}; + +static void posix_acl_oplock_got_break(struct tevent_req *req) +{ + struct posix_acl_oplock_state *state = tevent_req_callback_data( + req, struct posix_acl_oplock_state); + uint16_t fnum; + uint8_t level; + NTSTATUS status; + + status = cli_smb_oplock_break_waiter_recv(req, &fnum, &level); + TALLOC_FREE(req); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_smb_oplock_break_waiter_recv returned %s\n", + nt_errstr(status)); + return; + } + *state->got_break = true; + + req = cli_oplock_ack_send(state, state->ev, state->cli, fnum, + NO_OPLOCK); + if (req == NULL) { + printf("cli_oplock_ack_send failed\n"); + return; + } +} + +static void posix_acl_oplock_got_acl(struct tevent_req *req) +{ + struct posix_acl_oplock_state *state = tevent_req_callback_data( + req, struct posix_acl_oplock_state); + size_t ret_size = 0; + char *ret_data = NULL; + + state->status = cli_posix_getacl_recv(req, + state, + &ret_size, + &ret_data); + + if (!NT_STATUS_IS_OK(state->status)) { + printf("cli_posix_getacl_recv returned %s\n", + nt_errstr(state->status)); + } + *state->acl_ret = true; +} + +static bool run_posix_acl_oplock_test(int dummy) +{ + struct tevent_context *ev; + struct cli_state *cli1, *cli2; + struct tevent_req *oplock_req, *getacl_req; + const char *fname = "posix_acl_oplock"; + uint16_t fnum; + int saved_use_oplocks = use_oplocks; + NTSTATUS status; + bool correct = true; + bool got_break = false; + bool acl_ret = false; + + struct posix_acl_oplock_state *state; + + printf("starting posix_acl_oplock test\n"); + + if (!torture_open_connection(&cli1, 0)) { + use_level_II_oplocks = false; + use_oplocks = saved_use_oplocks; + return false; + } + + if (!torture_open_connection(&cli2, 1)) { + use_level_II_oplocks = false; + use_oplocks = saved_use_oplocks; + return false; + } + + /* Setup posix on cli2 only. */ + status = torture_setup_unix_extensions(cli2); + if (!NT_STATUS_IS_OK(status)) { + return false; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + smbXcli_conn_set_sockopt(cli2->conn, sockops); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Create the file on the Windows connection. */ + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + + status = cli_close(cli1, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close1 failed (%s)\n", nt_errstr(status)); + return false; + } + + cli1->use_oplocks = true; + + /* Open with oplock. */ + status = cli_ntcreate(cli1, + fname, + 0, + FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN, + 0, + 0, + &fnum, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + printf("tevent_context_init failed\n"); + return false; + } + + state = talloc_zero(ev, struct posix_acl_oplock_state); + if (state == NULL) { + printf("talloc failed\n"); + return false; + } + state->ev = ev; + state->cli = cli1; + state->got_break = &got_break; + state->acl_ret = &acl_ret; + + oplock_req = cli_smb_oplock_break_waiter_send( + talloc_tos(), ev, cli1); + if (oplock_req == NULL) { + printf("cli_smb_oplock_break_waiter_send failed\n"); + return false; + } + tevent_req_set_callback(oplock_req, posix_acl_oplock_got_break, state); + + /* Get ACL on POSIX connection - should break oplock. */ + getacl_req = cli_posix_getacl_send(talloc_tos(), + ev, + cli2, + fname); + if (getacl_req == NULL) { + printf("cli_posix_getacl_send failed\n"); + return false; + } + tevent_req_set_callback(getacl_req, posix_acl_oplock_got_acl, state); + + while (!got_break || !acl_ret) { + int ret; + ret = tevent_loop_once(ev); + if (ret == -1) { + printf("tevent_loop_once failed: %s\n", + strerror(errno)); + return false; + } + } + + if (!NT_STATUS_IS_OK(state->status)) { + printf("getacl failed (%s)\n", nt_errstr(state->status)); + correct = false; + } + + status = cli_close(cli1, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close2 failed (%s)\n", nt_errstr(status)); + correct = false; + } + + status = cli_unlink(cli1, + fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + correct = false; + } + + if (!torture_close_connection(cli1)) { + correct = false; + } + if (!torture_close_connection(cli2)) { + correct = false; + } + + if (!got_break) { + correct = false; + } + + printf("finished posix acl oplock test\n"); + + return correct; +} + +static bool run_posix_acl_shareroot_test(int dummy) +{ + struct cli_state *cli; + NTSTATUS status; + bool correct = false; + char *posix_acl = NULL; + size_t posix_acl_len = 0; + uint16_t num_file_acls = 0; + uint16_t num_dir_acls = 0; + uint16_t i; + uint32_t expected_size = 0; + bool got_user = false; + bool got_group = false; + bool got_other = false; + TALLOC_CTX *frame = NULL; + + frame = talloc_stackframe(); + + printf("starting posix_acl_shareroot test\n"); + + if (!torture_open_connection(&cli, 0)) { + TALLOC_FREE(frame); + return false; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = torture_setup_unix_extensions(cli); + if (!NT_STATUS_IS_OK(status)) { + printf("Failed to setup unix extensions\n"); + goto out; + } + + /* Get the POSIX ACL on the root of the share. */ + status = cli_posix_getacl(cli, + ".", + frame, + &posix_acl_len, + &posix_acl); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_getacl of '.' failed (%s)\n", + nt_errstr(status)); + goto out; + } + + if (posix_acl_len < 6 || + SVAL(posix_acl,0) != SMB_POSIX_ACL_VERSION) { + printf("getfacl ., unknown POSIX acl version %u.\n", + (unsigned int)CVAL(posix_acl,0) ); + goto out; + } + + num_file_acls = SVAL(posix_acl,2); + num_dir_acls = SVAL(posix_acl,4); + expected_size = SMB_POSIX_ACL_HEADER_SIZE + + SMB_POSIX_ACL_ENTRY_SIZE* + (num_file_acls+num_dir_acls); + + if (posix_acl_len != expected_size) { + printf("incorrect POSIX acl buffer size " + "(should be %u, was %u).\n", + (unsigned int)expected_size, + (unsigned int)posix_acl_len); + goto out; + } + + /* + * We don't need to know what the ACL's are + * we just need to know we have at least 3 + * file entries (u,g,o). + */ + + for (i = 0; i < num_file_acls; i++) { + unsigned char tagtype = + CVAL(posix_acl, + SMB_POSIX_ACL_HEADER_SIZE+ + (i*SMB_POSIX_ACL_ENTRY_SIZE)); + + switch(tagtype) { + case SMB_POSIX_ACL_USER_OBJ: + got_user = true; + break; + case SMB_POSIX_ACL_GROUP_OBJ: + got_group = true; + break; + case SMB_POSIX_ACL_OTHER: + got_other = true; + break; + default: + break; + } + } + + if (!got_user) { + printf("Missing user entry\n"); + goto out; + } + + if (!got_group) { + printf("Missing group entry\n"); + goto out; + } + + if (!got_other) { + printf("Missing other entry\n"); + goto out; + } + + correct = true; + + out: + + if (!torture_close_connection(cli)) { + correct = false; + } + + printf("finished posix acl shareroot test\n"); + TALLOC_FREE(frame); + + return correct; +} + +static uint32_t open_attrs_table[] = { + FILE_ATTRIBUTE_NORMAL, + FILE_ATTRIBUTE_ARCHIVE, + FILE_ATTRIBUTE_READONLY, + FILE_ATTRIBUTE_HIDDEN, + FILE_ATTRIBUTE_SYSTEM, + + FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY, + FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, + FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, + FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, + FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, + FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM, + + FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, + FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, + FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM, + FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM, +}; + +struct trunc_open_results { + unsigned int num; + uint32_t init_attr; + uint32_t trunc_attr; + uint32_t result_attr; +}; + +static struct trunc_open_results attr_results[] = { + { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE }, + { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE }, + { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY }, + { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE }, + { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE }, + { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY }, + { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN }, + { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN }, + { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN }, + { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM }, + { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM }, + { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }, + { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN }, + { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN }, + { 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 }, + { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM }, + { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM }, + { 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 }, + { 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 }, + { 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 }, + { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN }, + { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN }, + { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN }, + { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM }, + { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM }, + { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM } +}; + +static bool run_openattrtest(int dummy) +{ + static struct cli_state *cli1; + const char *fname = "\\openattr.file"; + uint16_t fnum1; + bool correct = True; + uint32_t attr; + unsigned int i, j, k, l; + NTSTATUS status; + + printf("starting open attr test\n"); + + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32_t); i++) { + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, + open_attrs_table[i], FILE_SHARE_NONE, + FILE_OVERWRITE_IF, 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("open %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status)); + return False; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close %d (1) of %s failed (%s)\n", i, fname, nt_errstr(status)); + return False; + } + + for (j = 0; j < sizeof(open_attrs_table)/sizeof(uint32_t); j++) { + status = cli_ntcreate(cli1, fname, 0, + FILE_READ_DATA|FILE_WRITE_DATA, + open_attrs_table[j], + FILE_SHARE_NONE, FILE_OVERWRITE, + 0, 0, &fnum1, NULL); + if (!NT_STATUS_IS_OK(status)) { + for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) { + if (attr_results[l].num == k) { + printf("[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(0x%x:%s)\n", + k, open_attrs_table[i], + open_attrs_table[j], + fname, NT_STATUS_V(status), nt_errstr(status)); + correct = False; + } + } + + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + printf("[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s\n", + k, open_attrs_table[i], open_attrs_table[j], + nt_errstr(status)); + correct = False; + } +#if 0 + printf("[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]); +#endif + k++; + continue; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + printf("close %d (2) of %s failed (%s)\n", j, fname, nt_errstr(status)); + return False; + } + + status = cli_getatr(cli1, fname, &attr, NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("getatr(2) failed (%s)\n", nt_errstr(status)); + return False; + } + +#if 0 + printf("[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n", + k, open_attrs_table[i], open_attrs_table[j], attr ); +#endif + + for (l = 0; l < sizeof(attr_results)/sizeof(struct trunc_open_results); l++) { + if (attr_results[l].num == k) { + if (attr != attr_results[l].result_attr || + open_attrs_table[i] != attr_results[l].init_attr || + open_attrs_table[j] != attr_results[l].trunc_attr) { + printf("getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n", + open_attrs_table[i], + open_attrs_table[j], + (unsigned int)attr, + attr_results[l].result_attr); + correct = False; + } + break; + } + } + k++; + } + } + + cli_setatr(cli1, fname, 0, 0); + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + printf("open attr test %s.\n", correct ? "passed" : "failed"); + + if (!torture_close_connection(cli1)) { + correct = False; + } + return correct; +} + +static NTSTATUS list_fn(struct file_info *finfo, + const char *name, void *state) +{ + int *matched = (int *)state; + if (matched != NULL) { + *matched += 1; + } + return NT_STATUS_OK; +} + +/* + test directory listing speed + */ +static bool run_dirtest(int dummy) +{ + int i; + static struct cli_state *cli; + uint16_t fnum; + struct timeval core_start; + bool correct = True; + int matched; + + printf("starting directory test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + srandom(0); + for (i=0;iname); + + if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0) + return NT_STATUS_OK; + + if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) { + if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname))) + printf("del_fn: failed to rmdir %s\n,", fname ); + } else { + if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) + printf("del_fn: failed to unlink %s\n,", fname ); + } + return NT_STATUS_OK; +} + + +/* + send a raw ioctl - used by the torture code +*/ +static NTSTATUS cli_raw_ioctl(struct cli_state *cli, + uint16_t fnum, + uint32_t code, + DATA_BLOB *blob) +{ + uint16_t vwv[3]; + NTSTATUS status; + + PUSH_LE_U16(vwv + 0, 0, fnum); + PUSH_LE_U16(vwv + 1, 0, code >> 16); + PUSH_LE_U16(vwv + 2, 0, (code & 0xFFFF)); + + status = cli_smb(talloc_tos(), + cli, + SMBioctl, + 0, + 3, + vwv, + 0, + NULL, + NULL, + 0, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + *blob = data_blob_null; + return NT_STATUS_OK; +} + +/* + sees what IOCTLs are supported + */ +bool torture_ioctl_test(int dummy) +{ + static struct cli_state *cli; + uint16_t device, function; + uint16_t fnum; + const char *fname = "\\ioctl.dat"; + DATA_BLOB blob; + NTSTATUS status; + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + printf("starting ioctl test\n"); + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_openx(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open of %s failed (%s)\n", fname, nt_errstr(status)); + return False; + } + + status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob); + printf("ioctl device info: %s\n", nt_errstr(status)); + + status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob); + printf("ioctl job info: %s\n", nt_errstr(status)); + + for (device=0;device<0x100;device++) { + printf("ioctl test with device = 0x%x\n", device); + for (function=0;function<0x100;function++) { + uint32_t code = (device<<16) | function; + + status = cli_raw_ioctl(cli, fnum, code, &blob); + + if (NT_STATUS_IS_OK(status)) { + printf("ioctl 0x%x OK : %d bytes\n", (int)code, + (int)blob.length); + data_blob_free(&blob); + } + } + } + + if (!torture_close_connection(cli)) { + return False; + } + + return True; +} + + +/* + tries variants of chkpath + */ +bool torture_chkpath_test(int dummy) +{ + static struct cli_state *cli; + uint16_t fnum; + bool ret; + NTSTATUS status; + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + printf("starting chkpath test\n"); + + /* cleanup from an old run */ + torture_deltree(cli, "\\chkpath.dir"); + + status = cli_mkdir(cli, "\\chkpath.dir"); + if (!NT_STATUS_IS_OK(status)) { + printf("mkdir1 failed : %s\n", nt_errstr(status)); + return False; + } + + status = cli_mkdir(cli, "\\chkpath.dir\\dir2"); + if (!NT_STATUS_IS_OK(status)) { + printf("mkdir2 failed : %s\n", nt_errstr(status)); + return False; + } + + status = cli_openx(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, + DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open1 failed (%s)\n", nt_errstr(status)); + return False; + } + cli_close(cli, fnum); + + status = cli_chkpath(cli, "\\chkpath.dir"); + if (!NT_STATUS_IS_OK(status)) { + printf("chkpath1 failed: %s\n", nt_errstr(status)); + ret = False; + } + + status = cli_chkpath(cli, "\\chkpath.dir\\dir2"); + if (!NT_STATUS_IS_OK(status)) { + printf("chkpath2 failed: %s\n", nt_errstr(status)); + ret = False; + } + + status = cli_chkpath(cli, "\\chkpath.dir\\foo.txt"); + if (!NT_STATUS_IS_OK(status)) { + ret = check_error(__LINE__, status, ERRDOS, ERRbadpath, + NT_STATUS_NOT_A_DIRECTORY); + } else { + printf("* chkpath on a file should fail\n"); + ret = False; + } + + status = cli_chkpath(cli, "\\chkpath.dir\\bar.txt"); + if (!NT_STATUS_IS_OK(status)) { + ret = check_error(__LINE__, status, ERRDOS, ERRbadfile, + NT_STATUS_OBJECT_NAME_NOT_FOUND); + } else { + printf("* chkpath on a non existent file should fail\n"); + ret = False; + } + + status = cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt"); + if (!NT_STATUS_IS_OK(status)) { + ret = check_error(__LINE__, status, ERRDOS, ERRbadpath, + NT_STATUS_OBJECT_PATH_NOT_FOUND); + } else { + printf("* chkpath on a non existent component should fail\n"); + ret = False; + } + + torture_deltree(cli, "\\chkpath.dir"); + + if (!torture_close_connection(cli)) { + return False; + } + + return ret; +} + +static bool run_eatest(int dummy) +{ + static struct cli_state *cli; + const char *fname = "\\eatest.txt"; + bool correct = True; + uint16_t fnum; + size_t i, num_eas; + struct ea_struct *ea_list = NULL; + TALLOC_CTX *mem_ctx = talloc_init("eatest"); + NTSTATUS status; + + printf("starting eatest\n"); + + if (!torture_open_connection(&cli, 0)) { + talloc_destroy(mem_ctx); + return False; + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + status = cli_ntcreate(cli, fname, 0, + FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE, + FILE_SHARE_NONE, FILE_OVERWRITE_IF, + 0x4044, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("open failed - %s\n", nt_errstr(status)); + talloc_destroy(mem_ctx); + return False; + } + + for (i = 0; i < 10; i++) { + fstring ea_name, ea_val; + + slprintf(ea_name, sizeof(ea_name), "EA_%zu", i); + memset(ea_val, (char)i+1, i+1); + status = cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1); + if (!NT_STATUS_IS_OK(status)) { + printf("ea_set of name %s failed - %s\n", ea_name, + nt_errstr(status)); + talloc_destroy(mem_ctx); + return False; + } + } + + cli_close(cli, fnum); + for (i = 0; i < 10; i++) { + fstring ea_name, ea_val; + + slprintf(ea_name, sizeof(ea_name), "EA_%zu", i+10); + memset(ea_val, (char)i+1, i+1); + status = cli_set_ea_path(cli, fname, ea_name, ea_val, i+1); + if (!NT_STATUS_IS_OK(status)) { + printf("ea_set of name %s failed - %s\n", ea_name, + nt_errstr(status)); + talloc_destroy(mem_ctx); + return False; + } + } + + status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list); + if (!NT_STATUS_IS_OK(status)) { + printf("ea_get list failed - %s\n", nt_errstr(status)); + correct = False; + } + + printf("num_eas = %d\n", (int)num_eas); + + if (num_eas != 20) { + printf("Should be 20 EA's stored... failing.\n"); + correct = False; + } + + for (i = 0; i < num_eas; i++) { + printf("%zu: ea_name = %s. Val = ", i, ea_list[i].name); + dump_data(0, ea_list[i].value.data, + ea_list[i].value.length); + } + + /* Setting EA's to zero length deletes them. Test this */ + printf("Now deleting all EA's - case independent....\n"); + +#if 1 + cli_set_ea_path(cli, fname, "", "", 0); +#else + for (i = 0; i < 20; i++) { + fstring ea_name; + slprintf(ea_name, sizeof(ea_name), "ea_%d", i); + status = cli_set_ea_path(cli, fname, ea_name, "", 0); + if (!NT_STATUS_IS_OK(status)) { + printf("ea_set of name %s failed - %s\n", ea_name, + nt_errstr(status)); + talloc_destroy(mem_ctx); + return False; + } + } +#endif + + status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list); + if (!NT_STATUS_IS_OK(status)) { + printf("ea_get list failed - %s\n", nt_errstr(status)); + correct = False; + } + + printf("num_eas = %d\n", (int)num_eas); + for (i = 0; i < num_eas; i++) { + printf("%zu: ea_name = %s. Val = ", i, ea_list[i].name); + dump_data(0, ea_list[i].value.data, + ea_list[i].value.length); + } + + if (num_eas != 0) { + printf("deleting EA's failed.\n"); + correct = False; + } + + /* Try and delete a non existent EA. */ + status = cli_set_ea_path(cli, fname, "foo", "", 0); + if (!NT_STATUS_IS_OK(status)) { + printf("deleting non-existent EA 'foo' should succeed. %s\n", + nt_errstr(status)); + correct = False; + } + + talloc_destroy(mem_ctx); + if (!torture_close_connection(cli)) { + correct = False; + } + + return correct; +} + +static bool run_dirtest1(int dummy) +{ + int i; + static struct cli_state *cli; + uint16_t fnum; + int num_seen; + bool correct = True; + + printf("starting directory test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli); + cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli); + cli_rmdir(cli, "\\LISTDIR"); + cli_mkdir(cli, "\\LISTDIR"); + + /* Create 1000 files and 1000 directories. */ + for (i=0;i<1000;i++) { + fstring fname; + slprintf(fname, sizeof(fname), "\\LISTDIR\\f%d", i); + if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_ARCHIVE, + FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, + 0, 0, &fnum, NULL))) { + fprintf(stderr,"Failed to open %s\n", fname); + return False; + } + cli_close(cli, fnum); + } + for (i=0;i<1000;i++) { + fstring fname; + slprintf(fname, sizeof(fname), "\\LISTDIR\\d%d", i); + if (!NT_STATUS_IS_OK(cli_mkdir(cli, fname))) { + fprintf(stderr,"Failed to open %s\n", fname); + return False; + } + } + + /* Now ensure that doing an old list sees both files and directories. */ + num_seen = 0; + cli_list_old(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen); + printf("num_seen = %d\n", num_seen ); + /* We should see 100 files + 1000 directories + . and .. */ + if (num_seen != 2002) + correct = False; + + /* Ensure if we have the "must have" bits we only see the + * relevant entries. + */ + num_seen = 0; + cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_DIRECTORY<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen); + printf("num_seen = %d\n", num_seen ); + if (num_seen != 1002) + correct = False; + + num_seen = 0; + cli_list_old(cli, "\\LISTDIR\\*", (FILE_ATTRIBUTE_ARCHIVE<<8)|FILE_ATTRIBUTE_DIRECTORY, list_fn, &num_seen); + printf("num_seen = %d\n", num_seen ); + if (num_seen != 1000) + correct = False; + + /* Delete everything. */ + cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli); + cli_list(cli, "\\LISTDIR\\*", FILE_ATTRIBUTE_DIRECTORY, del_fn, cli); + cli_rmdir(cli, "\\LISTDIR"); + +#if 0 + printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL)); + printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL)); + printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL)); +#endif + + if (!torture_close_connection(cli)) { + correct = False; + } + + printf("finished dirtest1\n"); + + return correct; +} + +static bool run_error_map_extract(int dummy) { + + static struct cli_state *c_dos; + static struct cli_state *c_nt; + NTSTATUS status; + + uint32_t error; + + uint32_t errnum; + uint8_t errclass; + + NTSTATUS nt_status; + + fstring user; + + /* NT-Error connection */ + + disable_spnego = true; + if (!(c_nt = open_nbt_connection())) { + disable_spnego = false; + return False; + } + disable_spnego = false; + + status = smbXcli_negprot(c_nt->conn, + c_nt->timeout, + PROTOCOL_CORE, + PROTOCOL_NT1, + NULL, + NULL, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + printf("%s rejected the NT-error negprot (%s)\n", host, + nt_errstr(status)); + cli_shutdown(c_nt); + return False; + } + + status = cli_session_setup_anon(c_nt); + if (!NT_STATUS_IS_OK(status)) { + printf("%s rejected the NT-error initial session setup (%s)\n",host, nt_errstr(status)); + return False; + } + + /* DOS-Error connection */ + + disable_spnego = true; + force_dos_errors = true; + if (!(c_dos = open_nbt_connection())) { + disable_spnego = false; + force_dos_errors = false; + return False; + } + disable_spnego = false; + force_dos_errors = false; + + status = smbXcli_negprot(c_dos->conn, + c_dos->timeout, + PROTOCOL_CORE, + PROTOCOL_NT1, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("%s rejected the DOS-error negprot (%s)\n", host, + nt_errstr(status)); + cli_shutdown(c_dos); + return False; + } + + status = cli_session_setup_anon(c_dos); + if (!NT_STATUS_IS_OK(status)) { + printf("%s rejected the DOS-error initial session setup (%s)\n", + host, nt_errstr(status)); + return False; + } + + c_nt->map_dos_errors = false; + c_dos->map_dos_errors = false; + + for (error=(0xc0000000 | 0x1); error < (0xc0000000| 0xFFF); error++) { + struct cli_credentials *user_creds = NULL; + + fstr_sprintf(user, "%X", error); + + user_creds = cli_session_creds_init(talloc_tos(), + user, + workgroup, + NULL, /* realm */ + password, + false, /* use_kerberos */ + false, /* fallback_after_kerberos */ + false, /* use_ccache */ + false); /* password_is_nt_hash */ + if (user_creds == NULL) { + printf("cli_session_creds_init(%s) failed\n", user); + return false; + } + + status = cli_session_setup_creds(c_nt, user_creds); + if (NT_STATUS_IS_OK(status)) { + printf("/** Session setup succeeded. This shouldn't happen...*/\n"); + } + + /* Case #1: 32-bit NT errors */ + if (!NT_STATUS_IS_DOS(status)) { + nt_status = status; + } else { + printf("/** Dos error on NT connection! (%s) */\n", + nt_errstr(status)); + nt_status = NT_STATUS(0xc0000000); + } + + status = cli_session_setup_creds(c_dos, user_creds); + if (NT_STATUS_IS_OK(status)) { + printf("/** Session setup succeeded. This shouldn't happen...*/\n"); + } + + /* Case #1: 32-bit NT errors */ + if (NT_STATUS_IS_DOS(status)) { + printf("/** NT error on DOS connection! (%s) */\n", + nt_errstr(status)); + errnum = errclass = 0; + } else { + errclass = NT_STATUS_DOS_CLASS(status); + errnum = NT_STATUS_DOS_CODE(status); + } + + if (NT_STATUS_V(nt_status) != error) { + printf("/*\t{ This NT error code was 'sqashed'\n\t from %s to %s \n\t during the session setup }\n*/\n", + get_nt_error_c_code(talloc_tos(), NT_STATUS(error)), + get_nt_error_c_code(talloc_tos(), nt_status)); + } + + printf("\t{%s,\t%s,\t%s},\n", + smb_dos_err_class(errclass), + smb_dos_err_name(errclass, errnum), + get_nt_error_c_code(talloc_tos(), NT_STATUS(error))); + + TALLOC_FREE(user_creds); + } + return True; +} + +static bool run_sesssetup_bench(int dummy) +{ + static struct cli_state *c; + const char *fname = "\\file.dat"; + uint16_t fnum; + NTSTATUS status; + int i; + + if (!torture_open_connection(&c, 0)) { + return false; + } + + status = cli_ntcreate(c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + FILE_DELETE_ON_CLOSE, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + d_printf("open %s failed: %s\n", fname, nt_errstr(status)); + return false; + } + + for (i=0; iconn, sockops); + + cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + reqs[0] = cli_openx_create(talloc_tos(), evt, cli1, fname, + O_CREAT|O_RDWR, 0, &smbreqs[0]); + if (reqs[0] == NULL) return false; + tevent_req_set_callback(reqs[0], chain1_open_completion, NULL); + + + reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0, + (const uint8_t *)str, 0, strlen(str)+1, + smbreqs, 1, &smbreqs[1]); + if (reqs[1] == NULL) return false; + tevent_req_set_callback(reqs[1], chain1_write_completion, NULL); + + reqs[2] = cli_smb1_close_create(talloc_tos(), evt, cli1, 0, &smbreqs[2]); + if (reqs[2] == NULL) return false; + tevent_req_set_callback(reqs[2], chain1_close_completion, &done); + + status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs)); + if (!NT_STATUS_IS_OK(status)) { + return false; + } + + while (!done) { + tevent_loop_once(evt); + } + + torture_close_connection(cli1); + return True; +} + +static void chain2_sesssetup_completion(struct tevent_req *req) +{ + NTSTATUS status; + status = cli_session_setup_guest_recv(req); + d_printf("sesssetup returned %s\n", nt_errstr(status)); +} + +static void chain2_tcon_completion(struct tevent_req *req) +{ + bool *done = (bool *)tevent_req_callback_data_void(req); + NTSTATUS status; + status = cli_tcon_andx_recv(req); + d_printf("tcon_and_x returned %s\n", nt_errstr(status)); + *done = true; +} + +static bool run_chain2(int dummy) +{ + struct cli_state *cli1; + struct tevent_context *evt = samba_tevent_context_init(NULL); + struct tevent_req *reqs[2], *smbreqs[2]; + bool done = false; + NTSTATUS status; + int flags = CLI_FULL_CONNECTION_FORCE_SMB1; + + printf("starting chain2 test\n"); + status = cli_start_connection(&cli1, lp_netbios_name(), host, NULL, + port_to_use, SMB_SIGNING_DEFAULT, flags); + if (!NT_STATUS_IS_OK(status)) { + return False; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + reqs[0] = cli_session_setup_guest_create(talloc_tos(), evt, cli1, + &smbreqs[0]); + if (reqs[0] == NULL) return false; + tevent_req_set_callback(reqs[0], chain2_sesssetup_completion, NULL); + + reqs[1] = cli_tcon_andx_create(talloc_tos(), evt, cli1, "IPC$", + "?????", NULL, 0, &smbreqs[1]); + if (reqs[1] == NULL) return false; + tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done); + + status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs)); + if (!NT_STATUS_IS_OK(status)) { + return false; + } + + while (!done) { + tevent_loop_once(evt); + } + + torture_close_connection(cli1); + return True; +} + + +struct torture_createdel_state { + struct tevent_context *ev; + struct cli_state *cli; +}; + +static void torture_createdel_created(struct tevent_req *subreq); +static void torture_createdel_closed(struct tevent_req *subreq); + +static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *name) +{ + struct tevent_req *req, *subreq; + struct torture_createdel_state *state; + + req = tevent_req_create(mem_ctx, &state, + struct torture_createdel_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + + subreq = cli_ntcreate_send( + state, ev, cli, name, 0, + FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, + SMB2_IMPERSONATION_IMPERSONATION, 0); + + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, torture_createdel_created, req); + return req; +} + +static void torture_createdel_created(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct torture_createdel_state *state = tevent_req_data( + req, struct torture_createdel_state); + NTSTATUS status; + uint16_t fnum; + + status = cli_ntcreate_recv(subreq, &fnum, NULL); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + DEBUG(10, ("cli_ntcreate_recv returned %s\n", + nt_errstr(status))); + return; + } + + subreq = cli_close_send(state, state->ev, state->cli, fnum, 0); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, torture_createdel_closed, req); +} + +static void torture_createdel_closed(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + NTSTATUS status; + + status = cli_close_recv(subreq); + if (tevent_req_nterror(req, status)) { + DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status))); + return; + } + tevent_req_done(req); +} + +static NTSTATUS torture_createdel_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +struct torture_createdels_state { + struct tevent_context *ev; + struct cli_state *cli; + const char *base_name; + int sent; + int received; + int num_files; + struct tevent_req **reqs; +}; + +static void torture_createdels_done(struct tevent_req *subreq); + +static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + const char *base_name, + int num_parallel, + int num_files) +{ + struct tevent_req *req; + struct torture_createdels_state *state; + int i; + + req = tevent_req_create(mem_ctx, &state, + struct torture_createdels_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + state->base_name = talloc_strdup(state, base_name); + if (tevent_req_nomem(state->base_name, req)) { + return tevent_req_post(req, ev); + } + state->num_files = MAX(num_parallel, num_files); + state->sent = 0; + state->received = 0; + + state->reqs = talloc_array(state, struct tevent_req *, num_parallel); + if (tevent_req_nomem(state->reqs, req)) { + return tevent_req_post(req, ev); + } + + for (i=0; ibase_name, + state->sent); + if (tevent_req_nomem(name, req)) { + return tevent_req_post(req, ev); + } + state->reqs[i] = torture_createdel_send( + state->reqs, state->ev, state->cli, name); + if (tevent_req_nomem(state->reqs[i], req)) { + return tevent_req_post(req, ev); + } + name = talloc_move(state->reqs[i], &name); + tevent_req_set_callback(state->reqs[i], + torture_createdels_done, req); + state->sent += 1; + } + return req; +} + +static void torture_createdels_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct torture_createdels_state *state = tevent_req_data( + req, struct torture_createdels_state); + size_t i, num_parallel = talloc_array_length(state->reqs); + NTSTATUS status; + char *name; + + status = torture_createdel_recv(subreq); + if (!NT_STATUS_IS_OK(status)){ + DEBUG(10, ("torture_createdel_recv returned %s\n", + nt_errstr(status))); + TALLOC_FREE(subreq); + tevent_req_nterror(req, status); + return; + } + + for (i=0; ireqs[i]) { + break; + } + } + if (i == num_parallel) { + DEBUG(10, ("received something we did not send\n")); + tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR); + return; + } + TALLOC_FREE(state->reqs[i]); + + if (state->sent >= state->num_files) { + tevent_req_done(req); + return; + } + + name = talloc_asprintf(state, "%s%8.8d", state->base_name, + state->sent); + if (tevent_req_nomem(name, req)) { + return; + } + state->reqs[i] = torture_createdel_send(state->reqs, state->ev, + state->cli, name); + if (tevent_req_nomem(state->reqs[i], req)) { + return; + } + name = talloc_move(state->reqs[i], &name); + tevent_req_set_callback(state->reqs[i], torture_createdels_done, req); + state->sent += 1; +} + +static NTSTATUS torture_createdels_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +struct swallow_notify_state { + struct tevent_context *ev; + struct cli_state *cli; + uint16_t fnum; + uint32_t completion_filter; + bool recursive; + bool (*fn)(uint32_t action, const char *name, void *priv); + void *priv; +}; + +static void swallow_notify_done(struct tevent_req *subreq); + +static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli, + uint16_t fnum, + uint32_t completion_filter, + bool recursive, + bool (*fn)(uint32_t action, + const char *name, + void *priv), + void *priv) +{ + struct tevent_req *req, *subreq; + struct swallow_notify_state *state; + + req = tevent_req_create(mem_ctx, &state, + struct swallow_notify_state); + if (req == NULL) { + return NULL; + } + state->ev = ev; + state->cli = cli; + state->fnum = fnum; + state->completion_filter = completion_filter; + state->recursive = recursive; + state->fn = fn; + state->priv = priv; + + subreq = cli_notify_send(state, state->ev, state->cli, state->fnum, + 0xffff, state->completion_filter, + state->recursive); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, swallow_notify_done, req); + return req; +} + +static void swallow_notify_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct swallow_notify_state *state = tevent_req_data( + req, struct swallow_notify_state); + NTSTATUS status; + uint32_t i, num_changes; + struct notify_change *changes; + + status = cli_notify_recv(subreq, state, &num_changes, &changes); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(10, ("cli_notify_recv returned %s\n", + nt_errstr(status))); + tevent_req_nterror(req, status); + return; + } + + for (i=0; ifn(changes[i].action, changes[i].name, state->priv); + } + TALLOC_FREE(changes); + + subreq = cli_notify_send(state, state->ev, state->cli, state->fnum, + 0xffff, state->completion_filter, + state->recursive); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, swallow_notify_done, req); +} + +static bool print_notifies(uint32_t action, const char *name, void *priv) +{ + if (DEBUGLEVEL > 5) { + d_printf("%d %s\n", (int)action, name); + } + return true; +} + +static void notify_bench_done(struct tevent_req *req) +{ + int *num_finished = (int *)tevent_req_callback_data_void(req); + *num_finished += 1; +} + +static bool run_notify_bench(int dummy) +{ + const char *dname = "\\notify-bench"; + struct tevent_context *ev; + NTSTATUS status; + uint16_t dnum; + struct tevent_req *req1; + struct tevent_req *req2 = NULL; + int i, num_unc_names; + int num_finished = 0; + + printf("starting notify-bench test\n"); + + if (use_multishare_conn) { + char **unc_list; + unc_list = file_lines_load(multishare_conn_fname, + &num_unc_names, 0, NULL); + if (!unc_list || num_unc_names <= 0) { + d_printf("Failed to load unc names list from '%s'\n", + multishare_conn_fname); + return false; + } + TALLOC_FREE(unc_list); + } else { + num_unc_names = 1; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + d_printf("tevent_context_init failed\n"); + return false; + } + + for (i=0; iconn, sockops); + + status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + 0, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + d_printf("open %s failed: %s\n", fname, nt_errstr(status)); + return false; + } + cli_close(cli, fnum); + + status = cli_qpathinfo_alt_name(cli, fname, alt_name); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_qpathinfo_alt_name failed: %s\n", + nt_errstr(status)); + return false; + } + d_printf("alt_name: %s\n", alt_name); + + status = cli_openx(cli, alt_name, O_RDONLY, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_openx(%s) failed: %s\n", alt_name, + nt_errstr(status)); + return false; + } + cli_close(cli, fnum); + + status = cli_qpathinfo1(cli, alt_name, NULL, NULL, NULL, NULL, NULL); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name, + nt_errstr(status)); + return false; + } + + return true; +} + +static NTSTATUS mangle_illegal_list_shortname_fn(struct file_info *f, + const char *mask, + void *state) +{ + if (f->short_name == NULL) { + return NT_STATUS_OK; + } + + if (strlen(f->short_name) == 0) { + return NT_STATUS_OK; + } + + printf("unexpected shortname: %s\n", f->short_name); + + return NT_STATUS_OBJECT_NAME_INVALID; +} + +static NTSTATUS mangle_illegal_list_name_fn(struct file_info *f, + const char *mask, + void *state) +{ + char *name = state; + + printf("name: %s\n", f->name); + fstrcpy(name, f->name); + return NT_STATUS_OK; +} + +static bool run_mangle_illegal(int dummy) +{ + struct cli_state *cli = NULL; + struct cli_state *cli_posix = NULL; + const char *fname = "\\MANGLE_ILLEGAL\\this_is_a_long_fname_to_be_mangled.txt"; + const char *illegal_fname = "MANGLE_ILLEGAL/foo:bar"; + char *mangled_path = NULL; + uint16_t fnum; + fstring name; + fstring alt_name; + NTSTATUS status; + + printf("starting mangle-illegal test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + if (!torture_open_connection(&cli_posix, 0)) { + return false; + } + + smbXcli_conn_set_sockopt(cli_posix->conn, sockops); + + status = torture_setup_unix_extensions(cli_posix); + if (!NT_STATUS_IS_OK(status)) { + return false; + } + + cli_rmdir(cli, "\\MANGLE_ILLEGAL"); + status = cli_mkdir(cli, "\\MANGLE_ILLEGAL"); + if (!NT_STATUS_IS_OK(status)) { + printf("mkdir1 failed : %s\n", nt_errstr(status)); + return False; + } + + /* + * Create a file with illegal NTFS characters and test that we + * get a usable mangled name + */ + + cli_setatr(cli_posix, illegal_fname, 0, 0); + cli_posix_unlink(cli_posix, illegal_fname); + + status = cli_posix_open(cli_posix, illegal_fname, O_RDWR|O_CREAT|O_EXCL, + 0600, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("POSIX create of %s failed (%s)\n", + illegal_fname, nt_errstr(status)); + return false; + } + + status = cli_close(cli_posix, fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("close failed (%s)\n", nt_errstr(status)); + return false; + } + + status = cli_list(cli, "\\MANGLE_ILLEGAL\\*", 0, mangle_illegal_list_name_fn, &name); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_list failed: %s\n", nt_errstr(status)); + return false; + } + + mangled_path = talloc_asprintf(talloc_tos(), "\\MANGLE_ILLEGAL\\%s", name); + if (mangled_path == NULL) { + return false; + } + + status = cli_openx(cli, mangled_path, O_RDONLY, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_openx(%s) failed: %s\n", mangled_path, nt_errstr(status)); + TALLOC_FREE(mangled_path); + return false; + } + TALLOC_FREE(mangled_path); + cli_close(cli, fnum); + + cli_setatr(cli_posix, illegal_fname, 0, 0); + cli_posix_unlink(cli_posix, illegal_fname); + + /* + * Create a file with a long name and check that we got *no* short name. + */ + + status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + 0, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + d_printf("open %s failed: %s\n", fname, nt_errstr(status)); + return false; + } + cli_close(cli, fnum); + + status = cli_list(cli, fname, 0, mangle_illegal_list_shortname_fn, &alt_name); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_list failed\n"); + return false; + } + + cli_unlink(cli, fname, 0); + cli_rmdir(cli, "\\MANGLE_ILLEGAL"); + + if (!torture_close_connection(cli_posix)) { + return false; + } + + if (!torture_close_connection(cli)) { + return false; + } + + return true; +} + +static size_t null_source(uint8_t *buf, size_t n, void *priv) +{ + size_t *to_pull = (size_t *)priv; + size_t thistime = *to_pull; + + thistime = MIN(thistime, n); + if (thistime == 0) { + return 0; + } + + memset(buf, 0, thistime); + *to_pull -= thistime; + return thistime; +} + +static bool run_windows_write(int dummy) +{ + struct cli_state *cli1; + uint16_t fnum; + int i; + bool ret = false; + const char *fname = "\\writetest.txt"; + struct timeval start_time; + double seconds; + double kbytes; + NTSTATUS status; + + printf("starting windows_write test\n"); + if (!torture_open_connection(&cli1, 0)) { + return False; + } + + status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("open failed (%s)\n", nt_errstr(status)); + return False; + } + + smbXcli_conn_set_sockopt(cli1->conn, sockops); + + start_time = timeval_current(); + + for (i=0; iserver_posix_capabilities & CIFS_UNIX_LARGE_READ_CAP) { + max_pdu = 0xFFFFFF; + } + + if (smb1cli_conn_signing_is_active(cli->conn)) { + max_pdu = 0x1FFFF; + } + + if (smb1cli_conn_encryption_on(cli->conn)) { + max_pdu = CLI_BUFFER_SIZE; + } + + if ((len_requested & 0xFFFF0000) == 0xFFFF0000) { + len_requested &= 0xFFFF; + } + + return MIN(len_requested, + max_pdu - (MIN_SMB_SIZE + VWV(12) + 1 /* padding byte */)); +} + +static bool check_read_call(struct cli_state *cli, + uint16_t fnum, + uint8_t *buf, + size_t len_requested) +{ + NTSTATUS status; + struct tevent_req *subreq = NULL; + ssize_t len_read = 0; + size_t len_expected = 0; + struct tevent_context *ev = NULL; + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + return false; + } + + subreq = cli_read_andx_send(talloc_tos(), + ev, + cli, + fnum, + 0, + len_requested); + + if (!tevent_req_poll_ntstatus(subreq, ev, &status)) { + return false; + } + + status = cli_read_andx_recv(subreq, &len_read, &buf); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_read_andx_recv failed: %s\n", nt_errstr(status)); + return false; + } + + TALLOC_FREE(subreq); + TALLOC_FREE(ev); + + len_expected = calc_expected_return(cli, len_requested); + + if (len_expected > 0x10000 && len_read == 0x10000) { + /* Windows servers only return a max of 0x10000, + doesn't matter if you set CAP_LARGE_READX in + the client sessionsetupX call or not. */ + d_printf("Windows server - returned 0x10000 on a read of 0x%x\n", + (unsigned int)len_requested); + } else if (len_read != len_expected) { + d_printf("read of 0x%x failed: got 0x%x, expected 0x%x\n", + (unsigned int)len_requested, + (unsigned int)len_read, + (unsigned int)len_expected); + return false; + } else { + d_printf("Correct read reply.\n"); + } + + return true; +} + +/* Test large readX variants. */ +static bool large_readx_tests(struct cli_state *cli, + uint16_t fnum, + uint8_t *buf) +{ + /* A read of 0xFFFF0001 should *always* return 1 byte. */ + if (check_read_call(cli, fnum, buf, 0xFFFF0001) == false) { + return false; + } + /* A read of 0x10000 should return 0x10000 bytes. */ + if (check_read_call(cli, fnum, buf, 0x10000) == false) { + return false; + } + /* A read of 0x10000 should return 0x10001 bytes. */ + if (check_read_call(cli, fnum, buf, 0x10001) == false) { + return false; + } + /* A read of 0x1FFFF - (MIN_SMB_SIZE + VWV(12) should return + the requested number of bytes. */ + if (check_read_call(cli, fnum, buf, 0x1FFFF - (MIN_SMB_SIZE + VWV(12))) == false) { + return false; + } + /* A read of 1MB should return 1MB bytes (on Samba). */ + if (check_read_call(cli, fnum, buf, 0x100000) == false) { + return false; + } + + if (check_read_call(cli, fnum, buf, 0x20001) == false) { + return false; + } + if (check_read_call(cli, fnum, buf, 0x22000001) == false) { + return false; + } + if (check_read_call(cli, fnum, buf, 0xFFFE0001) == false) { + return false; + } + return true; +} + +static bool run_large_readx(int dummy) +{ + uint8_t *buf = NULL; + struct cli_state *cli1 = NULL; + struct cli_state *cli2 = NULL; + bool correct = false; + const char *fname = "\\large_readx.dat"; + NTSTATUS status; + uint16_t fnum1 = UINT16_MAX; + uint32_t normal_caps = 0; + size_t file_size = 20*1024*1024; + TALLOC_CTX *frame = talloc_stackframe(); + size_t i; + struct { + const char *name; + enum smb_signing_setting signing_setting; + enum protocol_types protocol; + } runs[] = { + { + .name = "NT1", + .signing_setting = SMB_SIGNING_IF_REQUIRED, + .protocol = PROTOCOL_NT1, + },{ + .name = "NT1 - SIGNING_REQUIRED", + .signing_setting = SMB_SIGNING_REQUIRED, + .protocol = PROTOCOL_NT1, + }, + }; + + printf("starting large_readx test\n"); + + if (!torture_open_connection(&cli1, 0)) { + goto out; + } + + normal_caps = smb1cli_conn_capabilities(cli1->conn); + + if (!(normal_caps & CAP_LARGE_READX)) { + d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n", + (unsigned int)normal_caps); + goto out; + } + + /* Create a file of size 4MB. */ + status = cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + 0, 0, &fnum1, NULL); + + if (!NT_STATUS_IS_OK(status)) { + d_printf("open %s failed: %s\n", fname, nt_errstr(status)); + goto out; + } + + /* Write file_size bytes. */ + buf = talloc_zero_array(frame, uint8_t, file_size); + if (buf == NULL) { + goto out; + } + + status = cli_writeall(cli1, + fnum1, + 0, + buf, + 0, + file_size, + NULL); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_writeall failed: %s\n", nt_errstr(status)); + goto out; + } + + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_close failed: %s\n", nt_errstr(status)); + goto out; + } + + fnum1 = UINT16_MAX; + + for (i=0; i < ARRAY_SIZE(runs); i++) { + enum smb_signing_setting saved_signing_setting = signing_state; + uint16_t fnum2 = -1; + + if (do_encrypt && + (runs[i].signing_setting == SMB_SIGNING_REQUIRED)) + { + d_printf("skip[%u] - %s\n", (unsigned)i, runs[i].name); + continue; + } + + d_printf("run[%u] - %s\n", (unsigned)i, runs[i].name); + + signing_state = runs[i].signing_setting; + cli2 = open_nbt_connection(); + signing_state = saved_signing_setting; + if (cli2 == NULL) { + goto out; + } + + status = smbXcli_negprot(cli2->conn, + cli2->timeout, + runs[i].protocol, + runs[i].protocol, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + status = cli_session_setup_creds(cli2, torture_creds); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + status = cli_tree_connect(cli2, + share, + "?????", + password); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + cli_set_timeout(cli2, 120000); /* set a really long timeout (2 minutes) */ + + normal_caps = smb1cli_conn_capabilities(cli2->conn); + + if (!(normal_caps & CAP_LARGE_READX)) { + d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n", + (unsigned int)normal_caps); + goto out; + } + + if (do_encrypt) { + if (force_cli_encryption(cli2, share) == false) { + goto out; + } + } else if (SERVER_HAS_UNIX_CIFS(cli2)) { + uint16_t major, minor; + uint32_t caplow, caphigh; + + status = cli_unix_extensions_version(cli2, + &major, &minor, + &caplow, &caphigh); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + } + + status = cli_ntcreate(cli2, fname, 0, FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN, + 0, 0, &fnum2, NULL); + if (!NT_STATUS_IS_OK(status)) { + d_printf("Second open %s failed: %s\n", fname, nt_errstr(status)); + goto out; + } + + /* All reads must return less than file_size bytes. */ + if (!large_readx_tests(cli2, fnum2, buf)) { + goto out; + } + + status = cli_close(cli2, fnum2); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_close failed: %s\n", nt_errstr(status)); + goto out; + } + fnum2 = -1; + + if (!torture_close_connection(cli2)) { + goto out; + } + cli2 = NULL; + } + + correct = true; + printf("Success on large_readx test\n"); + + out: + + if (cli2) { + if (!torture_close_connection(cli2)) { + correct = false; + } + } + + if (cli1) { + if (fnum1 != UINT16_MAX) { + status = cli_close(cli1, fnum1); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_close failed: %s\n", nt_errstr(status)); + } + fnum1 = UINT16_MAX; + } + + status = cli_unlink(cli1, fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + } + + if (!torture_close_connection(cli1)) { + correct = false; + } + } + + TALLOC_FREE(frame); + + printf("finished large_readx test\n"); + return correct; +} + +static NTSTATUS msdfs_attribute_list_fn(struct file_info *finfo, + const char *mask, + void *private_data) +{ + uint32_t *p_attr = (uint32_t *)private_data; + + if (strequal(finfo->name, test_filename)) { + *p_attr = finfo->attr; + } + + return NT_STATUS_OK; +} + +static bool run_msdfs_attribute(int dummy) +{ + static struct cli_state *cli; + bool correct = false; + uint32_t attr = 0; + NTSTATUS status; + + printf("Starting MSDFS-ATTRIBUTE test\n"); + + if (test_filename == NULL || test_filename[0] == '\0') { + printf("MSDFS-ATTRIBUTE test " + "needs -f filename-of-msdfs-link\n"); + return false; + } + + /* + * NB. We use torture_open_connection_flags() not + * torture_open_connection() as the latter forces + * SMB1. + */ + if (!torture_open_connection_flags(&cli, 0, 0)) { + return false; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = cli_list(cli, + "*", + FILE_ATTRIBUTE_DIRECTORY, + msdfs_attribute_list_fn, + &attr); + + if (!NT_STATUS_IS_OK(status)) { + printf("cli_list failed with %s\n", + nt_errstr(status)); + goto out; + } + if ((attr & FILE_ATTRIBUTE_REPARSE_POINT) == 0) { + printf("file %s should have " + "FILE_ATTRIBUTE_REPARSE_POINT set. attr = 0x%x\n", + test_filename, + (unsigned int)attr); + goto out; + } + + if ((attr & FILE_ATTRIBUTE_DIRECTORY) == 0) { + printf("file %s should have " + "FILE_ATTRIBUTE_DIRECTORY set. attr = 0x%x\n", + test_filename, + (unsigned int)attr); + goto out; + } + + correct = true; + + out: + + torture_close_connection(cli); + return correct; +} + +static bool run_cli_echo(int dummy) +{ + struct cli_state *cli; + NTSTATUS status; + + printf("starting cli_echo test\n"); + if (!torture_open_connection(&cli, 0)) { + return false; + } + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = cli_echo(cli, 5, data_blob_const("hello", 5)); + + d_printf("cli_echo returned %s\n", nt_errstr(status)); + + torture_close_connection(cli); + return NT_STATUS_IS_OK(status); +} + +static int splice_status(off_t written, void *priv) +{ + return true; +} + +static bool run_cli_splice(int dummy) +{ + uint8_t *buf = NULL; + struct cli_state *cli1 = NULL; + bool correct = false; + const char *fname_src = "\\splice_src.dat"; + const char *fname_dst = "\\splice_dst.dat"; + NTSTATUS status; + uint16_t fnum1 = UINT16_MAX; + uint16_t fnum2 = UINT16_MAX; + size_t file_size = 2*1024*1024; + size_t splice_size = 1*1024*1024 + 713; + uint8_t digest1[16], digest2[16]; + off_t written = 0; + size_t nread = 0; + TALLOC_CTX *frame = talloc_stackframe(); + + printf("starting cli_splice test\n"); + + if (!torture_open_connection(&cli1, 0)) { + goto out; + } + + cli_unlink(cli1, fname_src, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname_dst, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Create a file */ + status = cli_ntcreate(cli1, fname_src, 0, GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + 0, 0, &fnum1, NULL); + + if (!NT_STATUS_IS_OK(status)) { + d_printf("open %s failed: %s\n", fname_src, nt_errstr(status)); + goto out; + } + + /* Write file_size bytes - must be bigger than splice_size. */ + buf = talloc_zero_array(frame, uint8_t, file_size); + if (buf == NULL) { + d_printf("talloc_fail\n"); + goto out; + } + + /* Fill it with random numbers. */ + generate_random_buffer(buf, file_size); + + /* MD5 the first 1MB + 713 bytes. */ + gnutls_hash_fast(GNUTLS_DIG_MD5, + buf, + splice_size, + digest1); + + status = cli_writeall(cli1, + fnum1, + 0, + buf, + 0, + file_size, + NULL); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_writeall failed: %s\n", nt_errstr(status)); + goto out; + } + + status = cli_ntcreate(cli1, fname_dst, 0, GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + 0, 0, &fnum2, NULL); + + if (!NT_STATUS_IS_OK(status)) { + d_printf("open %s failed: %s\n", fname_dst, nt_errstr(status)); + goto out; + } + + /* Now splice 1MB + 713 bytes. */ + status = cli_splice(cli1, + cli1, + fnum1, + fnum2, + splice_size, + 0, + 0, + &written, + splice_status, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_splice failed: %s\n", nt_errstr(status)); + goto out; + } + + /* Clear the old buffer. */ + memset(buf, '\0', file_size); + + /* Read the new file. */ + status = cli_read(cli1, fnum2, (char *)buf, 0, splice_size, &nread); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_read failed: %s\n", nt_errstr(status)); + goto out; + } + if (nread != splice_size) { + d_printf("bad read of 0x%x, should be 0x%x\n", + (unsigned int)nread, + (unsigned int)splice_size); + goto out; + } + + /* MD5 the first 1MB + 713 bytes. */ + gnutls_hash_fast(GNUTLS_DIG_MD5, + buf, + splice_size, + digest2); + + /* Must be the same. */ + if (memcmp(digest1, digest2, 16) != 0) { + d_printf("bad MD5 compare\n"); + goto out; + } + + correct = true; + printf("Success on cli_splice test\n"); + + out: + + if (cli1) { + if (fnum1 != UINT16_MAX) { + cli_close(cli1, fnum1); + } + if (fnum2 != UINT16_MAX) { + cli_close(cli1, fnum2); + } + + cli_unlink(cli1, fname_src, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_unlink(cli1, fname_dst, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + if (!torture_close_connection(cli1)) { + correct = false; + } + } + + TALLOC_FREE(frame); + return correct; +} + +static bool run_uid_regression_test(int dummy) +{ + static struct cli_state *cli; + int16_t old_vuid; + int32_t old_cnum; + bool correct = True; + struct smbXcli_tcon *tcon_copy = NULL; + NTSTATUS status; + + printf("starting uid regression test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + /* Ok - now save then logoff our current user. */ + old_vuid = cli_state_get_uid(cli); + + status = cli_ulogoff(cli); + if (!NT_STATUS_IS_OK(status)) { + d_printf("(%s) cli_ulogoff failed: %s\n", + __location__, nt_errstr(status)); + correct = false; + goto out; + } + + cli_state_set_uid(cli, old_vuid); + + /* Try an operation. */ + status = cli_mkdir(cli, "\\uid_reg_test"); + if (NT_STATUS_IS_OK(status)) { + d_printf("(%s) cli_mkdir succeeded\n", + __location__); + correct = false; + goto out; + } else { + /* Should be bad uid. */ + if (!check_error(__LINE__, status, ERRSRV, ERRbaduid, + NT_STATUS_USER_SESSION_DELETED)) { + correct = false; + goto out; + } + } + + old_cnum = cli_state_get_tid(cli); + /* + * This is an SMB1-only test. + * Copy the tcon, not "save/restore". + * + * In SMB1 the cli_tdis() below frees + * cli->smb1.tcon so we need a copy + * of the struct to put back for the + * second tdis call with invalid vuid. + * + * This is a test-only hack. Real client code + * uses cli_state_save_tcon_share()/cli_state_restore_tcon_share(). + */ + tcon_copy = smbXcli_tcon_copy(cli, cli->smb1.tcon); + if (tcon_copy == NULL) { + correct = false; + goto out; + } + + /* Now try a SMBtdis with the invalid vuid set to zero. */ + cli_state_set_uid(cli, 0); + + /* This should succeed. */ + status = cli_tdis(cli); + + if (NT_STATUS_IS_OK(status)) { + d_printf("First tdis with invalid vuid should succeed.\n"); + } else { + d_printf("First tdis failed (%s)\n", nt_errstr(status)); + correct = false; + cli->smb1.tcon = tcon_copy; + goto out; + } + + cli->smb1.tcon = tcon_copy; + cli_state_set_uid(cli, old_vuid); + cli_state_set_tid(cli, old_cnum); + + /* This should fail. */ + status = cli_tdis(cli); + if (NT_STATUS_IS_OK(status)) { + d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n"); + correct = false; + goto out; + } else { + /* Should be bad tid. */ + if (!check_error(__LINE__, status, ERRSRV, ERRinvnid, + NT_STATUS_NETWORK_NAME_DELETED)) { + correct = false; + goto out; + } + } + + cli_rmdir(cli, "\\uid_reg_test"); + + out: + + cli_shutdown(cli); + return correct; +} + + +static const char *illegal_chars = "*\\/?<>|\":"; +static char force_shortname_chars[] = " +,.[];=\177"; + +static NTSTATUS shortname_del_fn(struct file_info *finfo, + const char *mask, void *state) +{ + struct cli_state *pcli = (struct cli_state *)state; + fstring fname; + NTSTATUS status = NT_STATUS_OK; + + slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name); + + if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0) + return NT_STATUS_OK; + + if (finfo->attr & FILE_ATTRIBUTE_DIRECTORY) { + status = cli_rmdir(pcli, fname); + if (!NT_STATUS_IS_OK(status)) { + printf("del_fn: failed to rmdir %s\n,", fname ); + } + } else { + status = cli_unlink(pcli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("del_fn: failed to unlink %s\n,", fname ); + } + } + return status; +} + +struct sn_state { + int matched; + int i; + bool val; +}; + +static NTSTATUS shortname_list_fn(struct file_info *finfo, + const char *name, void *state) +{ + struct sn_state *s = (struct sn_state *)state; + int i = s->i; + +#if 0 + printf("shortname list: i = %d, name = |%s|, shortname = |%s|\n", + i, finfo->name, finfo->short_name); +#endif + + if (strchr(force_shortname_chars, i)) { + if (!finfo->short_name) { + /* Shortname not created when it should be. */ + d_printf("(%s) ERROR: Shortname was not created for file %s containing %d\n", + __location__, finfo->name, i); + s->val = true; + } + } else if (finfo->short_name){ + /* Shortname created when it should not be. */ + d_printf("(%s) ERROR: Shortname %s was created for file %s\n", + __location__, finfo->short_name, finfo->name); + s->val = true; + } + s->matched += 1; + return NT_STATUS_OK; +} + +static bool run_shortname_test(int dummy) +{ + static struct cli_state *cli; + bool correct = True; + int i; + struct sn_state s; + char fname[40]; + NTSTATUS status; + + printf("starting shortname test\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli); + cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli); + cli_rmdir(cli, "\\shortname"); + + status = cli_mkdir(cli, "\\shortname"); + if (!NT_STATUS_IS_OK(status)) { + d_printf("(%s) cli_mkdir of \\shortname failed: %s\n", + __location__, nt_errstr(status)); + correct = false; + goto out; + } + + if (strlcpy(fname, "\\shortname\\", sizeof(fname)) >= sizeof(fname)) { + correct = false; + goto out; + } + if (strlcat(fname, "test .txt", sizeof(fname)) >= sizeof(fname)) { + correct = false; + goto out; + } + + s.val = false; + + for (i = 32; i < 128; i++) { + uint16_t fnum = (uint16_t)-1; + + s.i = i; + + if (strchr(illegal_chars, i)) { + continue; + } + fname[15] = i; + + status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_OVERWRITE_IF, 0, 0, &fnum, NULL); + if (!NT_STATUS_IS_OK(status)) { + d_printf("(%s) cli_nt_create of %s failed: %s\n", + __location__, fname, nt_errstr(status)); + correct = false; + goto out; + } + cli_close(cli, fnum); + + s.matched = 0; + status = cli_list(cli, "\\shortname\\test*.*", 0, + shortname_list_fn, &s); + if (s.matched != 1) { + d_printf("(%s) failed to list %s: %s\n", + __location__, fname, nt_errstr(status)); + correct = false; + goto out; + } + + status = cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + d_printf("(%s) failed to delete %s: %s\n", + __location__, fname, nt_errstr(status)); + correct = false; + goto out; + } + + if (s.val) { + correct = false; + goto out; + } + } + + out: + + cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli); + cli_list(cli, "\\shortname\\*", FILE_ATTRIBUTE_DIRECTORY, shortname_del_fn, cli); + cli_rmdir(cli, "\\shortname"); + torture_close_connection(cli); + return correct; +} + +TLDAPRC callback_code; + +static void pagedsearch_cb(struct tevent_req *req) +{ + TLDAPRC rc; + struct tldap_message *msg; + char *dn; + + rc = tldap_search_paged_recv(req, talloc_tos(), &msg); + if (!TLDAP_RC_IS_SUCCESS(rc)) { + d_printf("tldap_search_paged_recv failed: %s\n", + tldap_rc2string(rc)); + callback_code = rc; + return; + } + if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) { + TALLOC_FREE(msg); + return; + } + if (!tldap_entry_dn(msg, &dn)) { + d_printf("tldap_entry_dn failed\n"); + return; + } + d_printf("%s\n", dn); + TALLOC_FREE(msg); +} + +enum tldap_extended_val { + EXTENDED_ZERO = 0, + EXTENDED_ONE = 1, + EXTENDED_NONE = 2, +}; + +/* + * Construct an extended dn control with either no value, 0 or 1 + * + * No value and 0 are equivalent (non-hyphenated GUID) + * 1 has the hyphenated GUID + */ +static struct tldap_control * +tldap_build_extended_control(enum tldap_extended_val val) +{ + struct tldap_control empty_control; + struct asn1_data *data; + + ZERO_STRUCT(empty_control); + + if (val != EXTENDED_NONE) { + data = asn1_init(talloc_tos(), ASN1_MAX_TREE_DEPTH); + + if (!data) { + return NULL; + } + + if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) { + return NULL; + } + + if (!asn1_write_Integer(data, (int)val)) { + return NULL; + } + + if (!asn1_pop_tag(data)) { + return NULL; + } + + if (!asn1_blob(data, &empty_control.value)) { + return NULL; + } + } + + empty_control.oid = "1.2.840.113556.1.4.529"; + empty_control.critical = true; + + return tldap_add_control(talloc_tos(), NULL, 0, &empty_control); + +} + +static bool tldap_test_dn_guid_format(struct tldap_context *ld, const char *basedn, + enum tldap_extended_val control_val) +{ + struct tldap_control *control = tldap_build_extended_control(control_val); + char *dn = NULL; + struct tldap_message **msg; + TLDAPRC rc; + + rc = tldap_search(ld, basedn, TLDAP_SCOPE_BASE, + "(objectClass=*)", NULL, 0, 0, + control, 1, NULL, + 0, 0, 0, 0, talloc_tos(), &msg); + if (!TLDAP_RC_IS_SUCCESS(rc)) { + d_printf("tldap_search for domain DN failed: %s\n", + tldap_errstr(talloc_tos(), ld, rc)); + return false; + } + + if (!tldap_entry_dn(msg[0], &dn)) { + d_printf("tldap_search domain DN fetch failed: %s\n", + tldap_errstr(talloc_tos(), ld, rc)); + return false; + } + + d_printf("%s\n", dn); + { + uint32_t time_low; + uint32_t time_mid, time_hi_and_version; + uint32_t clock_seq[2]; + uint32_t node[6]; + char next; + + switch (control_val) { + case EXTENDED_NONE: + case EXTENDED_ZERO: + /* + * When reading GUIDs with hyphens, scanf will treat + * hyphen as a hex character (and counts as part of the + * width). This creates leftover GUID string which we + * check will for with 'next' and closing '>'. + */ + if (12 == sscanf(dn, "%c", + &time_low, &time_mid, + &time_hi_and_version, &clock_seq[0], + &clock_seq[1], &node[0], &node[1], + &node[2], &node[3], &node[4], + &node[5], &next)) { + /* This GUID is good */ + } else { + d_printf("GUID format in control (no hyphens) doesn't match output\n"); + return false; + } + + break; + case EXTENDED_ONE: + if (12 == sscanf(dn, + "%c", + &time_low, &time_mid, + &time_hi_and_version, &clock_seq[0], + &clock_seq[1], &node[0], &node[1], + &node[2], &node[3], &node[4], + &node[5], &next)) { + /* This GUID is good */ + } else { + d_printf("GUID format in control (with hyphens) doesn't match output\n"); + return false; + } + + break; + default: + return false; + } + } + + return true; +} + +static bool run_tldap(int dummy) +{ + struct tldap_context *ld; + int fd; + TLDAPRC rc; + NTSTATUS status; + struct sockaddr_storage addr; + struct tevent_context *ev; + struct tevent_req *req; + char *basedn; + const char *filter; + + if (!resolve_name(host, &addr, 0, false)) { + d_printf("could not find host %s\n", host); + return false; + } + status = open_socket_out(&addr, 389, 9999, &fd); + if (!NT_STATUS_IS_OK(status)) { + d_printf("open_socket_out failed: %s\n", nt_errstr(status)); + return false; + } + + ld = tldap_context_create(talloc_tos(), fd); + if (ld == NULL) { + close(fd); + d_printf("tldap_context_create failed\n"); + return false; + } + + rc = tldap_fetch_rootdse(ld); + if (!TLDAP_RC_IS_SUCCESS(rc)) { + d_printf("tldap_fetch_rootdse failed: %s\n", + tldap_errstr(talloc_tos(), ld, rc)); + return false; + } + + basedn = tldap_talloc_single_attribute( + tldap_rootdse(ld), "defaultNamingContext", talloc_tos()); + if (basedn == NULL) { + d_printf("no defaultNamingContext\n"); + return false; + } + d_printf("defaultNamingContext: %s\n", basedn); + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + d_printf("tevent_context_init failed\n"); + return false; + } + + rc = tldap_gensec_bind(ld, torture_creds, "ldap", host, NULL, + loadparm_init_s3(talloc_tos(), + loadparm_s3_helpers()), + GENSEC_FEATURE_SIGN | GENSEC_FEATURE_SEAL); + + if (!TLDAP_RC_IS_SUCCESS(rc)) { + d_printf("tldap_gensec_bind failed\n"); + return false; + } + + callback_code = TLDAP_SUCCESS; + + req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn, + TLDAP_SCOPE_SUB, "(objectclass=*)", + NULL, 0, 0, + NULL, 0, NULL, 0, 0, 0, 0, 5); + if (req == NULL) { + d_printf("tldap_search_paged_send failed\n"); + return false; + } + tevent_req_set_callback(req, pagedsearch_cb, NULL); + + tevent_req_poll(req, ev); + + TALLOC_FREE(req); + + rc = callback_code; + + if (!TLDAP_RC_IS_SUCCESS(rc)) { + d_printf("tldap_search with paging failed: %s\n", + tldap_errstr(talloc_tos(), ld, rc)); + return false; + } + + /* test search filters against rootDSE */ + filter = "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))" + "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))"; + + rc = tldap_search(ld, "", TLDAP_SCOPE_BASE, filter, + NULL, 0, 0, NULL, 0, NULL, 0, 0, 0, 0, + talloc_tos(), NULL); + if (!TLDAP_RC_IS_SUCCESS(rc)) { + d_printf("tldap_search with complex filter failed: %s\n", + tldap_errstr(talloc_tos(), ld, rc)); + return false; + } + + /* + * Tests to check for regression of: + * + * https://bugzilla.samba.org/show_bug.cgi?id=14029 + * + * TLDAP used here to pick apart the original string DN (with GUID) + */ + if (!tldap_test_dn_guid_format(ld, basedn, EXTENDED_NONE)) { + d_printf("tldap_search with extended dn (no val) failed: %s\n", + tldap_errstr(talloc_tos(), ld, rc)); + return false; + } + if (!tldap_test_dn_guid_format(ld, basedn, EXTENDED_ZERO)) { + d_printf("tldap_search with extended dn (0) failed: %s\n", + tldap_errstr(talloc_tos(), ld, rc)); + return false; + } + if (!tldap_test_dn_guid_format(ld, basedn, EXTENDED_ONE)) { + d_printf("tldap_search with extended dn (1) failed: %s\n", + tldap_errstr(talloc_tos(), ld, rc)); + return false; + } + + TALLOC_FREE(ld); + return true; +} + +/* Torture test to ensure no regression of : +https://bugzilla.samba.org/show_bug.cgi?id=7084 +*/ + +static bool run_dir_createtime(int dummy) +{ + struct cli_state *cli; + const char *dname = "\\testdir_createtime"; + const char *fname = "\\testdir_createtime\\testfile"; + NTSTATUS status; + struct timespec create_time; + struct timespec create_time1; + uint16_t fnum; + bool ret = false; + uint64_t ino; + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) { + /* Ensure ino is zero, SMB2 gets a real one. */ + ino = 0; + } else { + /* Ensure ino is -1, SMB1 never gets a real one. */ + ino = (uint64_t)-1; + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_rmdir(cli, dname); + + status = cli_mkdir(cli, dname); + if (!NT_STATUS_IS_OK(status)) { + printf("mkdir failed: %s\n", nt_errstr(status)); + goto out; + } + + status = cli_qpathinfo2(cli, + dname, + &create_time, + NULL, + NULL, + NULL, + NULL, + NULL, + &ino, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_qpathinfo2 returned %s\n", + nt_errstr(status)); + goto out; + } + + if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) { + /* SMB2 should always return an inode. */ + if (ino == 0) { + printf("SMB2 bad inode (0)\n"); + goto out; + } + } else { + /* SMB1 must always return zero here. */ + if (ino != 0) { + printf("SMB1 bad inode (!0)\n"); + goto out; + } + } + + /* Sleep 3 seconds, then create a file. */ + sleep(3); + + status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_EXCL, + DENY_NONE, &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_openx failed: %s\n", nt_errstr(status)); + goto out; + } + + status = cli_qpathinfo2(cli, + dname, + &create_time1, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_qpathinfo2 (2) returned %s\n", + nt_errstr(status)); + goto out; + } + + if (timespec_compare(&create_time1, &create_time)) { + printf("run_dir_createtime: create time was updated (error)\n"); + } else { + printf("run_dir_createtime: create time was not updated (correct)\n"); + ret = true; + } + + out: + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + cli_rmdir(cli, dname); + if (!torture_close_connection(cli)) { + ret = false; + } + return ret; +} + + +static bool run_streamerror(int dummy) +{ + struct cli_state *cli; + const char *dname = "\\testdir_streamerror"; + const char *streamname = + "testdir_streamerror:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA"; + NTSTATUS status; + time_t change_time, access_time, write_time; + off_t size; + uint16_t fnum; + uint32_t attr; + bool ret = true; + + if (!torture_open_connection(&cli, 0)) { + return false; + } + + torture_deltree(cli, dname); + + status = cli_mkdir(cli, dname); + if (!NT_STATUS_IS_OK(status)) { + printf("mkdir failed: %s\n", nt_errstr(status)); + return false; + } + + status = cli_qpathinfo1(cli, streamname, &change_time, &access_time, + &write_time, &size, &attr); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + printf("pathinfo returned %s, expected " + "NT_STATUS_OBJECT_NAME_NOT_FOUND\n", + nt_errstr(status)); + ret = false; + } + + status = cli_ntcreate(cli, streamname, 0x16, + FILE_READ_DATA|FILE_READ_EA| + FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS, + FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, + FILE_OPEN, 0, 0, &fnum, NULL); + + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + printf("ntcreate returned %s, expected " + "NT_STATUS_OBJECT_NAME_NOT_FOUND\n", + nt_errstr(status)); + ret = false; + } + + + cli_rmdir(cli, dname); + return ret; +} + +struct pidtest_state { + bool success; + uint16_t vwv[1]; + DATA_BLOB data; +}; + +static void pid_echo_done(struct tevent_req *subreq); + +static struct tevent_req *pid_echo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct cli_state *cli) +{ + struct tevent_req *req, *subreq; + struct pidtest_state *state; + + req = tevent_req_create(mem_ctx, &state, struct pidtest_state); + if (req == NULL) { + return NULL; + } + + SSVAL(state->vwv, 0, 1); + state->data = data_blob_const("hello", 5); + + subreq = smb1cli_req_send(state, + ev, + cli->conn, + SMBecho, + 0, 0, /* *_flags */ + 0, 0, /* *_flags2 */ + cli->timeout, + 0xDEADBEEF, /* pid */ + NULL, /* tcon */ + NULL, /* session */ + ARRAY_SIZE(state->vwv), state->vwv, + state->data.length, state->data.data); + + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, pid_echo_done, req); + return req; +} + +static void pid_echo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct pidtest_state *state = tevent_req_data( + req, struct pidtest_state); + NTSTATUS status; + uint32_t num_bytes; + uint8_t *bytes = NULL; + struct iovec *recv_iov = NULL; + uint8_t *phdr = NULL; + uint16_t pidlow = 0; + uint16_t pidhigh = 0; + struct smb1cli_req_expected_response expected[] = { + { + .status = NT_STATUS_OK, + .wct = 1, + }, + }; + + status = smb1cli_req_recv(subreq, state, + &recv_iov, + &phdr, + NULL, /* pwct */ + NULL, /* pvwv */ + NULL, /* pvwv_offset */ + &num_bytes, + &bytes, + NULL, /* pbytes_offset */ + NULL, /* pinbuf */ + expected, ARRAY_SIZE(expected)); + + TALLOC_FREE(subreq); + + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + if (num_bytes != state->data.length) { + tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE); + return; + } + + if (memcmp(bytes, state->data.data, num_bytes) != 0) { + tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE); + return; + } + + /* Check pid low/high == DEADBEEF */ + pidlow = SVAL(phdr, HDR_PID); + if (pidlow != 0xBEEF){ + printf("Incorrect pidlow 0x%x, should be 0xBEEF\n", + (unsigned int)pidlow); + tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE); + return; + } + pidhigh = SVAL(phdr, HDR_PIDHIGH); + if (pidhigh != 0xDEAD){ + printf("Incorrect pidhigh 0x%x, should be 0xDEAD\n", + (unsigned int)pidhigh); + tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE); + return; + } + + tevent_req_done(req); +} + +static NTSTATUS pid_echo_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static bool run_pidhigh(int dummy) +{ + bool success = false; + struct cli_state *cli = NULL; + NTSTATUS status; + struct tevent_context *ev = NULL; + struct tevent_req *req = NULL; + TALLOC_CTX *frame = talloc_stackframe(); + + printf("starting pid high test\n"); + if (!torture_open_connection(&cli, 0)) { + return false; + } + smbXcli_conn_set_sockopt(cli->conn, sockops); + + ev = samba_tevent_context_init(frame); + if (ev == NULL) { + goto fail; + } + + req = pid_echo_send(frame, ev, cli); + if (req == NULL) { + goto fail; + } + + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + goto fail; + } + + status = pid_echo_recv(req); + if (NT_STATUS_IS_OK(status)) { + printf("pid high test ok\n"); + success = true; + } + + fail: + + TALLOC_FREE(frame); + torture_close_connection(cli); + return success; +} + +/* + Test Windows open on a bad POSIX symlink. + */ +static bool run_symlink_open_test(int dummy) +{ + static struct cli_state *cli; + const char *fname = "non_existant_file"; + const char *sname = "dangling_symlink"; + uint16_t fnum = (uint16_t)-1; + bool correct = false; + NTSTATUS status; + TALLOC_CTX *frame = NULL; + + frame = talloc_stackframe(); + + printf("Starting Windows bad symlink open test\n"); + + if (!torture_open_connection(&cli, 0)) { + TALLOC_FREE(frame); + return false; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = torture_setup_unix_extensions(cli); + if (!NT_STATUS_IS_OK(status)) { + TALLOC_FREE(frame); + return false; + } + + /* Ensure nothing exists. */ + cli_setatr(cli, fname, 0, 0); + cli_posix_unlink(cli, fname); + cli_setatr(cli, sname, 0, 0); + cli_posix_unlink(cli, sname); + + /* Create a symlink pointing nowhere. */ + status = cli_posix_symlink(cli, fname, sname); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_symlink of %s -> %s failed (%s)\n", + sname, + fname, + nt_errstr(status)); + goto out; + } + + /* Now ensure that a Windows open doesn't hang. */ + status = cli_ntcreate(cli, + sname, + 0, + FILE_READ_DATA|FILE_WRITE_DATA, + 0, + FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, + FILE_OPEN_IF, + 0x0, + 0x0, + &fnum, + NULL); + + /* + * We get either NT_STATUS_OBJECT_NAME_NOT_FOUND or + * NT_STATUS_OBJECT_PATH_NOT_FOUND depending on if + * we use O_NOFOLLOW on the server or not. + */ + if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND) || + NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND)) + { + correct = true; + } else { + printf("cli_ntcreate of %s returned %s - should return" + " either (%s) or (%s)\n", + sname, + nt_errstr(status), + nt_errstr(NT_STATUS_OBJECT_NAME_NOT_FOUND), + nt_errstr(NT_STATUS_OBJECT_PATH_NOT_FOUND)); + goto out; + } + + correct = true; + + out: + + if (fnum != (uint16_t)-1) { + cli_close(cli, fnum); + fnum = (uint16_t)-1; + } + + cli_setatr(cli, sname, 0, 0); + cli_posix_unlink(cli, sname); + cli_setatr(cli, fname, 0, 0); + cli_posix_unlink(cli, fname); + + if (!torture_close_connection(cli)) { + correct = false; + } + + TALLOC_FREE(frame); + return correct; +} + +static NTSTATUS smb1_wild_mangle_list_fn(struct file_info *finfo, + const char *name, + void *state) +{ + char **mangled_name_return = (char **)state; + bool is_mangled = strchr(finfo->name, '~'); + + if (is_mangled) { + *mangled_name_return = talloc_strdup(NULL, finfo->name); + if (*mangled_name_return == NULL) { + return NT_STATUS_NO_MEMORY; + } + } + return NT_STATUS_OK; +} + +static bool run_smb1_wild_mangle_unlink_test(int dummy) +{ + static struct cli_state *cli_posix = NULL; + static struct cli_state *cli = NULL; + uint16_t fnum = (uint16_t)-1; + bool correct = false; + const char *dname = "smb1_wild_mangle_unlink"; + const char *aname = "smb1_wild_mangle_unlink/a"; + const char *star_name = "smb1_wild_mangle_unlink/*"; + char *windows_unlink_name = NULL; + char *mangled_name = NULL; + NTSTATUS status; + + printf("Starting SMB1 wild mangle unlink test\n"); + + /* Open a Windows connection. */ + if (!torture_open_connection(&cli, 0)) { + return false; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + /* Open a POSIX connection. */ + if (!torture_open_connection(&cli_posix, 0)) { + goto out; + } + + smbXcli_conn_set_sockopt(cli_posix->conn, sockops); + + status = torture_setup_unix_extensions(cli_posix); + if (!NT_STATUS_IS_OK(status)) { + printf("server doesn't support POSIX\n"); + goto out; + } + + /* Start fresh. */ + torture_deltree(cli, dname); + + /* + * Create two files - 'a' and '*'. + * We need POSIX extensions for this as '*' + * is not a valid Windows name. + */ + + status = cli_mkdir(cli, dname); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_mkdir of %s returned %s\n", + dname, + nt_errstr(status)); + goto out; + } + + status = cli_posix_open(cli_posix, + aname, + O_RDWR|O_CREAT|O_EXCL, + 0660, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open (create) of %s returned %s\n", + aname, + nt_errstr(status)); + goto out; + } + status = cli_close(cli_posix, fnum); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + status = cli_posix_open(cli_posix, + star_name, + O_RDWR|O_CREAT|O_EXCL, + 0660, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open (create) of %s returned %s\n", + star_name, + nt_errstr(status)); + goto out; + } + status = cli_close(cli_posix, fnum); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + status = cli_list(cli, + star_name, + 0, + smb1_wild_mangle_list_fn, + &mangled_name); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_list of %s returned %s\n", + star_name, + nt_errstr(status)); + goto out; + } + + if (mangled_name == NULL) { + goto out; + } + + printf("mangled_name = %s\n", + mangled_name); + + /* + * Try a Windows unlink with the mangled name. + * This should *NOT* unlink the 'a' name. + */ + + windows_unlink_name = talloc_asprintf(cli_posix, + "%s\\%s", + dname, + mangled_name); + + status = cli_unlink(cli, windows_unlink_name, 0); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_unlink of %s returned %s\n", + windows_unlink_name, + nt_errstr(status)); + goto out; + } + + /* Does 'a' still exist ? */ + status = cli_posix_open(cli_posix, + aname, + O_RDONLY, + 0, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open O_RNONLY of %s returned %s\n", + aname, + nt_errstr(status)); + goto out; + } + + status = cli_close(cli_posix, fnum); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + correct = true; + + out: + + TALLOC_FREE(windows_unlink_name); + TALLOC_FREE(mangled_name); + + if (cli != NULL) { + torture_deltree(cli, dname); + torture_close_connection(cli); + } + + if (cli_posix != NULL) { + torture_close_connection(cli_posix); + } + + return correct; +} + +static bool run_smb1_wild_mangle_rename_test(int dummy) +{ + static struct cli_state *cli_posix = NULL; + static struct cli_state *cli = NULL; + uint16_t fnum = (uint16_t)-1; + bool correct = false; + const char *dname = "smb1_wild_mangle_rename"; + const char *fooname = "smb1_wild_mangle_rename/foo"; + const char *foostar_name = "smb1_wild_mangle_rename/fo*"; + const char *wild_name = "smb1_wild_mangle_rename/*"; + char *windows_rename_src = NULL; + const char *windows_rename_dst = "smb1_wild_mangle_rename\\bar"; + char *mangled_name = NULL; + NTSTATUS status; + + printf("Starting SMB1 wild mangle rename test\n"); + + if (!torture_open_connection(&cli_posix, 0)) { + return false; + } + + smbXcli_conn_set_sockopt(cli_posix->conn, sockops); + + status = torture_setup_unix_extensions(cli_posix); + if (!NT_STATUS_IS_OK(status)) { + printf("server doesn't support POSIX\n"); + return false; + } + + /* Open a Windows connection. */ + if (!torture_open_connection(&cli, 0)) { + goto out; + } + + smbXcli_conn_set_sockopt(cli->conn, sockops); + + /* Ensure we start from fresh. */ + torture_deltree(cli, dname); + + /* + * Create two files - 'foo' and 'fo*'. + * We need POSIX extensions for this as 'fo*' + * is not a valid Windows name. + */ + + status = cli_posix_mkdir(cli_posix, dname, 0770); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_mkdir of %s returned %s\n", + dname, + nt_errstr(status)); + goto out; + } + + status = cli_posix_open(cli_posix, + fooname, + O_RDWR|O_CREAT|O_EXCL, + 0660, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open (create) of %s returned %s\n", + fooname, + nt_errstr(status)); + goto out; + } + status = cli_close(cli_posix, fnum); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + status = cli_posix_open(cli_posix, + foostar_name, + O_RDWR|O_CREAT|O_EXCL, + 0660, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open (create) of %s returned %s\n", + foostar_name, + nt_errstr(status)); + goto out; + } + status = cli_close(cli_posix, fnum); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + /* + * Get the mangled name. We can re-use the + * previous smb1_wild_mangle_list_fn for this. + */ + + status = cli_list(cli, + wild_name, + 0, + smb1_wild_mangle_list_fn, + &mangled_name); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_list of %s returned %s\n", + wild_name, + nt_errstr(status)); + goto out; + } + + if (mangled_name == NULL) { + goto out; + } + + printf("mangled_name = %s\n", + mangled_name); + + /* + * Try a Windows rename with the mangled name. + * This should *NOT* rename the 'foo' name. + */ + + windows_rename_src = talloc_asprintf(cli_posix, + "%s\\%s", + dname, + mangled_name); + + status = cli_rename(cli, + windows_rename_src, + windows_rename_dst, + false); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_rename of %s -> %s returned %s\n", + windows_rename_src, + windows_rename_dst, + nt_errstr(status)); + goto out; + } + + /* Does 'foo' still exist ? */ + status = cli_posix_open(cli_posix, + fooname, + O_RDONLY, + 0, + &fnum); + if (!NT_STATUS_IS_OK(status)) { + printf("cli_posix_open O_RNONLY of %s returned %s\n", + fooname, + nt_errstr(status)); + goto out; + } + + status = cli_close(cli_posix, fnum); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + correct = true; + + out: + + TALLOC_FREE(mangled_name); + TALLOC_FREE(windows_rename_src); + + if (cli != NULL) { + torture_deltree(cli, dname); + torture_close_connection(cli); + } + + torture_close_connection(cli_posix); + + return correct; +} + +/* + * Only testing minimal time strings, as the others + * need (locale-dependent) guessing at what strftime does and + * even may differ in builds. + */ +static bool timesubst_test(void) +{ + TALLOC_CTX *ctx = NULL; + /* Sa 23. Dez 04:33:20 CET 2017 */ + const struct timeval tv = { 1514000000, 123 }; + const char* expect_minimal = "20171223_033320"; + const char* expect_minus = "20171223_033320_000123"; + char *s; + char *env_tz, *orig_tz = NULL; + bool result = true; + + ctx = talloc_new(NULL); + + env_tz = getenv("TZ"); + if(env_tz) { + orig_tz = talloc_strdup(ctx, env_tz); + } + setenv("TZ", "UTC", 1); + + s = minimal_timeval_string(ctx, &tv, false); + + if(!s || strcmp(s, expect_minimal)) { + printf("minimal_timeval_string(ctx, tv, false) returned [%s], expected " + "[%s]\n", s ? s : "", expect_minimal); + result = false; + } + TALLOC_FREE(s); + s = minimal_timeval_string(ctx, &tv, true); + if(!s || strcmp(s, expect_minus)) { + printf("minimal_timeval_string(ctx, tv, true) returned [%s], expected " + "[%s]\n", s ? s : "", expect_minus); + result = false; + } + TALLOC_FREE(s); + + if(orig_tz) { + setenv("TZ", orig_tz, 1); + } + + TALLOC_FREE(ctx); + return result; +} + +static bool run_local_substitute(int dummy) +{ + bool ok = true; + + ok &= subst_test("%U", "bla", "", -1, -1, "bla"); + ok &= subst_test("%u%U", "bla", "", -1, -1, "blabla"); + ok &= subst_test("%g", "", "", -1, -1, "NO_GROUP"); + ok &= subst_test("%G", "", "", -1, -1, "NO_GROUP"); + ok &= subst_test("%g", "", "", -1, 0, gidtoname(0)); + ok &= subst_test("%G", "", "", -1, 0, gidtoname(0)); + ok &= subst_test("%D%u", "u", "dom", -1, 0, "domu"); + ok &= subst_test("%i %I", "", "", -1, -1, "0.0.0.0 0.0.0.0"); + ok &= subst_test("%j %J", "", "", -1, -1, "0_0_0_0 0_0_0_0"); + /* Substitution depends on current time, so better test the underlying + formatting function. At least covers %t. */ + ok &= timesubst_test(); + + /* Different captialization rules in sub_basic... */ + + ok &= (strcmp(talloc_sub_basic(talloc_tos(), "BLA", "dom", "%U%D"), + "blaDOM") == 0); + + return ok; +} + +static bool run_local_base64(int dummy) +{ + int i; + bool ret = true; + + for (i=1; i<2000; i++) { + DATA_BLOB blob1, blob2; + char *b64; + + blob1.data = talloc_array(talloc_tos(), uint8_t, i); + blob1.length = i; + generate_random_buffer(blob1.data, blob1.length); + + b64 = base64_encode_data_blob(talloc_tos(), blob1); + if (b64 == NULL) { + d_fprintf(stderr, "base64_encode_data_blob failed " + "for %d bytes\n", i); + ret = false; + } + blob2 = base64_decode_data_blob(b64); + TALLOC_FREE(b64); + + if (data_blob_cmp(&blob1, &blob2)) { + d_fprintf(stderr, "data_blob_cmp failed for %d " + "bytes\n", i); + ret = false; + } + TALLOC_FREE(blob1.data); + data_blob_free(&blob2); + } + return ret; +} + +static void parse_fn(const struct gencache_timeout *t, + DATA_BLOB blob, + void *private_data) +{ + return; +} + +static bool run_local_gencache(int dummy) +{ + char *val; + time_t tm; + DATA_BLOB blob; + char v; + struct memcache *mem; + int i; + + mem = memcache_init(NULL, 0); + if (mem == NULL) { + d_printf("%s: memcache_init failed\n", __location__); + return false; + } + memcache_set_global(mem); + + if (!gencache_set("foo", "bar", time(NULL) + 1000)) { + d_printf("%s: gencache_set() failed\n", __location__); + return False; + } + + if (!gencache_get("foo", NULL, NULL, NULL)) { + d_printf("%s: gencache_get() failed\n", __location__); + return False; + } + + for (i=0; i<1000000; i++) { + gencache_parse("foo", parse_fn, NULL); + } + + if (!gencache_get("foo", talloc_tos(), &val, &tm)) { + d_printf("%s: gencache_get() failed\n", __location__); + return False; + } + TALLOC_FREE(val); + + if (!gencache_get("foo", talloc_tos(), &val, &tm)) { + d_printf("%s: gencache_get() failed\n", __location__); + return False; + } + + if (strcmp(val, "bar") != 0) { + d_printf("%s: gencache_get() returned %s, expected %s\n", + __location__, val, "bar"); + TALLOC_FREE(val); + return False; + } + + TALLOC_FREE(val); + + if (!gencache_del("foo")) { + d_printf("%s: gencache_del() failed\n", __location__); + return False; + } + if (gencache_del("foo")) { + d_printf("%s: second gencache_del() succeeded\n", + __location__); + return False; + } + + if (gencache_get("foo", talloc_tos(), &val, &tm)) { + d_printf("%s: gencache_get() on deleted entry " + "succeeded\n", __location__); + return False; + } + + blob = data_blob_string_const_null("bar"); + tm = time(NULL) + 60; + + if (!gencache_set_data_blob("foo", blob, tm)) { + d_printf("%s: gencache_set_data_blob() failed\n", __location__); + return False; + } + + if (!gencache_get_data_blob("foo", talloc_tos(), &blob, NULL, NULL)) { + d_printf("%s: gencache_get_data_blob() failed\n", __location__); + return False; + } + + if (strcmp((const char *)blob.data, "bar") != 0) { + d_printf("%s: gencache_get_data_blob() returned %s, expected %s\n", + __location__, (const char *)blob.data, "bar"); + data_blob_free(&blob); + return False; + } + + data_blob_free(&blob); + + if (!gencache_del("foo")) { + d_printf("%s: gencache_del() failed\n", __location__); + return False; + } + if (gencache_del("foo")) { + d_printf("%s: second gencache_del() succeeded\n", + __location__); + return False; + } + + if (gencache_get_data_blob("foo", talloc_tos(), &blob, NULL, NULL)) { + d_printf("%s: gencache_get_data_blob() on deleted entry " + "succeeded\n", __location__); + return False; + } + + v = 1; + blob.data = (uint8_t *)&v; + blob.length = sizeof(v); + + if (!gencache_set_data_blob("blob", blob, tm)) { + d_printf("%s: gencache_set_data_blob() failed\n", + __location__); + return false; + } + if (gencache_get("blob", talloc_tos(), &val, &tm)) { + d_printf("%s: gencache_get succeeded\n", __location__); + return false; + } + + return True; +} + +static bool rbt_testflags(struct db_context *db, const char *key, + const char *value) +{ + bool ret = false; + NTSTATUS status; + struct db_record *rec; + + rec = dbwrap_fetch_locked(db, db, string_tdb_data(key)); + if (rec == NULL) { + d_fprintf(stderr, "fetch_locked failed\n"); + goto done; + } + + status = dbwrap_record_store(rec, string_tdb_data(value), TDB_MODIFY); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { + d_fprintf(stderr, "store TDB_MODIFY unexpected status: %s\n", + nt_errstr(status)); + goto done; + } + + status = dbwrap_record_store(rec, string_tdb_data("overwriteme"), + TDB_INSERT); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "store TDB_INSERT failed: %s\n", + nt_errstr(status)); + goto done; + } + + status = dbwrap_record_store(rec, string_tdb_data(value), TDB_INSERT); + if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) { + d_fprintf(stderr, "store TDB_INSERT unexpected status: %s\n", + nt_errstr(status)); + goto done; + } + + status = dbwrap_record_store(rec, string_tdb_data(value), TDB_MODIFY); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "store TDB_MODIFY failed: %s\n", + nt_errstr(status)); + goto done; + } + + ret = true; +done: + TALLOC_FREE(rec); + return ret; +} + +static bool rbt_testval(struct db_context *db, const char *key, + const char *value) +{ + struct db_record *rec; + TDB_DATA data = string_tdb_data(value); + bool ret = false; + NTSTATUS status; + TDB_DATA dbvalue; + + rec = dbwrap_fetch_locked(db, db, string_tdb_data(key)); + if (rec == NULL) { + d_fprintf(stderr, "fetch_locked failed\n"); + goto done; + } + status = dbwrap_record_store(rec, data, 0); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "store failed: %s\n", nt_errstr(status)); + goto done; + } + TALLOC_FREE(rec); + + rec = dbwrap_fetch_locked(db, db, string_tdb_data(key)); + if (rec == NULL) { + d_fprintf(stderr, "second fetch_locked failed\n"); + goto done; + } + + dbvalue = dbwrap_record_get_value(rec); + if ((dbvalue.dsize != data.dsize) + || (memcmp(dbvalue.dptr, data.dptr, data.dsize) != 0)) { + d_fprintf(stderr, "Got wrong data back\n"); + goto done; + } + + ret = true; + done: + TALLOC_FREE(rec); + return ret; +} + +static int local_rbtree_traverse_read(struct db_record *rec, void *private_data) +{ + int *count2 = (int *)private_data; + (*count2)++; + return 0; +} + +static int local_rbtree_traverse_delete(struct db_record *rec, void *private_data) +{ + int *count2 = (int *)private_data; + (*count2)++; + dbwrap_record_delete(rec); + return 0; +} + +static bool run_local_rbtree(int dummy) +{ + struct db_context *db; + bool ret = false; + int i; + NTSTATUS status; + int count = 0; + int count2 = 0; + + db = db_open_rbt(NULL); + + if (db == NULL) { + d_fprintf(stderr, "db_open_rbt failed\n"); + return false; + } + + if (!rbt_testflags(db, "firstkey", "firstval")) { + goto done; + } + + for (i = 0; i < 999; i++) { + char key[sizeof("key-9223372036854775807")]; + char value[sizeof("value-9223372036854775807")]; + + snprintf(key, sizeof(key), "key%ld", random()); + snprintf(value, sizeof(value) ,"value%ld", random()); + + if (!rbt_testval(db, key, value)) { + goto done; + } + + snprintf(value, sizeof(value) ,"value%ld", random()); + + if (!rbt_testval(db, key, value)) { + goto done; + } + } + + ret = true; + count = 0; count2 = 0; + status = dbwrap_traverse_read(db, local_rbtree_traverse_read, + &count2, &count); + printf("%s: read1: %d %d, %s\n", __func__, count, count2, nt_errstr(status)); + if ((count != count2) || (count != 1000)) { + ret = false; + } + count = 0; count2 = 0; + status = dbwrap_traverse(db, local_rbtree_traverse_delete, + &count2, &count); + printf("%s: delete: %d %d, %s\n", __func__, count, count2, nt_errstr(status)); + if ((count != count2) || (count != 1000)) { + ret = false; + } + count = 0; count2 = 0; + status = dbwrap_traverse_read(db, local_rbtree_traverse_read, + &count2, &count); + printf("%s: read2: %d %d, %s\n", __func__, count, count2, nt_errstr(status)); + if ((count != count2) || (count != 0)) { + ret = false; + } + + done: + TALLOC_FREE(db); + return ret; +} + + +/* + local test for character set functions + + This is a very simple test for the functionality in convert_string_error() + */ +static bool run_local_convert_string(int dummy) +{ + TALLOC_CTX *tmp_ctx = talloc_new(NULL); + const char *test_strings[2] = { "March", "M\303\244rz" }; + char dst[7]; + int i; + + for (i=0; i<2; i++) { + const char *str = test_strings[i]; + int len = strlen(str); + size_t converted_size; + bool ret; + + memset(dst, 'X', sizeof(dst)); + + /* first try with real source length */ + ret = convert_string_error(CH_UNIX, CH_UTF8, + str, len, + dst, sizeof(dst), + &converted_size); + if (ret != true) { + d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str); + goto failed; + } + + if (converted_size != len) { + d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n", + str, len, (int)converted_size); + goto failed; + } + + if (strncmp(str, dst, converted_size) != 0) { + d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst); + goto failed; + } + + if (strlen(str) != converted_size) { + d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str, + (int)strlen(str), (int)converted_size); + goto failed; + } + + if (dst[converted_size] != 'X') { + d_fprintf(stderr, "Expected no termination of '%s'\n", dst); + goto failed; + } + + /* now with srclen==-1, this causes the nul to be + * converted too */ + ret = convert_string_error(CH_UNIX, CH_UTF8, + str, -1, + dst, sizeof(dst), + &converted_size); + if (ret != true) { + d_fprintf(stderr, "Failed to convert '%s' to CH_DISPLAY\n", str); + goto failed; + } + + if (converted_size != len+1) { + d_fprintf(stderr, "Converted size of '%s' should be %d - got %d\n", + str, len, (int)converted_size); + goto failed; + } + + if (strncmp(str, dst, converted_size) != 0) { + d_fprintf(stderr, "Expected '%s' to match '%s'\n", str, dst); + goto failed; + } + + if (len+1 != converted_size) { + d_fprintf(stderr, "Expected '%s' length %d - got %d\n", str, + len+1, (int)converted_size); + goto failed; + } + + if (dst[converted_size] != 'X') { + d_fprintf(stderr, "Expected no termination of '%s'\n", dst); + goto failed; + } + + } + + + TALLOC_FREE(tmp_ctx); + return true; +failed: + TALLOC_FREE(tmp_ctx); + return false; +} + +static bool run_local_string_to_sid(int dummy) { + struct dom_sid sid; + + if (string_to_sid(&sid, "S--1-5-32-545")) { + printf("allowing S--1-5-32-545\n"); + return false; + } + if (string_to_sid(&sid, "S-1-5-32-+545")) { + printf("allowing S-1-5-32-+545\n"); + return false; + } + 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")) { + printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n"); + return false; + } + if (string_to_sid(&sid, "S-1-5-32-545-abc")) { + printf("allowing S-1-5-32-545-abc\n"); + return false; + } + if (string_to_sid(&sid, "S-300-5-32-545")) { + printf("allowing S-300-5-32-545\n"); + return false; + } + if (string_to_sid(&sid, "S-1-0xfffffffffffffe-32-545")) { + printf("allowing S-1-0xfffffffffffffe-32-545\n"); + return false; + } + if (string_to_sid(&sid, "S-1-0xffffffffffff-5294967297-545")) { + printf("allowing S-1-0xffffffffffff-5294967297-545\n"); + return false; + } + if (!string_to_sid(&sid, "S-1-0xfffffffffffe-32-545")) { + printf("could not parse S-1-0xfffffffffffe-32-545\n"); + return false; + } + if (!string_to_sid(&sid, "S-1-5-32-545")) { + printf("could not parse S-1-5-32-545\n"); + return false; + } + if (!dom_sid_equal(&sid, &global_sid_Builtin_Users)) { + struct dom_sid_buf buf; + printf("mis-parsed S-1-5-32-545 as %s\n", + dom_sid_str_buf(&sid, &buf)); + return false; + } + return true; +} + +static bool sid_to_string_test(const char *expected) { + char *str; + bool res = true; + struct dom_sid sid; + + if (!string_to_sid(&sid, expected)) { + printf("could not parse %s\n", expected); + return false; + } + + str = dom_sid_string(NULL, &sid); + if (strcmp(str, expected)) { + printf("Comparison failed (%s != %s)\n", str, expected); + res = false; + } + TALLOC_FREE(str); + return res; +} + +static bool run_local_sid_to_string(int dummy) { + if (!sid_to_string_test("S-1-0xffffffffffff-1-1-1-1-1-1-1-1-1-1-1-1")) + return false; + if (!sid_to_string_test("S-1-545")) + return false; + if (!sid_to_string_test("S-255-3840-1-1-1-1")) + return false; + return true; +} + +static bool run_local_binary_to_sid(int dummy) { + ssize_t ret; + struct dom_sid *sid = talloc(NULL, struct dom_sid); + static const uint8_t good_binary_sid[] = { + 0x1, /* revision number */ + 15, /* num auths */ + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */ + 0x1, 0x1, 0x1, 0x1, /* auth[0] */ + 0x1, 0x1, 0x1, 0x1, /* auth[1] */ + 0x1, 0x1, 0x1, 0x1, /* auth[2] */ + 0x1, 0x1, 0x1, 0x1, /* auth[3] */ + 0x1, 0x1, 0x1, 0x1, /* auth[4] */ + 0x1, 0x1, 0x1, 0x1, /* auth[5] */ + 0x1, 0x1, 0x1, 0x1, /* auth[6] */ + 0x1, 0x1, 0x1, 0x1, /* auth[7] */ + 0x1, 0x1, 0x1, 0x1, /* auth[8] */ + 0x1, 0x1, 0x1, 0x1, /* auth[9] */ + 0x1, 0x1, 0x1, 0x1, /* auth[10] */ + 0x1, 0x1, 0x1, 0x1, /* auth[11] */ + 0x1, 0x1, 0x1, 0x1, /* auth[12] */ + 0x1, 0x1, 0x1, 0x1, /* auth[13] */ + 0x1, 0x1, 0x1, 0x1, /* auth[14] */ + }; + + static const uint8_t long_binary_sid[] = { + 0x1, /* revision number */ + 15, /* num auths */ + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */ + 0x1, 0x1, 0x1, 0x1, /* auth[0] */ + 0x1, 0x1, 0x1, 0x1, /* auth[1] */ + 0x1, 0x1, 0x1, 0x1, /* auth[2] */ + 0x1, 0x1, 0x1, 0x1, /* auth[3] */ + 0x1, 0x1, 0x1, 0x1, /* auth[4] */ + 0x1, 0x1, 0x1, 0x1, /* auth[5] */ + 0x1, 0x1, 0x1, 0x1, /* auth[6] */ + 0x1, 0x1, 0x1, 0x1, /* auth[7] */ + 0x1, 0x1, 0x1, 0x1, /* auth[8] */ + 0x1, 0x1, 0x1, 0x1, /* auth[9] */ + 0x1, 0x1, 0x1, 0x1, /* auth[10] */ + 0x1, 0x1, 0x1, 0x1, /* auth[11] */ + 0x1, 0x1, 0x1, 0x1, /* auth[12] */ + 0x1, 0x1, 0x1, 0x1, /* auth[13] */ + 0x1, 0x1, 0x1, 0x1, /* auth[14] */ + 0x1, 0x1, 0x1, 0x1, /* auth[15] */ + 0x1, 0x1, 0x1, 0x1, /* auth[16] */ + 0x1, 0x1, 0x1, 0x1, /* auth[17] */ + }; + + static const uint8_t long_binary_sid2[] = { + 0x1, /* revision number */ + 32, /* num auths */ + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */ + 0x1, 0x1, 0x1, 0x1, /* auth[0] */ + 0x1, 0x1, 0x1, 0x1, /* auth[1] */ + 0x1, 0x1, 0x1, 0x1, /* auth[2] */ + 0x1, 0x1, 0x1, 0x1, /* auth[3] */ + 0x1, 0x1, 0x1, 0x1, /* auth[4] */ + 0x1, 0x1, 0x1, 0x1, /* auth[5] */ + 0x1, 0x1, 0x1, 0x1, /* auth[6] */ + 0x1, 0x1, 0x1, 0x1, /* auth[7] */ + 0x1, 0x1, 0x1, 0x1, /* auth[8] */ + 0x1, 0x1, 0x1, 0x1, /* auth[9] */ + 0x1, 0x1, 0x1, 0x1, /* auth[10] */ + 0x1, 0x1, 0x1, 0x1, /* auth[11] */ + 0x1, 0x1, 0x1, 0x1, /* auth[12] */ + 0x1, 0x1, 0x1, 0x1, /* auth[13] */ + 0x1, 0x1, 0x1, 0x1, /* auth[14] */ + 0x1, 0x1, 0x1, 0x1, /* auth[15] */ + 0x1, 0x1, 0x1, 0x1, /* auth[16] */ + 0x1, 0x1, 0x1, 0x1, /* auth[17] */ + 0x1, 0x1, 0x1, 0x1, /* auth[18] */ + 0x1, 0x1, 0x1, 0x1, /* auth[19] */ + 0x1, 0x1, 0x1, 0x1, /* auth[20] */ + 0x1, 0x1, 0x1, 0x1, /* auth[21] */ + 0x1, 0x1, 0x1, 0x1, /* auth[22] */ + 0x1, 0x1, 0x1, 0x1, /* auth[23] */ + 0x1, 0x1, 0x1, 0x1, /* auth[24] */ + 0x1, 0x1, 0x1, 0x1, /* auth[25] */ + 0x1, 0x1, 0x1, 0x1, /* auth[26] */ + 0x1, 0x1, 0x1, 0x1, /* auth[27] */ + 0x1, 0x1, 0x1, 0x1, /* auth[28] */ + 0x1, 0x1, 0x1, 0x1, /* auth[29] */ + 0x1, 0x1, 0x1, 0x1, /* auth[30] */ + 0x1, 0x1, 0x1, 0x1, /* auth[31] */ + }; + + ret = sid_parse(good_binary_sid, sizeof(good_binary_sid), sid); + if (ret == -1) { + return false; + } + ret = sid_parse(long_binary_sid2, sizeof(long_binary_sid2), sid); + if (ret != -1) { + return false; + } + ret = sid_parse(long_binary_sid, sizeof(long_binary_sid), sid); + if (ret != -1) { + return false; + } + return true; +} + +/* Split a path name into filename and stream name components. Canonicalise + * such that an implicit $DATA token is always explicit. + * + * The "specification" of this function can be found in the + * run_local_stream_name() function in torture.c, I've tried those + * combinations against a W2k3 server. + */ + +static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname, + char **pbase, char **pstream) +{ + char *base = NULL; + char *stream = NULL; + char *sname; /* stream name */ + const char *stype; /* stream type */ + + DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname)); + + sname = strchr_m(fname, ':'); + + if (sname == NULL) { + if (pbase != NULL) { + base = talloc_strdup(mem_ctx, fname); + NT_STATUS_HAVE_NO_MEMORY(base); + } + goto done; + } + + if (pbase != NULL) { + base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname)); + NT_STATUS_HAVE_NO_MEMORY(base); + } + + sname += 1; + + stype = strchr_m(sname, ':'); + + if (stype == NULL) { + sname = talloc_strdup(mem_ctx, sname); + stype = "$DATA"; + } + else { + if (strcasecmp_m(stype, ":$DATA") != 0) { + /* + * If there is an explicit stream type, so far we only + * allow $DATA. Is there anything else allowed? -- vl + */ + DEBUG(10, ("[%s] is an invalid stream type\n", stype)); + TALLOC_FREE(base); + return NT_STATUS_OBJECT_NAME_INVALID; + } + sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname)); + stype += 1; + } + + if (sname == NULL) { + TALLOC_FREE(base); + return NT_STATUS_NO_MEMORY; + } + + if (sname[0] == '\0') { + /* + * no stream name, so no stream + */ + goto done; + } + + if (pstream != NULL) { + stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype); + if (stream == NULL) { + TALLOC_FREE(sname); + TALLOC_FREE(base); + return NT_STATUS_NO_MEMORY; + } + /* + * upper-case the type field + */ + (void)strupper_m(strchr_m(stream, ':')+1); + } + + done: + if (pbase != NULL) { + *pbase = base; + } + if (pstream != NULL) { + *pstream = stream; + } + return NT_STATUS_OK; +} + +static bool test_stream_name(const char *fname, const char *expected_base, + const char *expected_stream, + NTSTATUS expected_status) +{ + NTSTATUS status; + char *base = NULL; + char *stream = NULL; + + status = split_ntfs_stream_name(talloc_tos(), fname, &base, &stream); + if (!NT_STATUS_EQUAL(status, expected_status)) { + goto error; + } + + if (!NT_STATUS_IS_OK(status)) { + return true; + } + + if (base == NULL) goto error; + + if (strcmp(expected_base, base) != 0) goto error; + + if ((expected_stream != NULL) && (stream == NULL)) goto error; + if ((expected_stream == NULL) && (stream != NULL)) goto error; + + if ((stream != NULL) && (strcmp(expected_stream, stream) != 0)) + goto error; + + TALLOC_FREE(base); + TALLOC_FREE(stream); + return true; + + error: + d_fprintf(stderr, "Do test_stream(%s, %s, %s, %s)\n", + fname, expected_base ? expected_base : "", + expected_stream ? expected_stream : "", + nt_errstr(expected_status)); + d_fprintf(stderr, "-> base=%s, stream=%s, status=%s\n", + base ? base : "", stream ? stream : "", + nt_errstr(status)); + TALLOC_FREE(base); + TALLOC_FREE(stream); + return false; +} + +static bool run_local_stream_name(int dummy) +{ + bool ret = true; + + ret &= test_stream_name( + "bla", "bla", NULL, NT_STATUS_OK); + ret &= test_stream_name( + "bla::$DATA", "bla", NULL, NT_STATUS_OK); + ret &= test_stream_name( + "bla:blub:", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID); + ret &= test_stream_name( + "bla::", NULL, NULL, NT_STATUS_OBJECT_NAME_INVALID); + ret &= test_stream_name( + "bla::123", "bla", NULL, NT_STATUS_OBJECT_NAME_INVALID); + ret &= test_stream_name( + "bla:$DATA", "bla", "$DATA:$DATA", NT_STATUS_OK); + ret &= test_stream_name( + "bla:x:$DATA", "bla", "x:$DATA", NT_STATUS_OK); + ret &= test_stream_name( + "bla:x", "bla", "x:$DATA", NT_STATUS_OK); + + return ret; +} + +static bool data_blob_equal(DATA_BLOB a, DATA_BLOB b) +{ + if (a.length != b.length) { + printf("a.length=%d != b.length=%d\n", + (int)a.length, (int)b.length); + return false; + } + if (memcmp(a.data, b.data, a.length) != 0) { + printf("a.data and b.data differ\n"); + return false; + } + return true; +} + +static bool run_local_memcache(int dummy) +{ + struct memcache *cache; + DATA_BLOB k1, k2, k3, k4, k5; + DATA_BLOB d1, d3; + DATA_BLOB v1, v3; + + TALLOC_CTX *mem_ctx; + char *ptr1 = NULL; + char *ptr2 = NULL; + char *ptr3 = NULL; + + char *str1, *str2; + size_t size1, size2; + bool ret = false; + + mem_ctx = talloc_init("foo"); + if (mem_ctx == NULL) { + return false; + } + + /* STAT_CACHE TESTS */ + + cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100); + + if (cache == NULL) { + printf("memcache_init failed\n"); + return false; + } + + d1 = data_blob_const("d1", 2); + d3 = data_blob_const("d3", 2); + + k1 = data_blob_const("d1", 2); + k2 = data_blob_const("d2", 2); + k3 = data_blob_const("d3", 2); + k4 = data_blob_const("d4", 2); + k5 = data_blob_const("d5", 2); + + memcache_add(cache, STAT_CACHE, k1, d1); + + if (!memcache_lookup(cache, STAT_CACHE, k1, &v1)) { + printf("could not find k1\n"); + return false; + } + if (!data_blob_equal(d1, v1)) { + return false; + } + + memcache_add(cache, STAT_CACHE, k1, d3); + + if (!memcache_lookup(cache, STAT_CACHE, k1, &v3)) { + printf("could not find replaced k1\n"); + return false; + } + if (!data_blob_equal(d3, v3)) { + return false; + } + + TALLOC_FREE(cache); + + /* GETWD_CACHE TESTS */ + str1 = talloc_strdup(mem_ctx, "string1"); + if (str1 == NULL) { + return false; + } + ptr2 = str1; /* Keep an alias for comparison. */ + + str2 = talloc_strdup(mem_ctx, "string2"); + if (str2 == NULL) { + return false; + } + + cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100); + if (cache == NULL) { + printf("memcache_init failed\n"); + return false; + } + + memcache_add_talloc(cache, GETWD_CACHE, k2, &str1); + /* str1 == NULL now. */ + ptr1 = memcache_lookup_talloc(cache, GETWD_CACHE, k2); + if (ptr1 == NULL) { + printf("could not find k2\n"); + return false; + } + if (ptr1 != ptr2) { + printf("fetch of k2 got wrong string\n"); + return false; + } + + /* Add a blob to ensure k2 gets purged. */ + d3 = data_blob_talloc_zero(mem_ctx, 180); + memcache_add(cache, STAT_CACHE, k3, d3); + + ptr2 = memcache_lookup_talloc(cache, GETWD_CACHE, k2); + if (ptr2 != NULL) { + printf("Did find k2, should have been purged\n"); + return false; + } + + /* + * Test that talloc size also is accounted in memcache and + * causes purge of other object. + */ + + str1 = talloc_zero_size(mem_ctx, 100); + str2 = talloc_zero_size(mem_ctx, 100); + + memcache_add_talloc(cache, GETWD_CACHE, k4, &str1); + memcache_add_talloc(cache, GETWD_CACHE, k5, &str1); + + ptr3 = memcache_lookup_talloc(cache, GETWD_CACHE, k4); + if (ptr3 != NULL) { + printf("Did find k4, should have been purged\n"); + return false; + } + + /* + * Test that adding a duplicate non-talloced + * key/value on top of a talloced key/value takes account + * of the talloc_freed value size. + */ + TALLOC_FREE(cache); + TALLOC_FREE(mem_ctx); + + mem_ctx = talloc_init("key_replace"); + if (mem_ctx == NULL) { + return false; + } + + cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100); + if (cache == NULL) { + return false; + } + + /* + * Add a 100 byte talloced string. This will + * store a (4 or 8 byte) pointer and record the + * total talloced size. + */ + str1 = talloc_zero_size(mem_ctx, 100); + memcache_add_talloc(cache, GETWD_CACHE, k4, &str1); + /* + * Now overwrite with a small talloced + * value. This should fit in the existing size + * and the total talloced size should be removed + * from the cache size. + */ + str1 = talloc_zero_size(mem_ctx, 2); + memcache_add_talloc(cache, GETWD_CACHE, k4, &str1); + /* + * Now store a 20 byte string. If the + * total talloced size wasn't accounted for + * and removed in the overwrite, then this + * will evict k4. + */ + str2 = talloc_zero_size(mem_ctx, 20); + memcache_add_talloc(cache, GETWD_CACHE, k5, &str2); + + ptr3 = memcache_lookup_talloc(cache, GETWD_CACHE, k4); + if (ptr3 == NULL) { + printf("Did not find k4, should not have been purged\n"); + return false; + } + + TALLOC_FREE(cache); + TALLOC_FREE(mem_ctx); + + mem_ctx = talloc_init("foo"); + if (mem_ctx == NULL) { + return false; + } + + cache = memcache_init(NULL, 0); + if (cache == NULL) { + return false; + } + + str1 = talloc_strdup(mem_ctx, "string1"); + if (str1 == NULL) { + return false; + } + str2 = talloc_strdup(mem_ctx, "string2"); + if (str2 == NULL) { + return false; + } + memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC, + data_blob_string_const("torture"), &str1); + size1 = talloc_total_size(cache); + + memcache_add_talloc(cache, SINGLETON_CACHE_TALLOC, + data_blob_string_const("torture"), &str2); + size2 = talloc_total_size(cache); + + printf("size1=%d, size2=%d\n", (int)size1, (int)size2); + + if (size2 > size1) { + printf("memcache leaks memory!\n"); + goto fail; + } + + ret = true; + fail: + TALLOC_FREE(cache); + return ret; +} + +static void wbclient_done(struct tevent_req *req) +{ + wbcErr wbc_err; + struct winbindd_response *wb_resp; + int *i = (int *)tevent_req_callback_data_void(req); + + wbc_err = wb_trans_recv(req, req, &wb_resp); + TALLOC_FREE(req); + *i += 1; + d_printf("wb_trans_recv %d returned %s\n", *i, wbcErrorString(wbc_err)); +} + +static bool run_wbclient_multi_ping(int dummy) +{ + struct tevent_context *ev; + struct wb_context **wb_ctx; + struct winbindd_request wb_req; + bool result = false; + int i, j; + + BlockSignals(True, SIGPIPE); + + ev = tevent_context_init(talloc_tos()); + if (ev == NULL) { + goto fail; + } + + wb_ctx = talloc_array(ev, struct wb_context *, torture_nprocs); + if (wb_ctx == NULL) { + goto fail; + } + + ZERO_STRUCT(wb_req); + wb_req.cmd = WINBINDD_PING; + + d_printf("torture_nprocs=%d, numops=%d\n", (int)torture_nprocs, (int)torture_numops); + + for (i=0; iai_addr, + res->ai_addrlen); + freeaddrinfo(res); + } + + count = remove_duplicate_addrs2(test_vector, i); + + if (count != 14) { + fprintf(stderr, "count wrong (%zu) should be 14\n", + count); + return false; + } + + for (i = 0; i < count; i++) { + char addr[INET6_ADDRSTRLEN]; + + print_sockaddr(addr, sizeof(addr), &test_vector[i].u.ss); + + if (strcmp(addr, remove_duplicate_addrs2_test_strings_result[i]) != 0) { + fprintf(stderr, "mismatch on [%zu] [%s] [%s]\n", + i, + addr, + remove_duplicate_addrs2_test_strings_result[i]); + return false; + } + } + + printf("run_local_remove_duplicate_addrs2: success\n"); + return true; +} + +static bool run_local_tdb_opener(int dummy) +{ + TDB_CONTEXT *t; + unsigned v = 0; + + while (1) { + t = tdb_open("test.tdb", 1000, TDB_CLEAR_IF_FIRST, + O_RDWR|O_CREAT, 0755); + if (t == NULL) { + perror("tdb_open failed"); + return false; + } + tdb_close(t); + + v += 1; + printf("\r%u", v); + } + return true; +} + +static bool run_local_tdb_writer(int dummy) +{ + TDB_CONTEXT *t; + unsigned v = 0; + TDB_DATA val; + + t = tdb_open("test.tdb", 1000, 0, O_RDWR|O_CREAT, 0755); + if (t == 0) { + perror("tdb_open failed"); + return 1; + } + + val.dptr = (uint8_t *)&v; + val.dsize = sizeof(v); + + while (1) { + TDB_DATA data; + int ret; + + ret = tdb_store(t, val, val, 0); + if (ret != 0) { + printf("%s\n", tdb_errorstr(t)); + } + v += 1; + printf("\r%u", v); + + data = tdb_fetch(t, val); + if (data.dptr != NULL) { + SAFE_FREE(data.dptr); + } + } + return true; +} + +static bool run_local_canonicalize_path(int dummy) +{ + const char *src[] = { + "/foo/..", + "/..", + "/foo/bar/../baz", + "/foo/././", + "/../foo", + ".././././", + ".././././../../../boo", + "./..", + "/", + "/../../", + "/foo/../", + "/./././", + "/./././.", + "/.../././.", + "/./././.foo", + "/./././.foo.", + "/./././foo.", + "/foo/bar/..", + "/foo/bar/../baz/", + "////////////////", + "/////////./././././.", + "/./.././../.boo/../baz", + "/a/component/path", + "/a/component/path/", + "/a/component/path/..", + "/a/component/../path/", + "///a/./././///component/../////path/", + NULL + }; + const char *dst[] = { + "/", + "/", + "/foo/baz", + "/foo", + "/foo", + "/", + "/boo", + "/", + "/", + "/", + "/", + "/", + "/", + "/...", + "/.foo", + "/.foo.", + "/foo.", + "/foo", + "/foo/baz", + "/", + "/", + "/baz", + "/a/component/path", + "/a/component/path", + "/a/component", + "/a/path", + "/a/path", + NULL + }; + unsigned int i; + + for (i = 0; src[i] != NULL; i++) { + char *d = canonicalize_absolute_path(talloc_tos(), src[i]); + if (d == NULL) { + perror("talloc fail\n"); + return false; + } + if (strcmp(d, dst[i]) != 0) { + d_fprintf(stderr, + "canonicalize mismatch %s -> %s != %s", + src[i], d, dst[i]); + return false; + } + talloc_free(d); + } + return true; +} +struct session_setup_nt1_truncated_state { + uint16_t vwv[13]; + uint8_t bytes[20]; +}; + +static void smb1_session_setup_nt1_truncated_done(struct tevent_req *subreq); + +static struct tevent_req *smb1_session_setup_nt1_truncated_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct smbXcli_conn *conn) +{ + uint16_t *vwv = NULL; + uint8_t *bytes = NULL; + const char *pass = "12345678"; + const char *uname = "z"; + struct session_setup_nt1_truncated_state *state = NULL; + struct tevent_req *req = NULL; + struct tevent_req *subreq = NULL; + + req = tevent_req_create(mem_ctx, + &state, + struct session_setup_nt1_truncated_state); + if (req == NULL) { + return NULL; + } + vwv = &state->vwv[0]; + bytes = &state->bytes[0]; + + SCVAL(vwv+0, 0, 0xff); + SCVAL(vwv+0, 1, 0); + SSVAL(vwv+1, 0, 0); + SSVAL(vwv+2, 0, 8192); + SSVAL(vwv+3, 0, 2); + SSVAL(vwv+4, 0, 1); + SIVAL(vwv+5, 0, 0); + SSVAL(vwv+7, 0, strlen(pass)); /* OEMPasswordLen */ + SSVAL(vwv+8, 0, 0); /* UnicodePasswordLen */ + SSVAL(vwv+9, 0, 0); /* reserved */ + SSVAL(vwv+10, 0, 0); /* reserved */ + SIVAL(vwv+11, 0, CAP_STATUS32); + + memcpy(bytes, pass, strlen(pass)); + bytes += strlen(pass); + memcpy(bytes, uname, strlen(uname)+1); + + subreq = smb1cli_req_send(state, ev, conn, + SMBsesssetupX, + 0, /* additional_flags */ + 0, /* clear_flags */ + 0, /* additional_flags2 */ + 0, /* clear_flags2 */ + 10000, /* timeout_msec */ + getpid(), + NULL, /* tcon */ + NULL, /* session */ + 13, /* wct */ + state->vwv, + strlen(pass), /* Truncate length at password. */ + state->bytes); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, + smb1_session_setup_nt1_truncated_done, + req); + return req; +} + +static void smb1_session_setup_nt1_truncated_done(struct tevent_req *subreq) +{ + struct tevent_req *req = + tevent_req_callback_data(subreq, + struct tevent_req); + struct session_setup_nt1_truncated_state *state = + tevent_req_data(req, + struct session_setup_nt1_truncated_state); + NTSTATUS status; + struct smb1cli_req_expected_response expected[] = { + { + .status = NT_STATUS_OK, + .wct = 3, + }, + }; + + status = smb1cli_req_recv(subreq, state, + NULL, + NULL, + NULL, + NULL, + NULL, /* pvwv_offset */ + NULL, + NULL, + NULL, /* pbytes_offset */ + NULL, + expected, ARRAY_SIZE(expected)); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + tevent_req_done(req); +} + +static NTSTATUS smb1_session_setup_nt1_truncated_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static bool run_smb1_truncated_sesssetup(int dummy) +{ + struct tevent_context *ev; + struct tevent_req *req; + struct smbXcli_conn *conn; + struct sockaddr_storage ss; + NTSTATUS status; + int fd; + bool ok; + + printf("Starting send truncated SMB1 sesssetup.\n"); + + ok = resolve_name(host, &ss, 0x20, true); + if (!ok) { + d_fprintf(stderr, "Could not resolve name %s\n", host); + return false; + } + + status = open_socket_out(&ss, 445, 10000, &fd); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "open_socket_out failed: %s\n", + nt_errstr(status)); + return false; + } + + conn = smbXcli_conn_create(talloc_tos(), fd, host, SMB_SIGNING_OFF, 0, + NULL, 0, NULL); + if (conn == NULL) { + d_fprintf(stderr, "smbXcli_conn_create failed\n"); + return false; + } + + status = smbXcli_negprot(conn, + 0, + PROTOCOL_NT1, + PROTOCOL_NT1, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "smbXcli_negprot failed!\n"); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + d_fprintf(stderr, "samba_tevent_context_init failed\n"); + return false; + } + + req = smb1_session_setup_nt1_truncated_send(ev, ev, conn); + if (req == NULL) { + d_fprintf(stderr, "smb1_session_setup_nt1_truncated_send failed\n"); + return false; + } + + ok = tevent_req_poll_ntstatus(req, ev, &status); + if (!ok) { + d_fprintf(stderr, "tevent_req_poll failed with status %s\n", + nt_errstr(status)); + return false; + } + + status = smb1_session_setup_nt1_truncated_recv(req); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "smb1_session_setup_nt1_truncated_recv returned " + "%s, expected NT_STATUS_OK\n", + nt_errstr(status)); + return false; + } + + TALLOC_FREE(conn); + return true; +} + +struct smb1_negotiate_exit_state { + int dummy; +}; + +static void smb1_negotiate_exit_done(struct tevent_req *subreq); + +static struct tevent_req *smb1_negotiate_exit_send( + TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct smbXcli_conn *conn) +{ + struct smb1_negotiate_exit_state *state = NULL; + struct tevent_req *req = NULL; + struct tevent_req *subreq = NULL; + + req = tevent_req_create(mem_ctx, + &state, + struct smb1_negotiate_exit_state); + if (req == NULL) { + return NULL; + } + subreq = smb1cli_req_send(state, ev, conn, + SMBexit, + 0, /* additional_flags */ + 0, /* clear_flags */ + 0, /* additional_flags2 */ + 0, /* clear_flags2 */ + 10000, /* timeout_msec */ + getpid(), + NULL, /* tcon */ + NULL, /* session */ + 0, /* wct */ + NULL, + 0, + NULL); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, + smb1_negotiate_exit_done, + req); + return req; +} + +static void smb1_negotiate_exit_done(struct tevent_req *subreq) +{ + struct tevent_req *req = + tevent_req_callback_data(subreq, + struct tevent_req); + struct smb1_negotiate_exit_state *state = + tevent_req_data(req, + struct smb1_negotiate_exit_state); + NTSTATUS status; + struct smb1cli_req_expected_response expected[] = { + { + .status = NT_STATUS_OK, + .wct = 0, + }, + }; + + status = smb1cli_req_recv(subreq, state, + NULL, + NULL, + NULL, + NULL, + NULL, /* pvwv_offset */ + NULL, + NULL, + NULL, /* pbytes_offset */ + NULL, + expected, ARRAY_SIZE(expected)); + TALLOC_FREE(subreq); + if (tevent_req_nterror(req, status)) { + return; + } + tevent_req_done(req); +} + +static NTSTATUS smb1_negotiate_exit_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_ntstatus(req); +} + +static bool do_smb1_exit(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct smbXcli_conn *conn) +{ + struct tevent_req *req; + bool ok; + NTSTATUS status; + NTSTATUS expected_status = NT_STATUS_DOS(ERRSRV, ERRinvnid);; + + req = smb1_negotiate_exit_send(ev, ev, conn); + if (req == NULL) { + d_fprintf(stderr, "smb1_negotiate_exit_send failed\n"); + return false; + } + + ok = tevent_req_poll_ntstatus(req, ev, &status); + if (!ok) { + d_fprintf(stderr, "tevent_req_poll failed with status %s\n", + nt_errstr(status)); + return false; + } + + status = smb1_negotiate_exit_recv(req); + if (!NT_STATUS_EQUAL(status, expected_status)) { + d_fprintf(stderr, "smb1_negotiate_exit_recv returned " + "%s, expected ERRSRV, ERRinvnid\n", + nt_errstr(status)); + return false; + } + return true; +} + +static bool run_smb1_negotiate_exit(int dummy) +{ + struct tevent_context *ev; + struct smbXcli_conn *conn; + struct sockaddr_storage ss; + NTSTATUS status; + int fd; + bool ok; + + printf("Starting send SMB1 negotiate+exit.\n"); + + ok = resolve_name(host, &ss, 0x20, true); + if (!ok) { + d_fprintf(stderr, "Could not resolve name %s\n", host); + return false; + } + + status = open_socket_out(&ss, 445, 10000, &fd); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "open_socket_out failed: %s\n", + nt_errstr(status)); + return false; + } + + conn = smbXcli_conn_create(talloc_tos(), fd, host, SMB_SIGNING_OFF, 0, + NULL, 0, NULL); + if (conn == NULL) { + d_fprintf(stderr, "smbXcli_conn_create failed\n"); + return false; + } + + status = smbXcli_negprot(conn, + 0, + PROTOCOL_NT1, + PROTOCOL_NT1, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "smbXcli_negprot failed!\n"); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + d_fprintf(stderr, "samba_tevent_context_init failed\n"); + return false; + } + + /* + * Call do_smb1_exit twice to catch a server crash, the + * server sends the first return code then crashes. + */ + ok = do_smb1_exit(ev, ev, conn); + if (!ok) { + d_fprintf(stderr, "do_smb1_exit (1) failed\n"); + return false; + } + ok = do_smb1_exit(ev, ev, conn); + if (!ok) { + d_fprintf(stderr, "do_smb1_exit (2) failed\n"); + return false; + } + + TALLOC_FREE(conn); + return true; +} + +static bool run_smb1_negotiate_tcon(int dummy) +{ + struct cli_state *cli = NULL; + uint16_t cnum = 0; + uint16_t max_xmit = 0; + NTSTATUS status; + + printf("Starting send SMB1 negotiate+tcon.\n"); + cli = open_nbt_connection(); + if (cli == NULL) { + d_fprintf(stderr, "open_nbt_connection failed!\n"); + return false; + } + smbXcli_conn_set_sockopt(cli->conn, sockops); + + status = smbXcli_negprot(cli->conn, + 0, + PROTOCOL_NT1, + PROTOCOL_NT1, + NULL, + NULL, + NULL); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "smbXcli_negprot failed %s!\n", + nt_errstr(status)); + return false; + } + status = cli_raw_tcon(cli, + share, + "", + "?????", + &max_xmit, + &cnum); + if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) { + d_fprintf(stderr, "cli_raw_tcon failed - got %s " + "(should get NT_STATUS_ACCESS_DENIED)!\n", + nt_errstr(status)); + return false; + } + return true; +} + +static bool run_ign_bad_negprot(int dummy) +{ + struct tevent_context *ev; + struct tevent_req *req; + struct smbXcli_conn *conn; + struct sockaddr_storage ss; + NTSTATUS status; + int fd; + bool ok; + + printf("starting ignore bad negprot\n"); + + ok = resolve_name(host, &ss, 0x20, true); + if (!ok) { + d_fprintf(stderr, "Could not resolve name %s\n", host); + return false; + } + + status = open_socket_out(&ss, 445, 10000, &fd); + if (!NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "open_socket_out failed: %s\n", + nt_errstr(status)); + return false; + } + + conn = smbXcli_conn_create(talloc_tos(), fd, host, SMB_SIGNING_OFF, 0, + NULL, 0, NULL); + if (conn == NULL) { + d_fprintf(stderr, "smbXcli_conn_create failed\n"); + return false; + } + + status = smbXcli_negprot(conn, + 0, + PROTOCOL_CORE, + PROTOCOL_CORE, + NULL, + NULL, + NULL); + if (NT_STATUS_IS_OK(status)) { + d_fprintf(stderr, "smbXcli_negprot succeeded!\n"); + return false; + } + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + d_fprintf(stderr, "samba_tevent_context_init failed\n"); + return false; + } + + req = smb1cli_session_setup_nt1_send( + ev, ev, conn, 0, getpid(), NULL, 65503, 2, 1, 0, "", "", + data_blob_null, data_blob_null, 0x40, + "Windows 2000 2195", "Windows 2000 5.0"); + if (req == NULL) { + d_fprintf(stderr, "smb1cli_session_setup_nt1_send failed\n"); + return false; + } + + ok = tevent_req_poll_ntstatus(req, ev, &status); + if (!ok) { + d_fprintf(stderr, "tevent_req_poll failed\n"); + return false; + } + + status = smb1cli_session_setup_nt1_recv(req, NULL, NULL, NULL, NULL, + NULL, NULL); + if (!NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_RESET)) { + d_fprintf(stderr, "smb1cli_session_setup_nt1_recv returned " + "%s, expected NT_STATUS_CONNECTION_RESET\n", + nt_errstr(status)); + return false; + } + + TALLOC_FREE(conn); + + printf("starting ignore bad negprot\n"); + + return true; +} + + +static double create_procs(bool (*fn)(int), bool *result) +{ + int i, status; + volatile pid_t *child_status; + volatile bool *child_status_out; + int synccount; + int tries = 8; + struct timeval start; + + synccount = 0; + + child_status = (volatile pid_t *)anonymous_shared_allocate(sizeof(pid_t)*torture_nprocs); + if (!child_status) { + printf("Failed to setup shared memory\n"); + return -1; + } + + child_status_out = (volatile bool *)anonymous_shared_allocate(sizeof(bool)*torture_nprocs); + if (!child_status_out) { + printf("Failed to setup result status shared memory\n"); + return -1; + } + + for (i = 0; i < torture_nprocs; i++) { + child_status[i] = 0; + child_status_out[i] = True; + } + + start = timeval_current(); + + for (i=0;i TEST1 TEST2 ...\n"); + + printf("\t-d debuglevel\n"); + printf("\t-U user%%pass\n"); + printf("\t-k use kerberos\n"); + printf("\t-N numprocs\n"); + printf("\t-n my_netbios_name\n"); + printf("\t-W workgroup\n"); + printf("\t-o num_operations\n"); + printf("\t-O socket_options\n"); + printf("\t-m maximum protocol\n"); + printf("\t-L use oplocks\n"); + printf("\t-c CLIENT.TXT specify client load file for NBENCH\n"); + printf("\t-A showall\n"); + printf("\t-p port\n"); + printf("\t-s seed\n"); + printf("\t-b unclist_filename specify multiple shares for multiple connections\n"); + printf("\t-f filename filename to test\n"); + printf("\t-e encrypt\n"); + printf("\n\n"); + + printf("tests are:"); + for (i=0;torture_ops[i].name;i++) { + printf(" %s", torture_ops[i].name); + } + printf("\n"); + + printf("default test is ALL\n"); + + exit(1); +} + +/**************************************************************************** + main program +****************************************************************************/ + int main(int argc,char *argv[]) +{ + int opt, i; + char *p; + int gotuser = 0; + int gotpass = 0; + bool correct = True; + TALLOC_CTX *frame = talloc_stackframe(); + int seed = time(NULL); + struct loadparm_context *lp_ctx = NULL; + +#ifdef HAVE_SETBUFFER + setbuffer(stdout, NULL, 0); +#endif + + setup_logging("smbtorture", DEBUG_STDOUT); + + smb_init_locale(); + fault_setup(); + + lp_ctx = loadparm_init_s3(frame, loadparm_s3_helpers()); + if (lp_ctx == NULL) { + fprintf(stderr, + "Failed to initialise the global parameter structure.\n"); + return 1; + } + + if (is_default_dyn_CONFIGFILE()) { + if(getenv("SMB_CONF_PATH")) { + set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH")); + } + } + lp_load_global(get_dyn_CONFIGFILE()); + load_interfaces(); + + if (argc < 2) { + usage(); + } + + for(p = argv[1]; *p; p++) + if(*p == '\\') + *p = '/'; + + if (strncmp(argv[1], "//", 2)) { + usage(); + } + + fstrcpy(host, &argv[1][2]); + p = strchr_m(&host[2],'/'); + if (!p) { + usage(); + } + *p = 0; + fstrcpy(share, p+1); + + fstrcpy(myname, get_myname(talloc_tos())); + if (!*myname) { + fprintf(stderr, "Failed to get my hostname.\n"); + return 1; + } + + if (*username == 0 && getenv("LOGNAME")) { + fstrcpy(username,getenv("LOGNAME")); + } + + argc--; + argv++; + + fstrcpy(workgroup, lp_workgroup()); + + while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:f:")) + != EOF) { + switch (opt) { + case 'p': + port_to_use = atoi(optarg); + break; + case 's': + seed = atoi(optarg); + break; + case 'W': + fstrcpy(workgroup,optarg); + break; + case 'm': + lpcfg_set_cmdline(lp_ctx, "client max protocol", optarg); + break; + case 'N': + torture_nprocs = atoi(optarg); + break; + case 'o': + torture_numops = atoi(optarg); + break; + case 'd': + lpcfg_set_cmdline(lp_ctx, "log level", optarg); + break; + case 'O': + sockops = optarg; + break; + case 'L': + use_oplocks = True; + break; + case 'l': + local_path = optarg; + break; + case 'A': + torture_showall = True; + break; + case 'n': + fstrcpy(myname, optarg); + break; + case 'c': + client_txt = optarg; + break; + case 'e': + do_encrypt = true; + break; + case 'k': +#ifdef HAVE_KRB5 + use_kerberos = True; +#else + d_printf("No kerberos support compiled in\n"); + exit(1); +#endif + break; + case 'U': + gotuser = 1; + fstrcpy(username,optarg); + p = strchr_m(username,'%'); + if (p) { + *p = 0; + fstrcpy(password, p+1); + gotpass = 1; + } + break; + case 'b': + fstrcpy(multishare_conn_fname, optarg); + use_multishare_conn = True; + break; + case 'B': + torture_blocksize = atoi(optarg); + break; + case 'f': + test_filename = SMB_STRDUP(optarg); + break; + default: + printf("Unknown option %c (%d)\n", (char)opt, opt); + usage(); + } + } + + d_printf("using seed %d\n", seed); + + srandom(seed); + + if(use_kerberos && !gotuser) gotpass = True; + + while (!gotpass) { + char pwd[256] = {0}; + int rc; + + rc = samba_getpass("Password:", pwd, sizeof(pwd), false, false); + if (rc == 0) { + fstrcpy(password, pwd); + gotpass = 1; + } + } + + printf("host=%s share=%s user=%s myname=%s\n", + host, share, username, myname); + + torture_creds = cli_session_creds_init(frame, + username, + workgroup, + NULL, /* realm */ + password, + use_kerberos, + false, /* fallback_after_kerberos */ + false, /* use_ccache */ + false); /* password_is_nt_hash */ + if (torture_creds == NULL) { + d_printf("cli_session_creds_init() failed.\n"); + exit(1); + } + + if (argc == optind) { + correct = run_test("ALL"); + } else { + for (i=optind;i. +*/ + +#include "includes.h" +#include "system/filesys.h" +#include "torture/proto.h" +#include "../libcli/security/security.h" +#include "libsmb/libsmb.h" +#include "libsmb/clirap.h" +#include "lib/util/string_wrappers.h" + +bool torture_utable(int dummy) +{ + struct cli_state *cli; + fstring fname, alt_name; + uint16_t fnum; + smb_ucs2_t c2; + int c, len, fd; + int chars_allowed=0, alt_allowed=0; + uint8_t valid[0x10000]; + + printf("starting utable\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + memset(valid, 0, sizeof(valid)); + + torture_deltree(cli, "\\utable"); + cli_mkdir(cli, "\\utable"); + + for (c=1; c < 0x10000; c++) { + size_t size = 0; + char *p; + + SSVAL(&c2, 0, c); + fstrcpy(fname, "\\utable\\x"); + p = fname+strlen(fname); + if (!convert_string(CH_UTF16LE, CH_UNIX, + &c2, 2, + p, sizeof(fname)-strlen(fname),&size)) { + d_printf("convert_string %s failed !\n", fname); + continue; + } + len = size; + p[len] = 0; + fstrcat(fname,"_a_long_extension"); + + if (!NT_STATUS_IS_OK(cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, + DENY_NONE, &fnum))) { + continue; + } + + chars_allowed++; + + cli_qpathinfo_alt_name(cli, fname, alt_name); + + if (strncmp(alt_name, "X_A_L", 5) != 0) { + alt_allowed++; + valid[c] = 1; + d_printf("fname=[%s] alt_name=[%s]\n", fname, alt_name); + } + + cli_close(cli, fnum); + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + if (c % 100 == 0) { + printf("%d (%d/%d)\r", c, chars_allowed, alt_allowed); + } + } + printf("%d (%d/%d)\n", c, chars_allowed, alt_allowed); + + cli_rmdir(cli, "\\utable"); + + d_printf("%d chars allowed %d alt chars allowed\n", chars_allowed, alt_allowed); + + fd = open("valid.dat", O_WRONLY|O_CREAT|O_TRUNC, 0644); + if (fd == -1) { + d_printf("Failed to create valid.dat - %s", strerror(errno)); + return False; + } + if (write(fd, valid, 0x10000) != 0x10000) { + d_printf("Failed to create valid.dat - %s", strerror(errno)); + close(fd); + return false; + } + close(fd); + d_printf("wrote valid.dat\n"); + + return True; +} + + +static char *form_name(int c) +{ + static fstring fname; + smb_ucs2_t c2; + char *p; + size_t len = 0; + + fstrcpy(fname, "\\utable\\"); + p = fname+strlen(fname); + SSVAL(&c2, 0, c); + + if (!convert_string(CH_UTF16LE, CH_UNIX, + &c2, 2, + p, sizeof(fname)-strlen(fname), &len)) { + d_printf("form_name: convert string %s failed\n", + fname); + return NULL; + } + p[len] = 0; + return fname; +} + +bool torture_casetable(int dummy) +{ + static struct cli_state *cli; + char *fname; + uint16_t fnum; + int c, i; +#define MAX_EQUIVALENCE 8 + smb_ucs2_t equiv[0x10000][MAX_EQUIVALENCE]; + printf("starting casetable\n"); + + if (!torture_open_connection(&cli, 0)) { + return False; + } + + memset(equiv, 0, sizeof(equiv)); + + torture_deltree(cli, "\\utable"); + if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\utable"))) { + printf("Failed to create utable directory!\n"); + return False; + } + + for (c=1; c < 0x10000; c++) { + off_t size; + + if (c == '.' || c == '\\') continue; + + printf("%04x (%c)\n", c, isprint(c)?c:'.'); + + fname = form_name(c); + if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, + GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, + FILE_SHARE_NONE, + FILE_OPEN_IF, 0, 0, &fnum, NULL))) { + printf("Failed to create file with char %04x\n", c); + continue; + } + + size = 0; + + if (!NT_STATUS_IS_OK(cli_qfileinfo_basic( + cli, fnum, NULL, &size, + NULL, NULL, NULL, NULL, NULL))) { + continue; + } + + if (size > 0) { + /* found a character equivalence! */ + int c2[MAX_EQUIVALENCE]; + + if (size/sizeof(int) >= MAX_EQUIVALENCE) { + printf("too many chars match?? size=%ld c=0x%04x\n", + (unsigned long)size, c); + cli_close(cli, fnum); + return False; + } + + cli_read(cli, fnum, (char *)c2, 0, size, NULL); + printf("%04x: ", c); + equiv[c][0] = c; + for (i=0; i. +*/ + +#include "includes.h" +#include "locking/share_mode_lock.h" +#include "smbd/smbd.h" +#include "smbd/globals.h" +#include "lib/cmdline/cmdline.h" +#include "vfstest.h" +#include "../libcli/smbreadline/smbreadline.h" +#include "auth.h" +#include "serverid.h" +#include "messages.h" +#include "libcli/security/security.h" +#include "lib/smbd_shim.h" +#include "system/filesys.h" +#include "lib/global_contexts.h" +#include "lib/param/param.h" + +/* List to hold groups of commands */ +static struct cmd_list { + struct cmd_list *prev, *next; + struct cmd_set *cmd_set; +} *cmd_list; + +/* shall we do talloc_report after each command? */ +static int memreports = 0; + +/**************************************************************************** +handle completion of commands for readline +****************************************************************************/ +static char **completion_fn(const char *text, int start, int end) +{ +#define MAX_COMPLETIONS 100 + char **matches; + int i, count=0; + struct cmd_list *commands = cmd_list; + + if (start) + return NULL; + + /* make sure we have a list of valid commands */ + if (!commands) + return NULL; + + matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS); + if (!matches) return NULL; + + matches[count++] = SMB_STRDUP(text); + if (!matches[0]) return NULL; + + while (commands && count < MAX_COMPLETIONS-1) + { + if (!commands->cmd_set) + break; + + for (i=0; commands->cmd_set[i].name; i++) + { + if ((strncmp(text, commands->cmd_set[i].name, strlen(text)) == 0) && + commands->cmd_set[i].fn) + { + matches[count] = SMB_STRDUP(commands->cmd_set[i].name); + if (!matches[count]) + return NULL; + count++; + } + } + + commands = commands->next; + } + + if (count == 2) { + SAFE_FREE(matches[0]); + matches[0] = SMB_STRDUP(matches[1]); + } + matches[count] = NULL; + return matches; +} + +static char *next_command(TALLOC_CTX *ctx, char **cmdstr) +{ + char *command; + char *p; + + if (!cmdstr || !(*cmdstr)) + return NULL; + + p = strchr_m(*cmdstr, ';'); + if (p) + *p = '\0'; + command = talloc_strdup(ctx, *cmdstr); + + /* Pass back the remaining cmdstring + (a trailing delimiter ";" does also work), + or NULL at last cmdstring. + */ + *cmdstr = p ? p + 1 : p; + + return command; +} + +/* Load specified configuration file */ +static NTSTATUS cmd_conf(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + if (argc != 2) { + printf("Usage: %s \n", argv[0]); + return NT_STATUS_OK; + } + + if (!lp_load_with_shares(argv[1])) { + printf("Error loading \"%s\"\n", argv[1]); + return NT_STATUS_OK; + } + + printf("\"%s\" successfully loaded\n", argv[1]); + return NT_STATUS_OK; +} + +/* Display help on commands */ +static NTSTATUS cmd_help(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + struct cmd_list *tmp; + struct cmd_set *tmp_set; + + /* Usage */ + if (argc > 2) { + printf("Usage: %s [command]\n", argv[0]); + return NT_STATUS_OK; + } + + /* Help on one command */ + + if (argc == 2) { + for (tmp = cmd_list; tmp; tmp = tmp->next) { + + tmp_set = tmp->cmd_set; + + while(tmp_set->name) { + if (strequal(argv[1], tmp_set->name)) { + if (tmp_set->usage && + tmp_set->usage[0]) + printf("%s\n", tmp_set->usage); + else + printf("No help for %s\n", tmp_set->name); + + return NT_STATUS_OK; + } + + tmp_set++; + } + } + + printf("No such command: %s\n", argv[1]); + return NT_STATUS_OK; + } + + /* List all commands */ + + for (tmp = cmd_list; tmp; tmp = tmp->next) { + + tmp_set = tmp->cmd_set; + + while(tmp_set->name) { + + printf("%15s\t\t%s\n", tmp_set->name, + tmp_set->description ? tmp_set->description: + ""); + + tmp_set++; + } + } + + return NT_STATUS_OK; +} + +/* Change the debug level */ +static NTSTATUS cmd_debuglevel(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + if (argc > 2) { + printf("Usage: %s [debuglevel]\n", argv[0]); + return NT_STATUS_OK; + } + + if (argc == 2) { + struct loadparm_context *lp_ctx = samba_cmdline_get_lp_ctx(); + lpcfg_set_cmdline(lp_ctx, "log level", argv[1]); + } + + printf("debuglevel is %d\n", DEBUGLEVEL); + + return NT_STATUS_OK; +} + +static NTSTATUS cmd_freemem(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + /* Cleanup */ + talloc_destroy(mem_ctx); + mem_ctx = NULL; + vfs->data = NULL; + vfs->data_size = 0; + return NT_STATUS_OK; +} + +static NTSTATUS cmd_quit(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv) +{ + /* Cleanup */ + talloc_destroy(mem_ctx); + + exit(0); + return NT_STATUS_OK; /* NOTREACHED */ +} + +static struct cmd_set vfstest_commands[] = { + + { .name = "GENERAL OPTIONS" }, + + { "conf", cmd_conf, "Load smb configuration file", "conf " }, + { "help", cmd_help, "Get help on commands", "" }, + { "?", cmd_help, "Get help on commands", "" }, + { "debuglevel", cmd_debuglevel, "Set debug level", "" }, + { "freemem", cmd_freemem, "Free currently allocated buffers", "" }, + { "exit", cmd_quit, "Exit program", "" }, + { "quit", cmd_quit, "Exit program", "" }, + + { .name = NULL } +}; + +static struct cmd_set separator_command[] = { + { + .name = "---------------", + .description = "----------------------" + }, + { + .name = NULL, + }, +}; + + +extern struct cmd_set vfs_commands[]; +static struct cmd_set *vfstest_command_list[] = { + vfstest_commands, + vfs_commands, + NULL +}; + +static void add_command_set(struct cmd_set *cmd_set) +{ + struct cmd_list *entry; + + if (!(entry = SMB_MALLOC_P(struct cmd_list))) { + DEBUG(0, ("out of memory\n")); + return; + } + + ZERO_STRUCTP(entry); + + entry->cmd_set = cmd_set; + DLIST_ADD(cmd_list, entry); +} + +static NTSTATUS do_cmd(struct vfs_state *vfs, struct cmd_set *cmd_entry, char *cmd) +{ + const char *p = cmd; + const char **argv = NULL; + NTSTATUS result = NT_STATUS_UNSUCCESSFUL; + char *buf; + TALLOC_CTX *mem_ctx = talloc_stackframe(); + int argc = 0; + + /* Count number of arguments first time through the loop then + allocate memory and strdup them. */ + + again: + while(next_token_talloc(mem_ctx, &p, &buf, " ")) { + if (argv) { + argv[argc] = talloc_strdup(argv, buf); + } + argc++; + } + + if (!argv) { + /* Create argument list */ + + argv = talloc_zero_array(mem_ctx, const char *, argc); + if (argv == NULL) { + fprintf(stderr, "out of memory\n"); + result = NT_STATUS_NO_MEMORY; + goto done; + } + + p = cmd; + argc = 0; + + goto again; + } + + /* Call the function */ + + if (cmd_entry->fn) { + /* Run command */ + result = cmd_entry->fn(vfs, mem_ctx, argc, (const char **)argv); + } else { + fprintf (stderr, "Invalid command\n"); + goto done; + } + + done: + + /* Cleanup */ + + if (argv) { + char **_argv = discard_const_p(char *, argv); + TALLOC_FREE(_argv); + argv = NULL; + } + + if (memreports != 0) { + talloc_report_full(mem_ctx, stdout); + } + TALLOC_FREE(mem_ctx); + return result; +} + +/* Process a command entered at the prompt or as part of -c */ +static NTSTATUS process_cmd(struct vfs_state *vfs, char *cmd) +{ + struct cmd_list *temp_list; + bool found = False; + char *buf; + const char *p = cmd; + NTSTATUS result = NT_STATUS_OK; + TALLOC_CTX *mem_ctx = talloc_stackframe(); + int len = 0; + + if (cmd[strlen(cmd) - 1] == '\n') + cmd[strlen(cmd) - 1] = '\0'; + + if (!next_token_talloc(mem_ctx, &p, &buf, " ")) { + TALLOC_FREE(mem_ctx); + return NT_STATUS_OK; + } + + /* Strip the trailing \n if it exists */ + len = strlen(buf); + if (buf[len-1] == '\n') + buf[len-1] = '\0'; + + /* Search for matching commands */ + + for (temp_list = cmd_list; temp_list; temp_list = temp_list->next) { + struct cmd_set *temp_set = temp_list->cmd_set; + + while(temp_set->name) { + if (strequal(buf, temp_set->name)) { + found = True; + result = do_cmd(vfs, temp_set, cmd); + + goto done; + } + temp_set++; + } + } + + done: + if (!found && buf[0]) { + printf("command not found: %s\n", buf); + TALLOC_FREE(mem_ctx); + return NT_STATUS_OK; + } + + if (!NT_STATUS_IS_OK(result)) { + printf("result was %s\n", nt_errstr(result)); + } + + TALLOC_FREE(mem_ctx); + return result; +} + +static void process_file(struct vfs_state *pvfs, char *filename) { + FILE *file; + char command[3 * PATH_MAX]; + + if (*filename == '-') { + file = stdin; + } else { + file = fopen(filename, "r"); + if (file == NULL) { + printf("vfstest: error reading file (%s)!", filename); + printf("errno n.%d: %s", errno, strerror(errno)); + exit(-1); + } + } + + while (fgets(command, 3 * PATH_MAX, file) != NULL) { + process_cmd(pvfs, command); + } + + if (file != stdin) { + fclose(file); + } +} + +static void vfstest_exit_server(const char * const reason) _NORETURN_; +static void vfstest_exit_server(const char * const reason) +{ + DEBUG(3,("Server exit (%s)\n", (reason ? reason : ""))); + exit(0); +} + +static void vfstest_exit_server_cleanly(const char * const reason) _NORETURN_; +static void vfstest_exit_server_cleanly(const char * const reason) +{ + vfstest_exit_server("normal exit"); +} + +struct smb_request *vfstest_get_smbreq(TALLOC_CTX *mem_ctx, + struct vfs_state *vfs) +{ + struct smb_request *result; + uint8_t *inbuf; + + result = talloc_zero(mem_ctx, struct smb_request); + if (result == NULL) { + return NULL; + } + result->sconn = vfs->conn->sconn; + result->mid = ++vfs->mid; + + inbuf = talloc_array(result, uint8_t, smb_size); + if (inbuf == NULL) { + goto fail; + } + SSVAL(inbuf, smb_mid, result->mid); + smb_setlen(inbuf, smb_size-4); + result->inbuf = inbuf; + return result; +fail: + TALLOC_FREE(result); + return NULL; +} + +/* Main function */ + +int main(int argc, const char *argv[]) +{ + char *cmdstr = NULL; + struct cmd_set **cmd_set; + struct conn_struct_tos *c = NULL; + struct vfs_state *vfs; + int opt; + int i; + char *filename = NULL; + char *cwd = NULL; + TALLOC_CTX *frame = talloc_stackframe(); + struct auth_session_info *session_info = NULL; + NTSTATUS status = NT_STATUS_OK; + bool ok; + + /* make sure the vars that get altered (4th field) are in + a fixed location or certain compilers complain */ + poptContext pc; + struct poptOption long_options[] = { + POPT_AUTOHELP + { + .longName = "file", + .shortName = 'f', + .argInfo = POPT_ARG_STRING, + .arg = &filename, + }, + { + .longName = "command", + .shortName = 'c', + .argInfo = POPT_ARG_STRING, + .arg = &cmdstr, + .val = 0, + .descrip = "Execute specified list of commands", + }, + { + .longName = "memreport", + .shortName = 'm', + .argInfo = POPT_ARG_INT, + .arg = &memreports, + .descrip = "Report memory left on talloc stackframe after each command", + }, + POPT_COMMON_SAMBA + POPT_COMMON_VERSION + POPT_TABLEEND + }; + static const struct smbd_shim vfstest_shim_fns = + { + .exit_server = vfstest_exit_server, + .exit_server_cleanly = vfstest_exit_server_cleanly, + }; + + smb_init_locale(); + + setlinebuf(stdout); + + ok = samba_cmdline_init(frame, + SAMBA_CMDLINE_CONFIG_SERVER, + true /* require_smbconf */); + if (!ok) { + TALLOC_FREE(frame); + exit(1); + } + + pc = samba_popt_get_context("vfstest", argc, argv, long_options, 0); + if (pc == NULL) { + TALLOC_FREE(frame); + exit(1); + } + + while ((opt = poptGetNextOpt(pc)) != -1) { + switch (opt) { + case POPT_ERROR_BADOPT: + fprintf(stderr, "\nInvalid option %s: %s\n\n", + poptBadOption(pc, 0), poptStrerror(opt)); + poptPrintUsage(pc, stderr, 0); + exit(1); + } + } + + poptFreeContext(pc); + + /* we want total control over the permissions on created files, + so set our umask to 0 */ + umask(0); + + /* TODO: check output */ + reload_services(NULL, NULL, false); + + per_thread_cwd_check(); + + set_smbd_shim(&vfstest_shim_fns); + + /* Load command lists */ + + cmd_set = vfstest_command_list; + + while(*cmd_set) { + add_command_set(*cmd_set); + add_command_set(separator_command); + cmd_set++; + } + + /* some basic initialization stuff */ + sec_init(); + init_guest_session_info(frame); + locking_init(); + vfs = talloc_zero(frame, struct vfs_state); + if (vfs == NULL) { + return 1; + } + status = make_session_info_guest(vfs, &session_info); + if (!NT_STATUS_IS_OK(status)) { + return 1; + } + + /* Provided by libreplace if not present. Always mallocs. */ + cwd = get_current_dir_name(); + if (cwd == NULL) { + return -1; + } + + status = create_conn_struct_tos_cwd(global_messaging_context(), + -1, + cwd, + session_info, + &c); + SAFE_FREE(cwd); + if (!NT_STATUS_IS_OK(status)) { + return 1; + } + vfs->conn = c->conn; + + vfs->conn->share_access = FILE_GENERIC_ALL; + vfs->conn->read_only = false; + + file_init(vfs->conn->sconn); + for (i=0; i < 1024; i++) + vfs->files[i] = NULL; + + if (!posix_locking_init(false)) { + return 1; + } + + /* Do we have a file input? */ + if (filename && filename[0]) { + process_file(vfs, filename); + return 0; + } + + /* Do anything specified with -c */ + if (cmdstr && cmdstr[0]) { + char *cmd; + char *p = cmdstr; + + while((cmd=next_command(frame, &p)) != NULL) { + status = process_cmd(vfs, cmd); + } + + TALLOC_FREE(cmd); + return NT_STATUS_IS_OK(status) ? 0 : 1; + } + + /* Loop around accepting commands */ + + while(1) { + char *line = NULL; + + line = smb_readline("vfstest $> ", NULL, completion_fn); + + if (line == NULL) { + break; + } + + if (line[0] != '\n') { + status = process_cmd(vfs, line); + } + SAFE_FREE(line); + } + + TALLOC_FREE(vfs); + TALLOC_FREE(frame); + return NT_STATUS_IS_OK(status) ? 0 : 1; +} diff --git a/source3/torture/vfstest.h b/source3/torture/vfstest.h new file mode 100644 index 0000000..bc28d49 --- /dev/null +++ b/source3/torture/vfstest.h @@ -0,0 +1,51 @@ +/* + Unix SMB/CIFS implementation. + VFS module tester + + Copyright (C) Simo Sorce 2002 + Copyright (C) Eric Lorimer 2002 + + Most of this code was ripped off of rpcclient. + Copyright (C) Tim Potter 2000-2001 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +struct func_entry { + char *name; + int (*fn)(struct connection_struct *conn, const char *path); +}; + +struct vfs_state { + struct connection_struct *conn; + uint64_t mid; + struct files_struct *files[1024]; + struct smb_Dir *currentdir; + void *data; + size_t data_size; +}; + +struct smb_request *vfstest_get_smbreq(TALLOC_CTX *mem_ctx, + struct vfs_state *vfs); + +struct cmd_set { + const char *name; + NTSTATUS (*fn)(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, + const char **argv); + const char *description; + const char *usage; +}; + +NTSTATUS cmd_test_chain(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv); diff --git a/source3/torture/vfstest_chain.c b/source3/torture/vfstest_chain.c new file mode 100644 index 0000000..174117b --- /dev/null +++ b/source3/torture/vfstest_chain.c @@ -0,0 +1,342 @@ +/* + Unix SMB/CIFS implementation. + Test smbd chain routines + + Copyright (C) Volker Lendecke 2012 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" +#include "vfstest.h" +#include "smbd/smbd.h" + +static const uint8_t nonchain1_data[] = +{0x00,0x00,0x00,0xBE,0xFF,0x53,0x4D,0x42,0x72,0x00,0x00,0x00,0x00,0x18,0x43 +,0xC8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 +,0xFE,0xFF,0x00,0x00,0x01,0x00,0x00,0x9B,0x00,0x02,0x50,0x43,0x20,0x4E,0x45 +,0x54,0x57,0x4F,0x52,0x4B,0x20,0x50,0x52,0x4F,0x47,0x52,0x41,0x4D,0x20,0x31 +,0x2E,0x30,0x00,0x02,0x4D,0x49,0x43,0x52,0x4F,0x53,0x4F,0x46,0x54,0x20,0x4E +,0x45,0x54,0x57,0x4F,0x52,0x4B,0x53,0x20,0x31,0x2E,0x30,0x33,0x00,0x02,0x4D +,0x49,0x43,0x52,0x4F,0x53,0x4F,0x46,0x54,0x20,0x4E,0x45,0x54,0x57,0x4F,0x52 +,0x4B,0x53,0x20,0x33,0x2E,0x30,0x00,0x02,0x4C,0x41,0x4E,0x4D,0x41,0x4E,0x31 +,0x2E,0x30,0x00,0x02,0x4C,0x4D,0x31,0x2E,0x32,0x58,0x30,0x30,0x32,0x00,0x02 +,0x44,0x4F,0x53,0x20,0x4C,0x41,0x4E,0x4D,0x41,0x4E,0x32,0x2E,0x31,0x00,0x02 +,0x4C,0x41,0x4E,0x4D,0x41,0x4E,0x32,0x2E,0x31,0x00,0x02,0x53,0x61,0x6D,0x62 +,0x61,0x00,0x02,0x4E,0x54,0x20,0x4C,0x41,0x4E,0x4D,0x41,0x4E,0x20,0x31,0x2E +,0x30,0x00,0x02,0x4E,0x54,0x20,0x4C,0x4D,0x20,0x30,0x2E,0x31,0x32,0x00}; + +static const uint8_t nonchain2_data[] = +{0x00,0x00,0x00,0xA4,0xFF,0x53,0x4D,0x42,0x73,0x00,0x00,0x00,0x00,0x18,0x43 +,0xC8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF +,0x00,0xE7,0x00,0x00,0x02,0x00,0x0C,0xFF,0x00,0x00,0x00,0xFF,0xFF,0x02,0x00 +,0x01,0x00,0x00,0x00,0x00,0x00,0x53,0x00,0x00,0x00,0x00,0x00,0x54,0x00,0x00 +,0x80,0x69,0x00,0x60,0x51,0x06,0x06,0x2B,0x06,0x01,0x05,0x05,0x02,0xA0,0x47 +,0x30,0x45,0xA0,0x0E,0x30,0x0C,0x06,0x0A,0x2B,0x06,0x01,0x04,0x01,0x82,0x37 +,0x02,0x02,0x0A,0xA2,0x33,0x04,0x31,0x4E,0x54,0x4C,0x4D,0x53,0x53,0x50,0x00 +,0x01,0x00,0x00,0x00,0x15,0x82,0x08,0x60,0x09,0x00,0x09,0x00,0x20,0x00,0x00 +,0x00,0x08,0x00,0x08,0x00,0x29,0x00,0x00,0x00,0x57,0x4F,0x52,0x4B,0x47,0x52 +,0x4F,0x55,0x50,0x46,0x52,0x45,0x45,0x42,0x53,0x44,0x38,0x55,0x00,0x6E,0x00 +,0x69,0x00,0x78,0x00,0x00,0x00,0x53,0x00,0x61,0x00,0x6D,0x00,0x62,0x00,0x61 +,0x00,0x00,0x00}; + +static const uint8_t chain1_data[] = +{0x00,0x00,0x00,0x57,0xFF,0x53,0x4D,0x42,0x2D,0x00,0x00,0x00,0x00,0x88,0x03 +,0xC8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00 +,0x00,0xE7,0x64,0x00,0x05,0x00,0x0F,0x2F,0x00,0x44,0x00,0x67,0x19,0x20,0x00 +,0x40,0xDD,0x44,0x4F,0x07,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x01 +,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x04,0x00 +,0x54,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 +,0x00}; + +static const uint8_t chain2_data[] = +{0x00,0x00,0x00,0x8C,0xFF,0x53,0x4D,0x42,0x73,0x00,0x00,0x00,0x00,0x18,0x43 +,0xC8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF +,0x03,0xE7,0x00,0x00,0x02,0x00,0x0D,0x75,0x00,0x58,0x00,0xFF,0xFF,0x02,0x00 +,0x03,0xE7,0x04,0xE7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x54 +,0x00,0x00,0x00,0x1B,0x00,0x00,0x00,0x00,0x00,0x00,0x55,0x00,0x6E,0x00,0x69 +,0x00,0x78,0x00,0x00,0x00,0x53,0x00,0x61,0x00,0x6D,0x00,0x62,0x00,0x61,0x00 +,0x00,0x00,0x04,0xFF,0xFF,0x00,0x00,0x08,0x00,0x01,0x00,0x29,0x00,0x00,0x5C +,0x00,0x5C,0x00,0x31,0x00,0x32,0x00,0x37,0x00,0x2E,0x00,0x30,0x00,0x2E,0x00 +,0x30,0x00,0x2E,0x00,0x31,0x00,0x5C,0x00,0x49,0x00,0x50,0x00,0x43,0x00,0x24 +,0x00,0x00,0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x00}; + +static const uint8_t bug_8360_data[] = +{0x00,0x00,0x00,0xE9,0xFF,0x53,0x4D,0x42,0x2F,0x00,0x00,0x00,0x00,0x08,0x03 +,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00 +,0x94,0x00,0x64,0x00,0xA5,0x45,0x0C,0x0A,0x00,0x3C,0x00,0xFA,0x4B,0x00,0x00 +,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x9D,0x00,0x4C +,0x00,0x9E,0x00,0x00,0x05,0xFA,0x4B,0x03,0x00,0x90,0x26,0x00,0x00,0x00,0x00 +,0x00,0x00,0x41,0x4E,0x4D,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58 +,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58}; + +static const uint8_t invalid1_data[] = +{0x00,0x00,0x0A,0x2E,0xFF,0x53,0x4D,0x42,0x72,0x00,0x00,0x00,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9,0xA9 +,0xA9,0xA9,0xA9,0xA9,0xA9,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 +,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xD5,0x15,0x00,0x00,0x81,0x0B,0x00,0x77 +,0x00,0x02,0x50,0x43,0x20,0x4E,0x45,0x54,0x57,0x4F,0x52,0x4B,0x20,0x50,0x52 +,0x4F,0x47,0x52,0x41,0x4D,0x20,0x31,0x2E,0x30,0x00,0x02,0x4D,0x49,0x43,0x52 +,0x4F,0x53,0x4F,0x46,0x54,0x20,0x4E,0x45,0x54,0x57,0x4F,0x52,0x4B,0x53,0x20 +,0x33,0x2E,0x30,0x00,0x02,0x44,0x4F,0x53,0x20,0x4C,0x4D,0x31,0x2E,0x32,0x58 +,0x30,0x30,0x32,0x00,0x02,0x44,0x4F,0x53,0x20,0x4C,0x41,0x4E,0x4D,0x41,0x4E +,0x32,0x2E,0x31,0x00,0x02,0x57,0x69,0x6E,0x64,0x6F,0x77,0x73,0x20,0x66,0x6F +,0x72,0x20,0x57,0x6F,0x72,0x6B,0x67,0x72,0x6F,0x75,0x70,0x73,0x20,0x33,0x2E +,0x31,0x61,0x00,0x02,0x4E,0x54,0x20,0x4C,0x4D,0x20,0x30,0x2E,0x31,0x32,0x00}; + +static const uint8_t invalid2_data[] = +{0x00,0x00,0x01,0x60,0xFF,0x53,0x4D,0x42,0x73,0x00,0x00,0x00,0x00,0x18,0x07 +,0x00,0x00,0x00,0x00,0x00,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74 +,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00 +,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74 +,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00 +,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74 +,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00 +,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74 +,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00 +,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74 +,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00 +,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74 +,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00 +,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74 +,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00,0x74,0x00 +,0x74,0x00,0x74,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00 +,0x00,0x04,0x00,0x0D,0x75,0x00,0x54,0x00,0x68,0x0B,0x02,0x00,0x00,0x00,0x04 +,0x06,0x03,0x80,0x01,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0xD4,0x00,0x00,0x00 +,0x17,0x00,0x00,0x00,0x57,0x69,0x6E,0x64,0x6F,0x77,0x73,0x20,0x37,0x20,0x50 +,0x72,0x6F,0x00,0x57,0x49,0x4E,0x37,0x00,0x00,0x00,0x04,0xFF,0x00,0x91,0x00 +,0x08,0x00,0x18,0x00,0x32,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 +,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 +,0x5C,0x5C,0x31,0x39,0x32,0x2E,0x31,0x36,0x38,0x2E,0x31,0x2E,0x38,0x36,0x5C +,0x49,0x50,0x43,0x24,0x00,0x3F,0x3F,0x3F,0x3F,0x3F,0x00}; +/* end binary data. size = 356 bytes */ + +NTSTATUS cmd_test_chain(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, + int argc, const char **argv) +{ + bool ret = true; + unsigned chain_length; + struct smb_request **requests; + + ret &= !smb1_is_chain(nonchain1_data); + ret &= !smb1_is_chain(nonchain2_data); + + ret &= smb1_is_chain(chain1_data); + + chain_length = smb1_chain_length(chain1_data); + ret &= (chain_length == 3); + + ret &= smb1_is_chain(chain2_data); + + chain_length = smb1_chain_length(chain2_data); + ret &= (chain_length == 2); + + ret &= smb1_is_chain(bug_8360_data); + + chain_length = smb1_chain_length(bug_8360_data); + ret &= (chain_length == 2); + + ret &= !smb1_is_chain(invalid1_data); + + chain_length = smb1_chain_length(invalid1_data); + ret &= (chain_length == 1); + + ret &= !smb1_is_chain(invalid2_data); + + chain_length = smb1_chain_length(invalid2_data); + ret &= (chain_length == 0); + + ret &= smb1_parse_chain(talloc_tos(), chain1_data, + NULL, false, 0, + &requests, &chain_length); + ret &= (chain_length == 3); + + ret &= smb1_parse_chain(talloc_tos(), chain2_data, + NULL, false, 0, + &requests, &chain_length); + ret &= (chain_length == 2); + + return ret ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL; +} diff --git a/source3/torture/wbc_async.c b/source3/torture/wbc_async.c new file mode 100644 index 0000000..9560e36 --- /dev/null +++ b/source3/torture/wbc_async.c @@ -0,0 +1,758 @@ +/* + Unix SMB/CIFS implementation. + Infrastructure for async winbind requests + Copyright (C) Volker Lendecke 2008 + + ** NOTE! The following LGPL license applies to the wbclient + ** library. This does NOT imply that all of Samba is released + ** under the LGPL + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 3 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + +#include "replace.h" +#include "system/filesys.h" +#include "system/network.h" +#include +#include +#include "lib/async_req/async_sock.h" +#include "nsswitch/winbind_struct_protocol.h" +#include "nsswitch/libwbclient/wbclient.h" +#include "wbc_async.h" +#include "lib/util/blocking.h" + +wbcErr map_wbc_err_from_errno(int error) +{ + switch(error) { + case EPERM: + case EACCES: + return WBC_ERR_AUTH_ERROR; + case ENOMEM: + return WBC_ERR_NO_MEMORY; + case EIO: + default: + return WBC_ERR_UNKNOWN_FAILURE; + } +} + +bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err) +{ + enum tevent_req_state state; + uint64_t error; + if (!tevent_req_is_error(req, &state, &error)) { + *pwbc_err = WBC_ERR_SUCCESS; + return false; + } + + switch (state) { + case TEVENT_REQ_USER_ERROR: + *pwbc_err = error; + break; + case TEVENT_REQ_TIMED_OUT: + *pwbc_err = WBC_ERR_UNKNOWN_FAILURE; + break; + case TEVENT_REQ_NO_MEMORY: + *pwbc_err = WBC_ERR_NO_MEMORY; + break; + default: + *pwbc_err = WBC_ERR_UNKNOWN_FAILURE; + break; + } + return true; +} + +wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req) +{ + wbcErr wbc_err; + + if (tevent_req_is_wbcerr(req, &wbc_err)) { + return wbc_err; + } + + return WBC_ERR_SUCCESS; +} + +struct wbc_debug_ops { + void (*debug)(void *context, enum wbcDebugLevel level, + const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0); + void *context; +}; + +struct wb_context { + struct tevent_queue *queue; + int fd; + bool is_priv; + const char *dir; + struct wbc_debug_ops debug_ops; +}; + +static int make_nonstd_fd(int fd) +{ + size_t i; + int sys_errno = 0; + int fds[3]; + size_t num_fds = 0; + + if (fd == -1) { + return -1; + } + while (fd < 3) { + fds[num_fds++] = fd; + fd = dup(fd); + if (fd == -1) { + sys_errno = errno; + break; + } + } + for (i=0; i= 0) { + flags |= FD_CLOEXEC; + result = fcntl( new_fd, F_SETFD, flags ); + } + if (result < 0) { + goto fail; + } +#endif + return new_fd; + + fail: + if (new_fd != -1) { + int sys_errno = errno; + close(new_fd); + errno = sys_errno; + } + return -1; +} + +/* Just put a prototype to avoid moving the whole function around */ +static const char *winbindd_socket_dir(void); + +struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx, const char* dir) +{ + struct wb_context *result; + + result = talloc_zero(mem_ctx, struct wb_context); + if (result == NULL) { + return NULL; + } + result->queue = tevent_queue_create(result, "wb_trans"); + if (result->queue == NULL) { + TALLOC_FREE(result); + return NULL; + } + result->fd = -1; + result->is_priv = false; + + if (dir != NULL) { + result->dir = talloc_strdup(result, dir); + } else { + result->dir = winbindd_socket_dir(); + } + if (result->dir == NULL) { + TALLOC_FREE(result); + return NULL; + } + return result; +} + +struct wb_connect_state { + int dummy; +}; + +static void wbc_connect_connected(struct tevent_req *subreq); + +static struct tevent_req *wb_connect_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + const char *dir) +{ + struct tevent_req *result, *subreq; + struct wb_connect_state *state; + struct sockaddr_un sunaddr; + struct stat st; + char *path = NULL; + wbcErr wbc_err; + + result = tevent_req_create(mem_ctx, &state, struct wb_connect_state); + if (result == NULL) { + return NULL; + } + + if (wb_ctx->fd != -1) { + close(wb_ctx->fd); + wb_ctx->fd = -1; + } + + /* Check permissions on unix socket directory */ + + if (lstat(dir, &st) == -1) { + wbc_err = WBC_ERR_WINBIND_NOT_AVAILABLE; + goto post_status; + } + + if (!S_ISDIR(st.st_mode) || + (st.st_uid != 0 && st.st_uid != geteuid())) { + wbc_err = WBC_ERR_WINBIND_NOT_AVAILABLE; + goto post_status; + } + + /* Connect to socket */ + + path = talloc_asprintf(mem_ctx, "%s/%s", dir, + WINBINDD_SOCKET_NAME); + if (path == NULL) { + goto nomem; + } + + sunaddr.sun_family = AF_UNIX; + strlcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path)); + TALLOC_FREE(path); + + /* If socket file doesn't exist, don't bother trying to connect + with retry. This is an attempt to make the system usable when + the winbindd daemon is not running. */ + + if ((lstat(sunaddr.sun_path, &st) == -1) + || !S_ISSOCK(st.st_mode) + || (st.st_uid != 0 && st.st_uid != geteuid())) { + wbc_err = WBC_ERR_WINBIND_NOT_AVAILABLE; + goto post_status; + } + + wb_ctx->fd = make_safe_fd(socket(AF_UNIX, SOCK_STREAM, 0)); + if (wb_ctx->fd == -1) { + wbc_err = map_wbc_err_from_errno(errno); + goto post_status; + } + + subreq = async_connect_send(mem_ctx, ev, wb_ctx->fd, + (struct sockaddr *)(void *)&sunaddr, + sizeof(sunaddr), NULL, NULL, NULL); + if (subreq == NULL) { + goto nomem; + } + tevent_req_set_callback(subreq, wbc_connect_connected, result); + return result; + + post_status: + tevent_req_error(result, wbc_err); + return tevent_req_post(result, ev); + nomem: + TALLOC_FREE(result); + return NULL; +} + +static void wbc_connect_connected(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + int res, err; + + res = async_connect_recv(subreq, &err); + TALLOC_FREE(subreq); + if (res == -1) { + tevent_req_error(req, map_wbc_err_from_errno(err)); + return; + } + tevent_req_done(req); +} + +static wbcErr wb_connect_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_wbcerr(req); +} + +static const char *winbindd_socket_dir(void) +{ + if (nss_wrapper_enabled()) { + const char *env_dir; + + env_dir = getenv("SELFTEST_WINBINDD_SOCKET_DIR"); + if (env_dir != NULL) { + return env_dir; + } + } + + return WINBINDD_SOCKET_DIR; +} + +struct wb_open_pipe_state { + struct wb_context *wb_ctx; + struct tevent_context *ev; + bool need_priv; + struct winbindd_request wb_req; +}; + +static void wb_open_pipe_connect_nonpriv_done(struct tevent_req *subreq); +static void wb_open_pipe_ping_done(struct tevent_req *subreq); +static void wb_open_pipe_getpriv_done(struct tevent_req *subreq); +static void wb_open_pipe_connect_priv_done(struct tevent_req *subreq); + +static struct tevent_req *wb_open_pipe_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + bool need_priv) +{ + struct tevent_req *result, *subreq; + struct wb_open_pipe_state *state; + + result = tevent_req_create(mem_ctx, &state, struct wb_open_pipe_state); + if (result == NULL) { + return NULL; + } + state->wb_ctx = wb_ctx; + state->ev = ev; + state->need_priv = need_priv; + + if (wb_ctx->fd != -1) { + close(wb_ctx->fd); + wb_ctx->fd = -1; + } + + subreq = wb_connect_send(state, ev, wb_ctx, wb_ctx->dir); + if (subreq == NULL) { + goto fail; + } + tevent_req_set_callback(subreq, wb_open_pipe_connect_nonpriv_done, + result); + return result; + + fail: + TALLOC_FREE(result); + return NULL; +} + +static void wb_open_pipe_connect_nonpriv_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wb_open_pipe_state *state = tevent_req_data( + req, struct wb_open_pipe_state); + wbcErr wbc_err; + + wbc_err = wb_connect_recv(subreq); + TALLOC_FREE(subreq); + if (!WBC_ERROR_IS_OK(wbc_err)) { + state->wb_ctx->is_priv = true; + tevent_req_error(req, wbc_err); + return; + } + + ZERO_STRUCT(state->wb_req); + state->wb_req.cmd = WINBINDD_INTERFACE_VERSION; + state->wb_req.pid = getpid(); + (void)snprintf(state->wb_req.client_name, + sizeof(state->wb_req.client_name), + "%s", + "TORTURE"); + + subreq = wb_simple_trans_send(state, state->ev, NULL, + state->wb_ctx->fd, &state->wb_req); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wb_open_pipe_ping_done, req); +} + +static void wb_open_pipe_ping_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wb_open_pipe_state *state = tevent_req_data( + req, struct wb_open_pipe_state); + struct winbindd_response *wb_resp; + int ret, err; + + ret = wb_simple_trans_recv(subreq, state, &wb_resp, &err); + TALLOC_FREE(subreq); + if (ret == -1) { + tevent_req_error(req, map_wbc_err_from_errno(err)); + return; + } + + if (!state->need_priv) { + tevent_req_done(req); + return; + } + + state->wb_req.cmd = WINBINDD_PRIV_PIPE_DIR; + state->wb_req.pid = getpid(); + + subreq = wb_simple_trans_send(state, state->ev, NULL, + state->wb_ctx->fd, &state->wb_req); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wb_open_pipe_getpriv_done, req); +} + +static void wb_open_pipe_getpriv_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wb_open_pipe_state *state = tevent_req_data( + req, struct wb_open_pipe_state); + struct winbindd_response *wb_resp = NULL; + int ret, err; + + ret = wb_simple_trans_recv(subreq, state, &wb_resp, &err); + TALLOC_FREE(subreq); + if (ret == -1) { + tevent_req_error(req, map_wbc_err_from_errno(err)); + return; + } + + close(state->wb_ctx->fd); + state->wb_ctx->fd = -1; + + subreq = wb_connect_send(state, state->ev, state->wb_ctx, + (char *)wb_resp->extra_data.data); + TALLOC_FREE(wb_resp); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wb_open_pipe_connect_priv_done, req); +} + +static void wb_open_pipe_connect_priv_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wb_open_pipe_state *state = tevent_req_data( + req, struct wb_open_pipe_state); + wbcErr wbc_err; + + wbc_err = wb_connect_recv(subreq); + TALLOC_FREE(subreq); + if (!WBC_ERROR_IS_OK(wbc_err)) { + tevent_req_error(req, wbc_err); + return; + } + state->wb_ctx->is_priv = true; + tevent_req_done(req); +} + +static wbcErr wb_open_pipe_recv(struct tevent_req *req) +{ + return tevent_req_simple_recv_wbcerr(req); +} + +struct wb_trans_state { + struct wb_trans_state *prev, *next; + struct wb_context *wb_ctx; + struct tevent_context *ev; + struct winbindd_request *wb_req; + struct winbindd_response *wb_resp; + bool need_priv; +}; + +static bool closed_fd(int fd) +{ + struct timeval tv; + fd_set r_fds; + int selret; + + if (fd == -1) { + return true; + } + + FD_ZERO(&r_fds); + FD_SET(fd, &r_fds); + ZERO_STRUCT(tv); + + selret = select(fd+1, &r_fds, NULL, NULL, &tv); + if (selret == -1) { + return true; + } + if (selret == 0) { + return false; + } + return (FD_ISSET(fd, &r_fds)); +} + +static void wb_trans_trigger(struct tevent_req *req, void *private_data); +static void wb_trans_connect_done(struct tevent_req *subreq); +static void wb_trans_done(struct tevent_req *subreq); +static void wb_trans_retry_wait_done(struct tevent_req *subreq); + +struct tevent_req *wb_trans_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, bool need_priv, + struct winbindd_request *wb_req) +{ + struct tevent_req *req; + struct wb_trans_state *state; + + req = tevent_req_create(mem_ctx, &state, struct wb_trans_state); + if (req == NULL) { + return NULL; + } + state->wb_ctx = wb_ctx; + state->ev = ev; + state->wb_req = wb_req; + state->need_priv = need_priv; + + if (!tevent_queue_add(wb_ctx->queue, ev, req, wb_trans_trigger, + NULL)) { + tevent_req_oom(req); + return tevent_req_post(req, ev); + } + return req; +} + +static void wb_trans_trigger(struct tevent_req *req, void *private_data) +{ + struct wb_trans_state *state = tevent_req_data( + req, struct wb_trans_state); + struct tevent_req *subreq; + + if ((state->wb_ctx->fd != -1) && closed_fd(state->wb_ctx->fd)) { + close(state->wb_ctx->fd); + state->wb_ctx->fd = -1; + } + + if ((state->wb_ctx->fd == -1) + || (state->need_priv && !state->wb_ctx->is_priv)) { + subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx, + state->need_priv); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wb_trans_connect_done, req); + return; + } + + state->wb_req->pid = getpid(); + + subreq = wb_simple_trans_send(state, state->ev, NULL, + state->wb_ctx->fd, state->wb_req); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wb_trans_done, req); +} + +static bool wb_trans_retry(struct tevent_req *req, + struct wb_trans_state *state, + wbcErr wbc_err) +{ + struct tevent_req *subreq; + + if (WBC_ERROR_IS_OK(wbc_err)) { + return false; + } + + if (wbc_err == WBC_ERR_WINBIND_NOT_AVAILABLE) { + /* + * Winbind not around or we can't connect to the pipe. Fail + * immediately. + */ + tevent_req_error(req, wbc_err); + return true; + } + + /* + * The transfer as such failed, retry after one second + */ + + if (state->wb_ctx->fd != -1) { + close(state->wb_ctx->fd); + state->wb_ctx->fd = -1; + } + + subreq = tevent_wakeup_send(state, state->ev, + tevent_timeval_current_ofs(1, 0)); + if (tevent_req_nomem(subreq, req)) { + return true; + } + tevent_req_set_callback(subreq, wb_trans_retry_wait_done, req); + return true; +} + +static void wb_trans_retry_wait_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wb_trans_state *state = tevent_req_data( + req, struct wb_trans_state); + bool ret; + + ret = tevent_wakeup_recv(subreq); + TALLOC_FREE(subreq); + if (!ret) { + tevent_req_error(req, WBC_ERR_UNKNOWN_FAILURE); + return; + } + + subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx, + state->need_priv); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wb_trans_connect_done, req); +} + +static void wb_trans_connect_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wb_trans_state *state = tevent_req_data( + req, struct wb_trans_state); + wbcErr wbc_err; + + wbc_err = wb_open_pipe_recv(subreq); + TALLOC_FREE(subreq); + + if (wb_trans_retry(req, state, wbc_err)) { + return; + } + + subreq = wb_simple_trans_send(state, state->ev, NULL, + state->wb_ctx->fd, state->wb_req); + if (tevent_req_nomem(subreq, req)) { + return; + } + tevent_req_set_callback(subreq, wb_trans_done, req); +} + +static void wb_trans_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct wb_trans_state *state = tevent_req_data( + req, struct wb_trans_state); + int ret, err; + + ret = wb_simple_trans_recv(subreq, state, &state->wb_resp, &err); + TALLOC_FREE(subreq); + if ((ret == -1) + && wb_trans_retry(req, state, map_wbc_err_from_errno(err))) { + return; + } + + tevent_req_done(req); +} + +wbcErr wb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx, + struct winbindd_response **presponse) +{ + struct wb_trans_state *state = tevent_req_data( + req, struct wb_trans_state); + wbcErr wbc_err; + + if (tevent_req_is_wbcerr(req, &wbc_err)) { + return wbc_err; + } + + *presponse = talloc_move(mem_ctx, &state->wb_resp); + return WBC_ERR_SUCCESS; +} + +/******************************************************************** + * Debug wrapper functions, modeled (with lot's of code copied as is) + * after the tevent debug wrapper functions + ********************************************************************/ + +/* + this allows the user to choose their own debug function +*/ +int wbcSetDebug(struct wb_context *wb_ctx, + void (*debug)(void *context, + enum wbcDebugLevel level, + const char *fmt, + va_list ap) PRINTF_ATTRIBUTE(3,0), + void *context) +{ + wb_ctx->debug_ops.debug = debug; + wb_ctx->debug_ops.context = context; + return 0; +} + +/* + debug function for wbcSetDebugStderr +*/ +static void wbcDebugStderr(void *private_data, + enum wbcDebugLevel level, + const char *fmt, + va_list ap) PRINTF_ATTRIBUTE(3,0); +static void wbcDebugStderr(void *private_data, + enum wbcDebugLevel level, + const char *fmt, va_list ap) +{ + if (level <= WBC_DEBUG_WARNING) { + vfprintf(stderr, fmt, ap); + } +} + +/* + convenience function to setup debug messages on stderr + messages of level WBC_DEBUG_WARNING and higher are printed +*/ +int wbcSetDebugStderr(struct wb_context *wb_ctx) +{ + return wbcSetDebug(wb_ctx, wbcDebugStderr, wb_ctx); +} + +/* + * log a message + * + * The default debug action is to ignore debugging messages. + * This is the most appropriate action for a library. + * Applications using the library must decide where to + * redirect debugging messages +*/ +void wbcDebug(struct wb_context *wb_ctx, enum wbcDebugLevel level, + const char *fmt, ...) +{ + va_list ap; + if (!wb_ctx) { + return; + } + if (wb_ctx->debug_ops.debug == NULL) { + return; + } + va_start(ap, fmt); + wb_ctx->debug_ops.debug(wb_ctx->debug_ops.context, level, fmt, ap); + va_end(ap); +} diff --git a/source3/torture/wbc_async.h b/source3/torture/wbc_async.h new file mode 100644 index 0000000..9cd6a93 --- /dev/null +++ b/source3/torture/wbc_async.h @@ -0,0 +1,171 @@ +/* + Unix SMB/CIFS implementation. + Headers for the async winbind client library + Copyright (C) Volker Lendecke 2008 + + ** NOTE! The following LGPL license applies to the wbclient + ** library. This does NOT imply that all of Samba is released + ** under the LGPL + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 3 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + +#ifndef _WBC_ASYNC_H_ +#define _WBC_ASYNC_H_ + +#include +#include +#include "nsswitch/libwbclient/wbclient.h" +#include "nsswitch/wb_reqtrans.h" + +struct wb_context; +struct winbindd_request; +struct winbindd_response; + +enum wbcDebugLevel { + WBC_DEBUG_FATAL, + WBC_DEBUG_ERROR, + WBC_DEBUG_WARNING, + WBC_DEBUG_TRACE +}; + +struct tevent_req *wb_trans_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, bool need_priv, + struct winbindd_request *wb_req); +wbcErr wb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx, + struct winbindd_response **presponse); +struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx, const char* dir); +int wbcSetDebug(struct wb_context *wb_ctx, + void (*debug)(void *context, + enum wbcDebugLevel level, + const char *fmt, + va_list ap) PRINTF_ATTRIBUTE(3,0), + void *context); +int wbcSetDebugStderr(struct wb_context *wb_ctx); +void wbcDebug(struct wb_context *wb_ctx, enum wbcDebugLevel level, + const char *fmt, ...) PRINTF_ATTRIBUTE(3,0); + +/* Definitions from wb_reqtrans.c */ +wbcErr map_wbc_err_from_errno(int error); + +bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err); +wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req); + +/* Async functions from wbc_idmap.c */ + +struct tevent_req *wbcSidToUid_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + const struct wbcDomainSid *sid); +wbcErr wbcSidToUid_recv(struct tevent_req *req, uid_t *puid); + +struct tevent_req *wbcUidToSid_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + uid_t uid); +wbcErr wbcUidToSid_recv(struct tevent_req *req, struct wbcDomainSid *psid); + +struct tevent_req *wbcSidToGid_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + const struct wbcDomainSid *sid); +wbcErr wbcSidToGid_recv(struct tevent_req *req, gid_t *pgid); + +struct tevent_req *wbcGidToSid_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + gid_t gid); +wbcErr wbcGidToSid_recv(struct tevent_req *req, struct wbcDomainSid *psid); + +/* Async functions from wbc_pam.c */ +struct tevent_req *wbcAuthenticateUserEx_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + const struct wbcAuthUserParams *params); +wbcErr wbcAuthenticateUserEx_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + struct wbcAuthUserInfo **info, + struct wbcAuthErrorInfo **error); + +/* Async functions from wbc_sid.c */ +struct tevent_req *wbcLookupName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + const char *domain, + const char *name); +wbcErr wbcLookupName_recv(struct tevent_req *req, + struct wbcDomainSid *sid, + enum wbcSidType *name_type); +struct tevent_req *wbcLookupSid_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + const struct wbcDomainSid *sid); +wbcErr wbcLookupSid_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + char **pdomain, + char **pname, + enum wbcSidType *pname_type); + +/* Async functions from wbc_util.c */ + +struct tevent_req *wbcPing_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx); +wbcErr wbcPing_recv(struct tevent_req *req); + +struct tevent_req *wbcInterfaceVersion_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx); +wbcErr wbcInterfaceVersion_recv(struct tevent_req *req, + uint32_t *interface_version); + +struct tevent_req *wbcInfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx); +wbcErr wbcInfo_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + char *winbind_separator, + char **version_string); + +struct tevent_req *wbcNetbiosName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx); +wbcErr wbcNetbiosName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + char **netbios_name); + +struct tevent_req *wbcDomainName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx); +wbcErr wbcDomainName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + char **netbios_name); + +struct tevent_req *wbcInterfaceDetails_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx); +wbcErr wbcInterfaceDetails_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + struct wbcInterfaceDetails **details); + +struct tevent_req *wbcDomainInfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct wb_context *wb_ctx, + const char *domain); +wbcErr wbcDomainInfo_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + struct wbcDomainInfo **dinfo); + +#endif /*_WBC_ASYNC_H_*/ diff --git a/source3/torture/wscript_build b/source3/torture/wscript_build new file mode 100644 index 0000000..1d25200 --- /dev/null +++ b/source3/torture/wscript_build @@ -0,0 +1,135 @@ +#!/usr/bin/env python + +bld.SAMBA3_BINARY('locktest2', + source='locktest2.c', + deps=''' + talloc + smbconf + libsmb + LOCKING + ''', + for_selftest=True) + +TORTURE3_ADDITIONAL_SOURCE="" + +if bld.env.with_ctdb: + TORTURE3_ADDITIONAL_SOURCE += ' test_ctdbd_conn.c' + +bld.SAMBA3_BINARY('smbtorture' + bld.env.suffix3, + source=''' + torture.c + nbio.c + scanner.c + utable.c + denytest.c + mangle_test.c + nbench.c + test_async_echo.c + test_addrchange.c + test_matching.c + test_posix_append.c + test_posix.c + test_nttrans_create.c + test_nttrans_fsctl.c + test_case_insensitive.c + test_notify_online.c + test_chain3.c + test_smb2.c + test_smb1_dfs.c + test_authinfo_structs.c + test_smbsock_any_connect.c + test_cleanup.c + test_notify.c + ../lib/tevent_barrier.c + test_dbwrap_watch.c + test_dbwrap_do_locked.c + test_idmap_tdb_common.c + test_dbwrap_ctdb.c + test_buffersize.c + test_messaging_read.c + test_messaging_fd_passing.c + test_messaging_send_all.c + test_oplock_cancel.c + test_pthreadpool_tevent.c + bench_pthreadpool.c + wbc_async.c + test_g_lock.c + test_namemap_cache.c + test_idmap_cache.c + test_hidenewfiles.c + test_readdir_timestamp.c + test_rpc_scale.c + test_tdb_validate.c + ''' + TORTURE3_ADDITIONAL_SOURCE, + deps=''' + talloc + smbconf + libsmb + msrpc3 + TLDAP + RPC_NDR_ECHO + WB_REQTRANS + LOCKING + NDR_OPEN_FILES + idmap + IDMAP_TDB_COMMON + libcli_lsa3 + samba-cluster-support + util_sd + TDB_VALIDATE + ''', + cflags='-DWINBINDD_SOCKET_DIR=\"%s\"' % bld.env.WINBINDD_SOCKET_DIR, + for_selftest=True) + +bld.SAMBA3_BINARY('msgtest', + source='msgtest.c', + deps=''' + talloc + smbconf + ''', + install=False) + +bld.SAMBA3_BINARY('msg_sink', + source='msg_sink.c', + deps=''' + talloc + smbconf + ''', + install=False) + +bld.SAMBA3_BINARY('msg_source', + source='msg_source.c', + deps=''' + talloc + smbconf + ''', + install=False) + +bld.SAMBA3_BINARY('pdbtest', + source='pdbtest.c', + deps=''' + talloc + pdb + CMDLINE_S3 + AUTH_COMMON + auth + ''', + for_selftest=True) + +if bld.CONFIG_SET('WITH_SMB1SERVER'): + SMB1_SOURCES = 'vfstest_chain.c' +else: + SMB1_SOURCES = '' + +bld.SAMBA3_BINARY('vfstest', + source=''' + cmd_vfs.c + vfstest.c + ''' + SMB1_SOURCES, + deps=''' + vfs + CMDLINE_S3 + smbconf + SMBREADLINE + ''', + for_selftest=True) -- cgit v1.2.3