Changeset 988 for vendor/current/source3/torture

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source3/torture

Files:

• bench_pthreadpool.c (added)
• cmd_vfs.c (modified) (41 diffs)
• denytest.c (modified) (8 diffs)
• locktest.c (deleted)
• locktest2.c (modified) (5 diffs)
• mangle_test.c (modified) (3 diffs)
• masktest.c (modified) (13 diffs)
• msg_sink.c (added)
• msg_source.c (added)
• msgtest.c (modified) (7 diffs)
• nbench.c (modified) (4 diffs)
• nbio.c (modified) (11 diffs)
• pdbtest.c (modified) (22 diffs)
• proto.h (modified) (3 diffs)
• rpc_open_tcp.c (modified) (1 diff)
• scanner.c (modified) (17 diffs)
• smbiconv.c (deleted)
• t_asn1.c (deleted)
• t_push_ucs2.c (deleted)
• t_strappend.c (modified) (3 diffs)
• t_strcmp.c (deleted)
• t_stringoverflow.c (deleted)
• t_strstr.c (deleted)
• test_addrchange.c (modified) (2 diffs)
• test_async_echo.c (modified) (5 diffs)
• test_authinfo_structs.c (added)
• test_buffersize.c (added)
• test_case_insensitive.c (modified) (1 diff)
• test_chain3.c (added)
• test_cleanup.c (added)
• test_dbwrap_ctdb.c (added)
• test_dbwrap_watch.c (added)
• test_idmap_tdb_common.c (added)
• test_messaging_fd_passing.c (added)
• test_messaging_read.c (added)
• test_notify.c (added)
• test_notify_online.c (added)
• test_ntlm_auth.py (modified) (1 diff)
• test_nttrans_create.c (added)
• test_nttrans_fsctl.c (added)
• test_oplock_cancel.c (added)
• test_posix_append.c (modified) (2 diffs)
• test_smb2.c (added)
• torture.c (modified) (352 diffs)
• utable.c (modified) (8 diffs)
• vfstest.c (modified) (21 diffs)
• vfstest.h (modified) (5 diffs)
• vfstest_chain.c (added)
• wbc_async.c (modified) (3 diffs)

vendor/current/source3/torture/cmd_vfs.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    VFS module functions
@@ -10 +10 @@
    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 <http://www.gnu.org/licenses/>.
@@ -26 +26 @@
 #include "vfstest.h"
 #include "../lib/util/util_pw.h"
+#include "libcli/security/security.h"
+#include "passdb/machine_sid.h"
 
 static const char *null_string = "";
@@ -32 +34 @@
 {
         int i;
-        
+
         if (argc < 2) {
                 printf("Usage: load <modules>\n");
@@ -58 +60 @@
         c = argv[1][0];
         size = atoi(argv[2]);
-        vfs->data = TALLOC_ARRAY(mem_ctx, char, size);
+        vfs->data = talloc_array(mem_ctx, char, size);
         if (vfs->data == NULL) {
                 printf("populate: error=-1 (not enough memory)");
@@ -92 +94 @@
                 return NT_STATUS_UNSUCCESSFUL;
         }
-        dump_data(0, (uint8 *)(vfs->data) + offset, len);
+        dump_data(0, (uint8_t *)(vfs->data) + offset, len);
         return NT_STATUS_OK;
 }
@@ -98 +100 @@
 static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
-        SMB_VFS_CONNECT(vfs->conn, lp_servicename(SNUM(vfs->conn)), "vfstest");
+        SMB_VFS_CONNECT(vfs->conn, lp_servicename(talloc_tos(), SNUM(vfs->conn)), "vfstest");
         return NT_STATUS_OK;
 }
@@ -116 +118 @@
         }
 
-        diskfree = SMB_VFS_DISK_FREE(vfs->conn, argv[1], False, &bsize, &dfree, &dsize);
+        diskfree = SMB_VFS_DISK_FREE(vfs->conn, argv[1], &bsize, &dfree, &dsize);
         printf("disk_free: %lu, bsize = %lu, dfree = %lu, dsize = %lu\n",
                         (unsigned long)diskfree,
@@ -147 +149 @@
 {
         SMB_STRUCT_STAT st;
-        SMB_STRUCT_DIRENT *dent = NULL;
+        struct dirent *dent = NULL;
 
         if (vfs->currentdir == NULL) {
@@ -208 +210 @@
                 return NT_STATUS_UNSUCCESSFUL;
         }
-        
+
         printf("mkdir: ok\n");
         return NT_STATUS_OK;
@@ -217 +219 @@
 {
         int ret;
-        
+
         if (vfs->currentdir == NULL) {
                 printf("closedir: failure (no directory open)\n");
@@ -243 +245 @@
         struct smb_filename *smb_fname = NULL;
         NTSTATUS status;
+        int ret;
 
         mode = 00400;
@@ -318 +321 @@
         }
 
-        fsp = SMB_MALLOC_P(struct files_struct);
+        fsp = talloc_zero(vfs, struct files_struct);
         if (fsp == NULL) {
                 return NT_STATUS_NO_MEMORY;
         }
-        fsp->fh = SMB_MALLOC_P(struct fd_handle);
+        fsp->fh = talloc_zero(fsp, struct fd_handle);
         if (fsp->fh == NULL) {
-                SAFE_FREE(fsp->fsp_name);
-                SAFE_FREE(fsp);
+                TALLOC_FREE(fsp);
                 return NT_STATUS_NO_MEMORY;
         }
         fsp->conn = vfs->conn;
 
-        status = create_synthetic_smb_fname_split(mem_ctx, argv[1], NULL,
-                                                  &smb_fname);
-        if (!NT_STATUS_IS_OK(status)) {
-                SAFE_FREE(fsp);
-                return status;
+        smb_fname = synthetic_smb_fname_split(NULL, argv[1], NULL);
+        if (smb_fname == NULL) {
+                TALLOC_FREE(fsp);
+                return NT_STATUS_NO_MEMORY;
         }
 
@@ -342 +343 @@
         if (fsp->fh->fd == -1) {
                 printf("open: error=%d (%s)\n", errno, strerror(errno));
-                SAFE_FREE(fsp->fh);
-                SAFE_FREE(fsp);
+                TALLOC_FREE(fsp);
                 TALLOC_FREE(smb_fname);
                 return NT_STATUS_UNSUCCESSFUL;
         }
+
+        status = NT_STATUS_OK;
+        ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
+        if (ret == -1) {
+                /* 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),
+                         strerror(errno) ));
+                status = map_nt_error_from_unix(errno);
+        } 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)) {
+                SMB_VFS_CLOSE(fsp);
+                TALLOC_FREE(fsp);
+                TALLOC_FREE(smb_fname);
+                return status;
+        }
+
+        fsp->file_id = vfs_file_id_from_sbuf(vfs->conn, &smb_fname->st);
+        fsp->vuid = UID_FIELD_INVALID;
+        fsp->file_pid = 0;
+        fsp->can_lock = True;
+        fsp->can_read = True;
+        fsp->can_write =
+                CAN_WRITE(vfs->conn);
+        fsp->print_file = NULL;
+        fsp->modified = False;
+        fsp->sent_oplock_break = NO_BREAK_SENT;
+        fsp->is_directory = False;
 
         vfs->files[fsp->fh->fd] = fsp;
@@ -366 +399 @@
                 ret = SMB_VFS_RMDIR(vfs->conn, argv[1]);
         } else if (strcmp("unlink", argv[0]) == 0 ) {
-                struct smb_filename *smb_fname = NULL;
-                NTSTATUS status;
-
-                status = create_synthetic_smb_fname_split(mem_ctx, argv[1],
-                                                          NULL, &smb_fname);
-                if (!NT_STATUS_IS_OK(status)) {
-                        return status;
+                struct smb_filename *smb_fname;
+
+                smb_fname = synthetic_smb_fname_split(mem_ctx, argv[1], NULL);
+                if (smb_fname == NULL) {
+                        return NT_STATUS_NO_MEMORY;
                 }
 
@@ -415 +446 @@
                 printf("close: ok\n");
 
-        TALLOC_FREE(vfs->files[fd]->fsp_name);
-        SAFE_FREE(vfs->files[fd]->fh);
-        SAFE_FREE(vfs->files[fd]);
+        TALLOC_FREE(vfs->files[fd]);
         vfs->files[fd] = NULL;
         return NT_STATUS_OK;
@@ -436 +465 @@
         fd = atoi(argv[1]);
         size = atoi(argv[2]);
-        vfs->data = TALLOC_ARRAY(mem_ctx, char, size);
+        vfs->data = talloc_array(mem_ctx, char, size);
         if (vfs->data == NULL) {
                 printf("read: error=-1 (not enough memory)");
@@ -442 +471 @@
         }
         vfs->data_size = size;
-        
+
         rsize = SMB_VFS_READ(vfs->files[fd], vfs->data, size);
         if (rsize == -1) {
@@ -491 +520 @@
 {
         int fd, offset, whence;
-        SMB_OFF_T pos;
+        off_t pos;
 
         if (argc != 4) {
@@ -508 +537 @@
 
         pos = SMB_VFS_LSEEK(vfs->files[fd], offset, whence);
-        if (pos == (SMB_OFF_T)-1) {
+        if (pos == (off_t)-1) {
                 printf("lseek: error=%d (%s)\n", errno, strerror(errno));
                 return NT_STATUS_UNSUCCESSFUL;
@@ -523 +552 @@
         struct smb_filename *smb_fname_src = NULL;
         struct smb_filename *smb_fname_dst = NULL;
-        NTSTATUS status;
 
         if (argc != 3) {
@@ -530 +558 @@
         }
 
-        status = create_synthetic_smb_fname_split(mem_ctx, argv[1], NULL,
-                                                  &smb_fname_src);
-        if (!NT_STATUS_IS_OK(status)) {
-                return status;
-        }
-
-        status = create_synthetic_smb_fname_split(mem_ctx, argv[2], NULL,
-                                                  &smb_fname_dst);
-        if (!NT_STATUS_IS_OK(status)) {
+        smb_fname_src = synthetic_smb_fname_split(mem_ctx, argv[1], NULL);
+        if (smb_fname_src == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        smb_fname_dst = synthetic_smb_fname_split(mem_ctx, argv[2], NULL);
+        if (smb_fname_dst == NULL) {
                 TALLOC_FREE(smb_fname_src);
-                return status;
+                return NT_STATUS_NO_MEMORY;
         }
 
@@ -586 +612 @@
         SMB_STRUCT_STAT st;
         time_t tmp_time;
-        NTSTATUS status;
 
         if (argc != 2) {
@@ -593 +618 @@
         }
 
-        status = create_synthetic_smb_fname_split(mem_ctx, argv[1], NULL,
-                                                  &smb_fname);
-        if (!NT_STATUS_IS_OK(status)) {
-                return status;
+        smb_fname = synthetic_smb_fname_split(mem_ctx, argv[1], NULL);
+        if (smb_fname == NULL) {
+                return NT_STATUS_NO_MEMORY;
         }
 
@@ -608 +632 @@
         TALLOC_FREE(smb_fname);
 
-        pwd = sys_getpwuid(st.st_ex_uid);
+        pwd = getpwuid(st.st_ex_uid);
         if (pwd != NULL) user = pwd->pw_name;
         else user = null_string;
-        grp = sys_getgrgid(st.st_ex_gid);
+        grp = getgrgid(st.st_ex_gid);
         if (grp != NULL) group = grp->gr_name;
         else group = null_string;
@@ -679 +703 @@
         }
 
-        pwd = sys_getpwuid(st.st_ex_uid);
+        pwd = getpwuid(st.st_ex_uid);
         if (pwd != NULL) user = pwd->pw_name;
         else user = null_string;
-        grp = sys_getgrgid(st.st_ex_gid);
+        grp = getgrgid(st.st_ex_gid);
         if (grp != NULL) group = grp->gr_name;
         else group = null_string;
@@ -727 +751 @@
         SMB_STRUCT_STAT st;
         time_t tmp_time;
-        NTSTATUS status;
 
         if (argc != 2) {
@@ -734 +757 @@
         }
 
-        status = create_synthetic_smb_fname_split(mem_ctx, argv[1], NULL,
-                                                  &smb_fname);
-        if (!NT_STATUS_IS_OK(status)) {
-                return status;
+        smb_fname = synthetic_smb_fname_split(mem_ctx, argv[1], NULL);
+        if (smb_fname == NULL) {
+                return NT_STATUS_NO_MEMORY;
         }
 
@@ -748 +770 @@
         TALLOC_FREE(smb_fname);
 
-        pwd = sys_getpwuid(st.st_ex_uid);
+        pwd = getpwuid(st.st_ex_uid);
         if (pwd != NULL) user = pwd->pw_name;
         else user = null_string;
-        grp = sys_getgrgid(st.st_ex_gid);
+        grp = getgrgid(st.st_ex_gid);
         if (grp != NULL) group = grp->gr_name;
         else group = null_string;
@@ -782 +804 @@
         tmp_time = convert_timespec_to_time_t(st.st_ex_ctime);
         printf("  Change: %s", ctime(&tmp_time));
-        
+
         return NT_STATUS_OK;
 }
@@ -832 +854 @@
 
         printf("fchmod: ok\n");
+        return NT_STATUS_OK;
+}
+
+
+static NTSTATUS cmd_chmod_acl(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
+{
+        mode_t mode;
+        if (argc != 3) {
+                printf("Usage: chmod_acl <path> <mode>\n");
+                return NT_STATUS_OK;
+        }
+
+        mode = atoi(argv[2]);
+        if (SMB_VFS_CHMOD_ACL(vfs->conn, argv[1], mode) == -1) {
+                printf("chmod_acl: error=%d (%s)\n", errno, strerror(errno));
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
+        printf("chmod_acl: ok\n");
+        return NT_STATUS_OK;
+}
+
+
+static NTSTATUS cmd_fchmod_acl(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
+{
+        int fd;
+        mode_t mode;
+        if (argc != 3) {
+                printf("Usage: fchmod_acl <fd> <mode>\n");
+                return NT_STATUS_OK;
+        }
+
+        fd = atoi(argv[1]);
+        mode = atoi(argv[2]);
+        if (fd < 0 || fd >= 1024) {
+                printf("fchmod_acl: error=%d (file descriptor out of range)\n", EBADF);
+                return NT_STATUS_OK;
+        }
+        if (vfs->files[fd] == NULL) {
+                printf("fchmod_acl: error=%d (invalid file descriptor)\n", EBADF);
+                return NT_STATUS_OK;
+        }
+
+        if (SMB_VFS_FCHMOD_ACL(vfs->files[fd], mode) == -1) {
+                printf("fchmod_acl: error=%d (%s)\n", errno, strerror(errno));
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
+        printf("fchmod_acl: ok\n");
         return NT_STATUS_OK;
 }
@@ -890 +961 @@
 static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
-        char buf[PATH_MAX];
-        if (SMB_VFS_GETWD(vfs->conn, buf) == NULL) {
+        char *buf = SMB_VFS_GETWD(vfs->conn);
+        if (buf == NULL) {
                 printf("getwd: error=%d (%s)\n", errno, strerror(errno));
                 return NT_STATUS_UNSUCCESSFUL;
@@ -897 +968 @@
 
         printf("getwd: %s\n", buf);
+        SAFE_FREE(buf);
         return NT_STATUS_OK;
 }
@@ -904 +976 @@
         struct smb_file_time ft;
         struct smb_filename *smb_fname = NULL;
-        NTSTATUS status;
 
         if (argc != 4) {
@@ -916 +987 @@
         ft.mtime = convert_time_t_to_timespec(atoi(argv[3]));
 
-        status = create_synthetic_smb_fname_split(mem_ctx, argv[1],
-                                                  NULL, &smb_fname);
-        if (!NT_STATUS_IS_OK(status)) {
-                return status;
+        smb_fname = synthetic_smb_fname_split(mem_ctx, argv[1], NULL);
+        if (smb_fname == NULL) {
+                return NT_STATUS_NO_MEMORY;
         }
 
@@ -936 +1006 @@
 {
         int fd;
-        SMB_OFF_T off;
+        off_t off;
         if (argc != 3) {
                 printf("Usage: ftruncate <fd> <length>\n");
@@ -970 +1040 @@
         int type;
         const char *typestr;
-        
+
         if (argc != 6) {
                 printf("Usage: lock <fd> <op> <offset> <count> <type>\n");
@@ -1103 +1173 @@
         unsigned int dev_val;
         SMB_DEV_T dev;
-        
+
         if (argc != 4) {
                 printf("Usage: mknod <path> <mode> <dev>\n");
@@ -1146 +1216 @@
         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;
+
+        if (argc != 3) {
+                printf("Usage: getxattr <path> <xattr>\n");
+                return NT_STATUS_OK;
+        }
+
+        buf = NULL;
+
+        ret = SMB_VFS_GETXATTR(vfs->conn, argv[1], 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_GETXATTR(vfs->conn, argv[1], 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;
+
+        if (argc != 2) {
+                printf("Usage: listxattr <path>\n");
+                return NT_STATUS_OK;
+        }
+
+        buf = NULL;
+
+        ret = SMB_VFS_LISTXATTR(vfs->conn, argv[1], 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_LISTXATTR(vfs->conn, argv[1], 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_setxattr(struct vfs_state *vfs, TALLOC_CTX *mem_ctx,
+                             int argc, const char **argv)
+{
+        ssize_t ret;
+        int flags = 0;
+
+        if ((argc < 4) || (argc > 5)) {
+                printf("Usage: setxattr <path> <xattr> <value> [flags]\n");
+                return NT_STATUS_OK;
+        }
+
+        if (argc == 5) {
+                flags = atoi(argv[4]);
+        }
+
+        ret = SMB_VFS_SETXATTR(vfs->conn, argv[1], argv[2],
+                               argv[3], strlen(argv[3]), flags);
+        if (ret == -1) {
+                int err = errno;
+                printf("setxattr 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;
+
+        if (argc != 3) {
+                printf("Usage: removexattr <path> <xattr>\n");
+                return NT_STATUS_OK;
+        }
+
+        ret = SMB_VFS_REMOVEXATTR(vfs->conn, argv[1], 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 <fd>\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(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;
+
+        if (argc != 2) {
+                printf("Usage: get_nt_acl <path>\n");
+                return NT_STATUS_OK;
+        }
+
+        status = SMB_VFS_GET_NT_ACL(vfs->conn, argv[1],
+                                    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));
+                return status;
+        }
+        printf("%s\n", sddl_encode(talloc_tos(), sd, get_global_sam_sid()));
+        TALLOC_FREE(sd);
+        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 <fd> <sddl>\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(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)
+{
+        int flags;
+        int ret;
+        mode_t mode;
+        files_struct *fsp;
+        struct smb_filename *smb_fname = NULL;
+        NTSTATUS status;
+        struct security_descriptor *sd = NULL;
+
+        if (argc != 3) {
+                printf("Usage: set_nt_acl <file> <sddl>\n");
+                return NT_STATUS_OK;
+        }
+
+        mode = 00400;
+
+        fsp = talloc_zero(vfs, struct files_struct);
+        if (fsp == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        fsp->fh = talloc_zero(fsp, struct fd_handle);
+        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], NULL);
+        if (smb_fname == NULL) {
+                TALLOC_FREE(fsp);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        fsp->fsp_name = smb_fname;
+
+#ifdef O_DIRECTORY
+        flags = O_RDONLY|O_DIRECTORY;
+#else
+        /* POSIX allows us to open a directory with O_RDONLY. */
+        flags = O_RDONLY;
+#endif
+
+        fsp->fh->fd = SMB_VFS_OPEN(vfs->conn, smb_fname, fsp, O_RDWR, mode);
+        if (fsp->fh->fd == -1 && errno == EISDIR) {
+                fsp->fh->fd = SMB_VFS_OPEN(vfs->conn, smb_fname, fsp, flags, mode);
+        }
+        if (fsp->fh->fd == -1) {
+                printf("open: error=%d (%s)\n", errno, strerror(errno));
+                TALLOC_FREE(fsp);
+                TALLOC_FREE(smb_fname);
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
+        status = NT_STATUS_OK;
+        ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
+        if (ret == -1) {
+                /* 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),
+                         strerror(errno) ));
+                status = map_nt_error_from_unix(errno);
+        }
+        
+        if (!NT_STATUS_IS_OK(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->can_lock = True;
+        fsp->can_read = True;
+        fsp->can_write = True;
+        fsp->print_file = NULL;
+        fsp->modified = False;
+        fsp->sent_oplock_break = NO_BREAK_SENT;
+        fsp->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(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);
+
+        ret = SMB_VFS_CLOSE(fsp);
+        if (ret == -1 )
+                printf("close: error=%d (%s)\n", errno, strerror(errno));
+
+        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 <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], 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;
+        if (argc != 3) {
+                printf("Usage: sys_acl_get_file <path> <type>\n");
+                return NT_STATUS_OK;
+        }
+
+        type = atoi(argv[2]);
+        acl = SMB_VFS_SYS_ACL_GET_FILE(vfs->conn, argv[1], type, talloc_tos());
+        if (!acl) {
+                printf("sys_acl_get_file 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_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;
+
+        if (argc != 2) {
+                printf("Usage: sys_acl_get_file <path>\n");
+                return NT_STATUS_OK;
+        }
+
+        ret = SMB_VFS_SYS_ACL_BLOB_GET_FILE(vfs->conn, argv[1], talloc_tos(),
+                                            &description, &blob);
+        if (ret != 0) {
+                printf("sys_acl_blob_get_file 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_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 <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;
+
+        if (argc != 2) {
+                printf("Usage: sys_acl_delete_def_file <path>\n");
+                return NT_STATUS_OK;
+        }
+
+        ret = SMB_VFS_SYS_ACL_DELETE_DEF_FILE(vfs->conn, argv[1]);
+        if (ret == -1) {
+                printf("sys_acl_delete_def_file failed (%s)\n", strerror(errno));
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+        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)
+{
+        int ret;
+        struct dirent *dent = NULL;
+        SMB_STRUCT_STAT st;
+        bool found = false;
+        char *translated = NULL;
+        NTSTATUS status;
+
+        if (argc != 2) {
+                DEBUG(0, ("Usage: translate_name unix_filename\n"));
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
+        vfs->currentdir = SMB_VFS_OPENDIR(vfs->conn, ".", NULL, 0);
+        if (vfs->currentdir == NULL) {
+                DEBUG(0, ("cmd_translate_name: opendir error=%d (%s)\n",
+                          errno, strerror(errno)));
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
+        while (true) {
+                dent = SMB_VFS_READDIR(vfs->conn, vfs->currentdir, &st);
+                if (dent == NULL) {
+                        break;
+                }
+                if (strcmp (dent->d_name, argv[1]) == 0) {
+                        found = true;
+                        break;
+                }
+        };
+
+        if (!found) {
+                DEBUG(0, ("cmd_translate_name: file '%s' not found.\n", 
+                          argv[1]));
+                status = NT_STATUS_UNSUCCESSFUL;
+                goto cleanup;
+        }
+        status = SMB_VFS_TRANSLATE_NAME(vfs->conn, dent->d_name,
+                                        vfs_translate_to_windows,
+                                        talloc_tos(), &translated);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED)) {
+                DEBUG(0, ("cmd_translate_name: file '%s' cannot be "
+                          "translated\n", argv[1]));
+                TALLOC_FREE(translated);
+                goto cleanup;
+        }
+        /* translation success. But that could also mean
+           that translating "aaa" to "aaa" was successful :-(
+        */ 
+        DEBUG(0, ("cmd_translate_name: file '%s' --> '%s'\n", 
+                  argv[1], translated));
+
+        TALLOC_FREE(translated);
+
+cleanup:
+        ret = SMB_VFS_CLOSEDIR(vfs->conn, vfs->currentdir);
+        if (ret == -1) {
+                DEBUG(0, ("cmd_translate_name: closedir failure: %s\n",
+                          strerror(errno)));
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
+        vfs->currentdir = NULL;
+        return status;;
+}
+
 
 struct cmd_set vfs_commands[] = {
@@ -1162 +1781 @@
         { "rmdir",   cmd_pathfunc,   "VFS rmdir()",    "rmdir <path>" },
         { "closedir",   cmd_closedir,   "VFS closedir()",    "closedir" },
-        { "open",   cmd_open,   "VFS open()",    "open <fname>" },
+        { "open",   cmd_open,   "VFS open()",    "open <fname> <flags> <mode>" },
         { "close",   cmd_close,   "VFS close()",    "close <fd>" },
         { "read",   cmd_read,   "VFS read()",    "read <fd> <size>" },
@@ -1187 +1806 @@
         { "mknod",   cmd_mknod,   "VFS mknod()",    "mknod <path> <mode> <dev>" },
         { "realpath",   cmd_realpath,   "VFS realpath()",    "realpath <path>" },
+        { "getxattr", cmd_getxattr, "VFS getxattr()",
+          "getxattr <path> <name>" },
+        { "listxattr", cmd_listxattr, "VFS listxattr()",
+          "listxattr <path>" },
+        { "setxattr", cmd_setxattr, "VFS setxattr()",
+          "setxattr <path> <name> <value> [<flags>]" },
+        { "removexattr", cmd_removexattr, "VFS removexattr()",
+          "removexattr <path> <name>\n" },
+        { "fget_nt_acl", cmd_fget_nt_acl, "VFS fget_nt_acl()", 
+          "fget_nt_acl <fd>\n" },
+        { "get_nt_acl", cmd_get_nt_acl, "VFS get_nt_acl()", 
+          "get_nt_acl <path>\n" },
+        { "fset_nt_acl", cmd_fset_nt_acl, "VFS fset_nt_acl()", 
+          "fset_nt_acl <fd>\n" },
+        { "set_nt_acl", cmd_set_nt_acl, "VFS open() and fset_nt_acl()", 
+          "set_nt_acl <file>\n" },
+        { "fchmod_acl",   cmd_fchmod_acl,   "VFS fchmod_acl()",    "fchmod_acl <fd> <mode>" },
+        { "chmod_acl",   cmd_chmod_acl,   "VFS chmod_acl()",    "chmod_acl <path> <mode>" },
+        { "sys_acl_get_file", cmd_sys_acl_get_file, "VFS sys_acl_get_file()", "sys_acl_get_file <path>" },
+        { "sys_acl_get_fd", cmd_sys_acl_get_fd, "VFS sys_acl_get_fd()", "sys_acl_get_fd <fd>" },
+        { "sys_acl_blob_get_file", cmd_sys_acl_blob_get_file,
+          "VFS sys_acl_blob_get_file()", "sys_acl_blob_get_file <path>" },
+        { "sys_acl_blob_get_fd", cmd_sys_acl_blob_get_fd,
+          "VFS sys_acl_blob_get_fd()", "sys_acl_blob_get_fd <path>" },
+        { "sys_acl_delete_def_file", cmd_sys_acl_delete_def_file, "VFS sys_acl_delete_def_file()", "sys_acl_delete_def_file <path>" },
+
+
+        { "test_chain", cmd_test_chain, "test chain code",
+          "test_chain" },
+        { "translate_name", cmd_translate_name, "VFS translate_name()", "translate_name unix_filename" },
         { NULL }
 };

vendor/current/source3/torture/denytest.c

@@ -1413 +1413 @@
         int i;
         bool correct = True;
-        NTSTATUS ret1, ret2;
+        NTSTATUS ret1, ret2, status;
         const char *fnames[2] = {"\\denytest1.dat", "\\denytest1.exe"};
+        size_t nread;
 
         if (!torture_open_connection(&cli1, 0)) {
@@ -1424 +1425 @@
         for (i=0;i<2;i++) {
                 cli_unlink(cli1, fnames[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-                cli_open(cli1, fnames[i], O_RDWR|O_CREAT, DENY_NONE, &fnum1);
-                cli_writeall(cli1, fnum1, 0, (uint8_t *)fnames[i], 0,
+                cli_openx(cli1, fnames[i], O_RDWR|O_CREAT, DENY_NONE, &fnum1);
+                cli_writeall(cli1, fnum1, 0, (const uint8_t *)fnames[i], 0,
                              strlen(fnames[i]), NULL);
                 cli_close(cli1, fnum1);
@@ -1438 +1439 @@
                 progress_bar(i, ARRAY_SIZE(denytable1));
 
-                ret1 = cli_open(cli1, fname, 
+                ret1 = cli_openx(cli1, fname, 
                                  denytable1[i].mode1,
                                  denytable1[i].deny1, &fnum1);
-                ret2 = cli_open(cli1, fname, 
+                ret2 = cli_openx(cli1, fname, 
                                  denytable1[i].mode2,
                                  denytable1[i].deny2, &fnum2);
@@ -1452 +1453 @@
                         char x = 1;
                         res = A_0;
-                        if (cli_read(cli1, fnum2, (char *)&x, 0, 1) == 1) {
+
+                        status = cli_read(cli1, fnum2, (char *)&x, 0, 1,
+                                          &nread);
+                        if (NT_STATUS_IS_OK(status) && nread == 1) {
                                 res += A_R;
                         }
@@ -1507 +1511 @@
         int i;
         bool correct = True;
-        NTSTATUS ret1, ret2;
+        NTSTATUS ret1, ret2, status;
         const char *fnames[2] = {"\\denytest2.dat", "\\denytest2.exe"};
+        size_t nread;
 
         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
@@ -1518 +1523 @@
         for (i=0;i<2;i++) {
                 cli_unlink(cli1, fnames[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-                cli_open(cli1, fnames[i], O_RDWR|O_CREAT, DENY_NONE, &fnum1);
-                cli_writeall(cli1, fnum1, 0, (uint8_t *)fnames[i], 0,
+                cli_openx(cli1, fnames[i], O_RDWR|O_CREAT, DENY_NONE, &fnum1);
+                cli_writeall(cli1, fnum1, 0, (const uint8_t *)fnames[i], 0,
                              strlen(fnames[i]), NULL);
                 cli_close(cli1, fnum1);
@@ -1530 +1535 @@
                 progress_bar(i, ARRAY_SIZE(denytable2));
 
-                ret1 = cli_open(cli1, fname, 
+                ret1 = cli_openx(cli1, fname, 
                                  denytable2[i].mode1,
                                  denytable2[i].deny1, &fnum1);
-                ret2 = cli_open(cli2, fname, 
+                ret2 = cli_openx(cli2, fname, 
                                  denytable2[i].mode2,
                                  denytable2[i].deny2, &fnum2);
@@ -1544 +1549 @@
                         char x = 1;
                         res = A_0;
-                        if (cli_read(cli2, fnum2, (char *)&x, 0, 1) == 1) {
-                                res += A_R;
-                        }
+
+                        status = cli_read(cli2, fnum2, (char *)&x, 0, 1,
+                                          &nread);
+                        if (NT_STATUS_IS_OK(status) && nread == 1) {
+                                res += A_R;
+                        }
                         if (NT_STATUS_IS_OK(cli_writeall(cli2, fnum2, 0,
                                                          (uint8_t *)&x, 0, 1,

vendor/current/source3/torture/locktest2.c

@@ -74 +74 @@
                 {
                         uint16_t fd;
-                        if (!NT_STATUS_IS_OK(cli_open(c, fname, flags, DENY_NONE, &fd))) {
+                        if (!NT_STATUS_IS_OK(cli_openx(c, fname, flags, DENY_NONE, &fd))) {
                                 return -1;
                         }
@@ -115 +115 @@
         switch (fstype) {
         case FSTYPE_SMB:
-                return cli_lock(c, fd, start, len, LOCK_TIMEOUT, op);
+                return NT_STATUS_IS_OK(cli_lock32(c, fd, start, len,
+                                       LOCK_TIMEOUT, op));
 
         case FSTYPE_NFS:
@@ -184 +185 @@
         
         if (!got_pass) {
-                char *pass = getpass("Password: ");
-                if (pass) {
-                        fstrcpy(password, pass);
+                char pwd[256] = {0};
+                int rc;
+
+                rc = samba_getpass("Password: ", pwd, sizeof(pwd), false, false);
+                if (rc == 0) {
+                        fstrcpy(password, pwd);
                 }
         }
@@ -194 +198 @@
         nt_status = cli_full_connection(&c, myname, server_n, NULL, 0, share, "?????", 
                                         username, lp_workgroup(), password, 0,
-                                        Undefined);
+                                        SMB_SIGNING_DEFAULT);
 
         if (!NT_STATUS_IS_OK(nt_status)) {
@@ -513 +517 @@
         argv += 4;
 
-        lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
+        lp_load_global(get_dyn_CONFIGFILE());
         load_interfaces();
 

vendor/current/source3/torture/mangle_test.c

@@ -43 +43 @@
         total++;
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, name, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
-                printf("open of %s failed (%s)\n", name, cli_errstr(cli));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum))) {
-                printf("close of %s failed (%s)\n", name, cli_errstr(cli));
+        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;
         }
@@ -56 +58 @@
         status = cli_qpathinfo_alt_name(cli, name, shortname);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("query altname of %s failed (%s)\n", name, cli_errstr(cli));
+                printf("query altname of %s failed (%s)\n", name, nt_errstr(status));
                 return False;
         }
 
         fstr_sprintf(name2, "\\mangle_test\\%s", shortname);
-        if (!NT_STATUS_IS_OK(cli_unlink(cli, name2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
+        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, cli_errstr(cli));
+                       name2, name, nt_errstr(status));
                 return False;
         }
 
         /* recreate by short name */
-        if (!NT_STATUS_IS_OK(cli_open(cli, name2, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
-                printf("open2 of %s failed (%s)\n", name2, cli_errstr(cli));
-                return False;
-        }
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum))) {
-                printf("close of %s failed (%s)\n", name, cli_errstr(cli));
+        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 */
-        if (!NT_STATUS_IS_OK(cli_unlink(cli, name, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
+        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, cli_errstr(cli));
+                       name, name2, nt_errstr(status));
                 failures++;
                 cli_unlink(cli, name2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
@@ -101 +108 @@
                 TDB_DATA namedata;
                 /* store it for later */
-                namedata.dptr = CONST_DISCARD(uint8 *, name);
+                namedata.dptr = discard_const_p(uint8_t, name);
                 namedata.dsize = strlen(name)+1;
                 tdb_store_bystring(tdb, shortname, namedata, TDB_REPLACE);

vendor/current/source3/torture/masktest.c

@@ -3 +3 @@
    mask_match tester
    Copyright (C) Andrew Tridgell 1999
-   
+
    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 <http://www.gnu.org/licenses/>.
@@ -23 +23 @@
 #include "libsmb/libsmb.h"
 #include "libsmb/nmblib.h"
+#include "../libcli/smb/smbXcli_base.h"
 
 static fstring password;
 static fstring username;
 static int got_pass;
-static int max_protocol = PROTOCOL_NT1;
+static int max_protocol = -1;
 static bool showall = False;
 static bool old_list = False;
@@ -145 +146 @@
         if (strcmp(file,"..") == 0) file = ".";
 
-        return ms_fnmatch(pattern, file, cli->protocol, False) == 0;
+        return ms_fnmatch(pattern, file, smbXcli_conn_protocol(cli->conn), False) == 0;
 }
 
@@ -168 +169 @@
 {
         struct cli_state *c;
-        struct nmb_name called, calling;
         char *server_n;
         char *server;
-        struct sockaddr_storage ss;
         NTSTATUS status;
 
@@ -182 +181 @@
         server_n = server;
 
-        zero_sockaddr(&ss);
-
-        make_nmb_name(&calling, "masktest", 0x0);
-        make_nmb_name(&called , server, 0x20);
-
- again:
-        zero_sockaddr(&ss);
-
-        /* have to open a new connection */
-        if (!(c=cli_initialise())) {
-                DEBUG(0,("Connection to %s failed\n", server_n));
+        status = cli_connect_nb(server, NULL, 0, 0x20, "masktest",
+                                SMB_SIGNING_DEFAULT, 0, &c);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,("Connection to %s failed. Error %s\n", server_n,
+                         nt_errstr(status)));
                 return NULL;
         }
 
-        status = cli_connect(c, server_n, &ss);
-        if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0,("Connection to %s failed. Error %s\n", server_n, nt_errstr(status) ));
-                return NULL;
-        }
-
-        c->protocol = max_protocol;
-
-        if (!cli_session_request(c, &calling, &called)) {
-                DEBUG(0,("session request to %s failed\n", called.name));
-                cli_shutdown(c);
-                if (strcmp(called.name, "*SMBSERVER")) {
-                        make_nmb_name(&called , "*SMBSERVER", 0x20);
-                        goto again;
-                }
-                return NULL;
-        }
-
-        DEBUG(4,(" session request ok\n"));
-
-        status = cli_negprot(c);
+        status = smbXcli_negprot(c->conn, c->timeout, PROTOCOL_CORE,
+                                 max_protocol);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0, ("protocol negotiation failed: %s\n",
@@ -225 +199 @@
 
         if (!got_pass) {
-                char *pass = getpass("Password: ");
-                if (pass) {
+                char pwd[256] = {0};
+                int rc;
+
+                rc = samba_getpass("Password: ", pwd, sizeof(pwd), false, false);
+                if (rc == 0) {
                         fstrcpy(password, pass);
                 }
@@ -254 +231 @@
         DEBUG(4,(" session setup ok\n"));
 
-        status = cli_tcon_andx(c, share, "?????", password,
-                               strlen(password)+1);
+        status = cli_tree_connect(c, share, "?????", password,
+                                  strlen(password)+1);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("tree connect failed: %s\n", nt_errstr(status)));
@@ -294 +271 @@
         }
 
-        fstrcpy(state->short_name, f->short_name);
-        strlower_m(state->short_name);
+
+        fstrcpy(state->short_name, f->short_name ? f->short_name : "");
+        (void)strlower_m(state->short_name);
         *state->pp_long_name = SMB_STRDUP(f->name);
         if (!*state->pp_long_name) {
                 return NT_STATUS_NO_MEMORY;
         }
-        strlower_m(*state->pp_long_name);
+        (void)strlower_m(*state->pp_long_name);
         return NT_STATUS_OK;
 }
@@ -348 +326 @@
         fstrcpy(res1, "---");
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, file, O_CREAT|O_TRUNC|O_RDWR, 0, &fnum))) {
+        if (!NT_STATUS_IS_OK(cli_openx(cli, file, O_CREAT|O_TRUNC|O_RDWR, 0, &fnum))) {
                 DEBUG(0,("Can't create %s\n", file));
                 return;
@@ -413 +391 @@
                 l1 = 1 + random() % 20;
                 l2 = 1 + random() % 20;
-                mask = TALLOC_ARRAY(ctx, char, strlen("\\masktest\\")+1+22);
-                file = TALLOC_ARRAY(ctx, char, strlen("\\masktest\\")+1+22);
+                mask = talloc_array(ctx, char, strlen("\\masktest\\")+1+22);
+                file = talloc_array(ctx, char, strlen("\\masktest\\")+1+22);
                 if (!mask || !file) {
                         goto finished;
@@ -505 +483 @@
         argv += 1;
 
-        load_case_tables();
-        lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
+        smb_init_locale();
+        lp_load_global(get_dyn_CONFIGFILE());
         load_interfaces();
 
@@ -533 +511 @@
                         break;
                 case 'M':
-                        max_protocol = interpret_protocol(optarg, max_protocol);
+                        lp_set_cmdline("client max protocol", optarg);
                         break;
                 case 'U':
@@ -571 +549 @@
         argv += optind;
 
+        max_protocol = lp_client_max_protocol();
 
         cli = connect_one(share);

vendor/current/source3/torture/msgtest.c

@@ -47 +47 @@
         char buf[12];
         int ret;
+        TALLOC_CTX *frame = talloc_stackframe();
 
-        load_case_tables();
+        smb_init_locale();
 
         setup_logging(argv[0], DEBUG_STDOUT);
 
-        lp_load(get_dyn_CONFIGFILE(),False,False,False,True);
+        lp_load_global(get_dyn_CONFIGFILE());
 
-        if (!(evt_ctx = tevent_context_init(NULL)) ||
-            !(msg_ctx = messaging_init(NULL, procid_self(), evt_ctx))) {
+        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);
         }
@@ -63 +65 @@
                 fprintf(stderr, "%s: Usage - %s pid count\n", argv[0],
                         argv[0]);
+                TALLOC_FREE(frame);
                 exit(1);
         }
@@ -83 +86 @@
         }
 
-        /* Now test that the duplicate filtering code works. */
+        /* Ensure all messages get through to ourselves. */
         pong_count = 0;
 
-        safe_strcpy(buf, "1234567890", sizeof(buf)-1);
+        strlcpy(buf, "1234567890", sizeof(buf));
 
         for (i=0;i<n;i++) {
@@ -92 +95 @@
                                &data_blob_null);
                 messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
-                                   MSG_PING,(uint8 *)buf, 11);
+                                   MSG_PING,(uint8_t *)buf, 11);
         }
 
-        for (i=0;i<n;i++) {
+        /*
+         * We have to loop at least 2 times for
+         * each message as local ping messages are
+         * handled by an immediate callback, that
+         * has to be dispatched, which sends a pong
+         * message, which also has to be dispatched.
+         * Above we sent 2*n messages, which means
+         * we have to dispatch 4*n times.
+         */
+
+        while (pong_count < n*2) {
                 ret = tevent_loop_once(evt_ctx);
                 if (ret != 0) {
@@ -102 +115 @@
         }
 
-        if (pong_count != 2) {
-                fprintf(stderr, "Duplicate filter failed (%d).\n", pong_count);
+        if (pong_count != 2*n) {
+                fprintf(stderr, "Message count failed (%d).\n", pong_count);
         }
 
@@ -120 +133 @@
                                                    msg_ctx, pid_to_procid(pid),
                                                    MSG_PING,
-                                                   (uint8 *)buf, 11)))
+                                                   (uint8_t *)buf, 11)))
                            ping_count++;
                         if(NT_STATUS_IS_OK(messaging_send(
@@ -153 +166 @@
         }
 
+        TALLOC_FREE(frame);
         return (0);
 }

vendor/current/source3/torture/nbench.c

@@ -97 +97 @@
         char *status;
 
-        result = TALLOC_P(mem_ctx, struct nbench_cmd_struct);
+        result = talloc(mem_ctx, struct nbench_cmd_struct);
         if (result == NULL) {
                 return NULL;
@@ -299 +299 @@
                 subreq = cli_qpathinfo_send(state, ev, nb_state->cli, fname,
                                             ival(state->cmd->params[2]),
-                                            0, nb_state->cli->max_xmit);
+                                            0, CLI_BUFFER_SIZE);
                 break;
         }
@@ -339 +339 @@
         case NBENCH_CMD_NTCREATEX: {
                 struct ftable *ft;
-                status = cli_ntcreate_recv(subreq, &state->ft->fnum);
+                status = cli_ntcreate_recv(subreq, &state->ft->fnum, NULL);
                 TALLOC_FREE(subreq);
                 if (status_wrong(req, state->cmd->status, status)) {
@@ -466 +466 @@
                 return false;
         }
-        ev = tevent_context_init(talloc_tos());
+        ev = samba_tevent_context_init(talloc_tos());
         if (ev == NULL) {
                 goto fail;

vendor/current/source3/torture/nbio.c

@@ -77 +77 @@
 {
         nprocs = n;
-        children = (struct children *)shm_setup(sizeof(*children) * nprocs);
+        children = (struct children *)anonymous_shared_allocate(sizeof(*children) * nprocs);
         if (!children) {
                 printf("Failed to setup shared memory!\n");
@@ -136 +136 @@
 void nb_unlink(const char *fname)
 {
-        if (!NT_STATUS_IS_OK(cli_unlink(c, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
+        NTSTATUS status;
+
+        status = cli_unlink(c, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
+        if (!NT_STATUS_IS_OK(status)) {
 #if NBDEBUG
                 printf("(%d) unlink %s failed (%s)\n", 
-                       line_count, fname, cli_errstr(c));
+                       line_count, fname, nt_errstr(status));
 #endif
         }
@@ -151 +154 @@
         int i;
         NTSTATUS status;
-        uint32 desired_access;
+        uint32_t desired_access;
 
         if (create_options & FILE_DIRECTORY_FILE) {
@@ -164 +167 @@
                                 FILE_SHARE_READ|FILE_SHARE_WRITE, 
                                 create_disposition, 
-                                create_options, 0, &fd);
+                                create_options, 0, &fd, NULL);
         if (!NT_STATUS_IS_OK(status) && handle != -1) {
                 printf("ERROR: cli_ntcreate failed for %s - %s\n",
-                       fname, cli_errstr(c));
+                       fname, nt_errstr(status));
                 exit(1);
         }
@@ -210 +213 @@
 void nb_readx(int handle, int offset, int size, int ret_size)
 {
-        int i, ret;
+        int i;
+        NTSTATUS status;
+        size_t nread;
 
         i = find_handle(handle);
-        if ((ret=cli_read(c, ftable[i].fd, buf, offset, size)) != ret_size) {
-                printf("(%d) ERROR: read failed on handle %d ofs=%d size=%d res=%d fd %d errno %d (%s)\n",
-                        line_count, handle, offset, size, ret, ftable[i].fd, errno, strerror(errno));
+        status = cli_read(c, ftable[i].fd, buf, offset, size, &nread);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("(%d) ERROR: read failed on handle %d ofs=%d size=%d "
+                       "fd %d nterror %s\n",
+                       line_count, handle, offset, size,
+                       ftable[i].fd, nt_errstr(status));
+                exit(1);
+        } else if (nread != ret_size) {
+                printf("(%d) ERROR: read failed on handle %d ofs=%d size=%d "
+                       "nread=%lu ret_size=%d fd %d\n",
+                       line_count, handle, offset, size, (unsigned long)nread,
+                       ret_size, ftable[i].fd);
                 exit(1);
         }
@@ -234 +248 @@
 void nb_rmdir(const char *fname)
 {
-        if (!NT_STATUS_IS_OK(cli_rmdir(c, fname))) {
+        NTSTATUS status;
+
+        status = cli_rmdir(c, fname);
+        if (!NT_STATUS_IS_OK(status)) {
                 printf("ERROR: rmdir %s failed (%s)\n", 
-                       fname, cli_errstr(c));
+                       fname, nt_errstr(status));
                 exit(1);
         }
@@ -243 +260 @@
 void nb_rename(const char *oldname, const char *newname)
 {
-        if (!NT_STATUS_IS_OK(cli_rename(c, oldname, newname))) {
+        NTSTATUS status;
+
+        status = cli_rename(c, oldname, newname);
+        if (!NT_STATUS_IS_OK(status)) {
                 printf("ERROR: rename %s %s failed (%s)\n", 
-                       oldname, newname, cli_errstr(c));
+                       oldname, newname, nt_errstr(status));
                 exit(1);
         }
@@ -266 +286 @@
 void nb_qfsinfo(int level)
 {
-        int bsize, total, avail;
+        uint64_t bsize, total, avail;
         /* this is not the right call - we need cli_qfsinfo() */
-        cli_dskattr(c, &bsize, &total, &avail);
+        cli_disk_size(c, "", &bsize, &total, &avail);
 }
 
@@ -287 +307 @@
         int i;
         i = find_handle(fnum);
-        /* hmmm, we don't have cli_flush() yet */
+
+        cli_flush(NULL, c, i);
 }
 
@@ -304 +325 @@
         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;
@@ -311 +333 @@
                 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);
-                        free(s2);
                         return status;
                 }

vendor/current/source3/torture/pdbtest.c

@@ -2 +2 @@
    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
@@ -10 +11 @@
    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 <http://www.gnu.org/licenses/>.
@@ -25 +26 @@
 #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"
+
+#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 s1_len, s2_len;
+        uint32_t s1_len, s2_len;
         const char *s1_buf, *s2_buf;
-        const uint8 *d1_buf, *d2_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);
@@ -104 +118 @@
         } else if (d1_buf == NULL) {
                 /* Do nothing */
-        } else if (s1_len != s1_len) {
+        } else if (s1_len != s2_len) {
                 DEBUG(0, ("Password history not written correctly, lengths differ, want %d, got %d\n",
                                         s1_len, s2_len));
@@ -121 +135 @@
         /* Check logoff time */
         if (pdb_get_logoff_time(s1) != pdb_get_logoff_time(s2)) {
-                DEBUG(0, ("Logoff time is not written correctly\n"));
-                ret = False;
-        }
-        
+                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_logoff_time(s2)) {
-                DEBUG(0, ("Kickoff time is not written correctly\n"));
-                ret = False;
-        }
-        
+        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)) {
@@ -136 +154 @@
                 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\n"));
-                ret = False;
-        }
-        
+                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\n"));
-                ret = False;
-        }
-        
+                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)) {
@@ -154 +176 @@
                 ret = False;
         }
-        
+
         /* Check logon divs */
         if (pdb_get_logon_divs(s1) != pdb_get_logon_divs(s2)) {
@@ -160 +182 @@
                 ret = False;
         }
-        
+
         /* Check logon hours */
         if (pdb_get_hours_len(s1) != pdb_get_hours_len(s2)) {
@@ -178 +200 @@
                 }
         }
-        
+
         /* Check profile path */
         s1_buf = pdb_get_profile_path(s1);
@@ -204 +226 @@
                 ret = False;
         }
-        
+
         /* Check logon script */
         s1_buf = pdb_get_logon_script(s1);
@@ -217 +239 @@
                 ret = False;
         }
-        
-        /* TODO Check user and group sids */
-                
+
+        /* 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;     
 }
 
-
-int main(int argc, char **argv)
+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 *tsocket_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;
+        NTSTATUS status;
+        
+        SMBOWFencrypt(pdb_get_nt_passwd(pdb_entry), challenge_8,
+                      local_nt_response);
+        SMBsesskeygen_ntv1(pdb_get_nt_passwd(pdb_entry), local_nt_session_key);
+
+        if (tsocket_address_inet_from_strings(NULL, "ip", NULL, 0, &tsocket_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(), 
+                                tsocket_address, 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_auth_context_fixed(NULL, &auth_context, challenge.data);
+
+        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 = auth_check_ntlm_password(mem_ctx,
+                                          auth_context,
+                                          user_info,
+                                          &server_info);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("Failed to test authentication with auth module: %s\n", nt_errstr(status)));
+                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)) {
+                DEBUG(0, ("domain_sid in SAM info3 %s does not match domain_sid in AUTH info3 %s\n", 
+                          dom_sid_string(NULL, info3_sam->base.domain_sid),
+                          dom_sid_string(NULL, info3_auth->base.domain_sid)));
+                return False;
+        }
+        
+        /* TODO: 
+         * Compre more details from the two info3 structures,
+         * then test that an expired/disabled/pwdmustchange account
+         * returns the correct errors
+         */
+
+        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;
+
+        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;
+        }
+
+        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 set_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;
+        }
+
+        return true;
+}
+
+
+int main(int argc, const char **argv)
 {
         TALLOC_CTX *ctx;
@@ -234 +444 @@
         bool error = False;
         struct passwd *pwd;
-        uint8 *buf;
-        uint32 expire, min_age, history;
+        uint8_t *buf;
+        uint32_t expire, min_age, history;
         struct pdb_methods *pdb;
         poptContext pc;
@@ -248 +458 @@
         };
 
-        load_case_tables();
-
-        pc = poptGetContext("pdbtest", argc, (const char **) argv,
-                            long_options, 0);
+        ctx = talloc_stackframe();
+
+        smb_init_locale();
+
+        pc = poptGetContext("pdbtest", argc, argv, long_options, 0);
 
         poptSetOtherOptionHelp(pc, "backend[:settings] username");
-        
+
         while(poptGetNextOpt(pc) != -1);
 
@@ -260 +471 @@
 
         /* Load configuration */
-        lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
+        lp_load_global(get_dyn_CONFIGFILE());
         setup_logging("pdbtest", DEBUG_STDOUT);
+        init_names();
 
         if (backend == NULL) {
@@ -272 +484 @@
                 exit(1);
         }
-        
-        ctx = talloc_init("PDBTEST");
-        
+
         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);
 
@@ -291 +501 @@
         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 *)TALLOC(ctx, NT_HASH_LEN);
+                buf = (uint8_t *)TALLOC(ctx, NT_HASH_LEN);
         } else {
-                buf = (uint8 *)TALLOC(ctx, history * PW_HISTORY_ENTRY_LEN);
+                buf = (uint8_t *)TALLOC(ctx, history * PW_HISTORY_ENTRY_LEN);
         }
 
@@ -302 +514 @@
         srand(tv.tv_usec);
         for (i = 0; i < NT_HASH_LEN; i++) {
-                buf[i] = (uint8) rand();
+                buf[i] = (uint8_t) rand();
         }
         pdb_set_nt_passwd(out, buf, PDB_SET);
         for (i = 0; i < LM_HASH_LEN; i++) {
-                buf[i] = (uint8) rand();
+                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) rand();
+                buf[i] = (uint8_t) rand();
         }
         pdb_set_pw_history(out, buf, history, PDB_SET);
@@ -317 +529 @@
         pdb_get_account_policy(PDB_POLICY_MIN_PASSWORD_AGE, &min_age);
         pdb_set_pass_last_set_time(out, time(NULL), PDB_SET);
-        
-        if (expire == 0 || expire == (uint32)-1) {
-                pdb_set_pass_must_change_time(out, get_time_t_max(), PDB_SET);
-        } else {
-                pdb_set_pass_must_change_time(out, time(NULL)+expire, PDB_SET);
-        }
-
-        if (min_age == (uint32)-1) {
+
+        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))) {
@@ -341 +553 @@
                 exit(1);
         }
-        
+
         /* Get account information through getsampwnam() */
-        if (NT_STATUS_IS_ERR(pdb->getsampwnam(pdb, in, out->username))) {
-                fprintf(stderr, "Error getting sampw of added user %s.\n",
-                                out->username);
+        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", 
@@ -351 +564 @@
                 }
                 TALLOC_FREE(ctx);
-        }
-        
+                exit(1);
+        }
+
         /* Verify integrity */
         if (samu_correct(out, in)) {
@@ -360 +574 @@
                 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))) {
@@ -367 +589 @@
         }
 
+        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);
 

vendor/current/source3/torture/proto.h

@@ -64 +64 @@
 /* The following definitions come from torture/torture.c  */
 
-void *shm_setup(int size);
 bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
                       char **hostname, char **sharename);
 bool torture_open_connection(struct cli_state **c, int conn_index);
-bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid);
+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);
@@ -84 +84 @@
 
 bool run_posix_append(int dummy);
+bool run_case_insensitive_create(int dummy);
 
 bool run_nbench2(int dummy);
@@ -89 +90 @@
 bool run_smb_any_connect(int dummy);
 bool run_addrchange(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_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_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_cleanup3(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_idmap_tdb_common_test(int dummy);
+bool run_local_dbwrap_ctdb(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_oplock_cancel(int dummy);
 
 #endif /* __TORTURE_H__ */

vendor/current/source3/torture/rpc_open_tcp.c

@@ -95 +95 @@
         }
 
-        status = rpc_pipe_open_tcp(mem_ctx, argv[2], &((*table)->syntax_id),
+        status = rpc_pipe_open_tcp(mem_ctx, argv[2], NULL,
+                                   *table,
                                    &rpc_pipe);
         if (!NT_STATUS_IS_OK(status)) {

vendor/current/source3/torture/scanner.c

@@ -22 +22 @@
 #include "torture/proto.h"
 #include "libsmb/libsmb.h"
+#include "../libcli/smb/smbXcli_base.h"
 
 #define VERBOSE 0
@@ -68 +69 @@
                            NULL, 0, 0, /* setup */
                            param, param_len, 2,
-                           data, data_len, cli->max_xmit,
+                           data, data_len, CLI_BUFFER_SIZE,
                            NULL,                /* recv_flags2 */
                            NULL, 0, NULL,       /* rsetup */
@@ -122 +123 @@
         uint32_t param_len = 0;
         uint32_t rparam_len, rdata_len;
-        uint8_t param[PARAM_SIZE], data[DATA_SIZE];
+        uint8_t *param = NULL;
+        uint8_t data[DATA_SIZE];
+        const char *newfname;
+        const char *dname;
         NTSTATUS status;
 
@@ -129 +133 @@
 
         /* try with a info level only */
-        param_len = 2;
-        SSVAL(param, 0, level);
+        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);
@@ -136 +145 @@
 
         /* try with a file descriptor */
-        param_len = 6;
+        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);
@@ -146 +160 @@
 
         /* try with a notify style */
-        param_len = 6;
+        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);
@@ -155 +174 @@
 
         /* try with a file name */
-        param_len = 6;
+        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_len += clistr_push(cli, &param[6], fname, -1, STR_TERMINATE);
-
+        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);
@@ -166 +191 @@
 
         /* try with a new file name */
-        param_len = 6;
+        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_len += clistr_push(cli, &param[6], "\\newfile.dat", -1, STR_TERMINATE);
-
+        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, "\\newfile.dat", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-        cli_rmdir(cli, "\\newfile.dat");
+        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  */
-        cli_mkdir(cli, "\\testdir");
-        param_len = 2;
-        SSVAL(param, 0, level);
-        param_len += clistr_push(cli, &param[2], "\\testdir", -1, STR_TERMINATE);
-
+        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, "\\testdir");
+        cli_rmdir(cli, dname);
         if (NT_STATUS_IS_OK(status)) return True;
 
@@ -206 +245 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR | O_CREAT | O_TRUNC, 
+        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_open(cli, "\\", O_RDONLY, DENY_NONE, &dnum))) {
+        if (!NT_STATUS_IS_OK(cli_openx(cli, "\\", O_RDONLY, DENY_NONE, &dnum))) {
                 printf("open of \\ failed\n");
                 return false;
@@ -276 +315 @@
                            NULL, 0, 0, /* setup */
                            param, param_len, 2,
-                           data, data_len, cli->max_xmit,
+                           data, data_len, CLI_BUFFER_SIZE,
                            NULL,                /* recv_flags2 */
                            NULL, 0, NULL,       /* rsetup */
@@ -329 +368 @@
         uint32_t param_len = 0;
         uint32_t rparam_len, rdata_len;
-        uint8_t param[PARAM_SIZE], data[DATA_SIZE];
+        uint8_t *param = NULL;
+        uint8_t data[DATA_SIZE];
         NTSTATUS status;
+        const char *newfname;
+        const char *dname;
 
         memset(data, 0, sizeof(data));
@@ -336 +378 @@
 
         /* try with a info level only */
-        param_len = 2;
-        SSVAL(param, 0, level);
+        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);
@@ -343 +390 @@
 
         /* try with a file descriptor */
-        param_len = 6;
+        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);
@@ -353 +405 @@
 
         /* try with a notify style */
-        param_len = 6;
+        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);
@@ -362 +419 @@
 
         /* try with a file name */
-        param_len = 6;
+        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_len += clistr_push(cli, &param[6], fname, -1, STR_TERMINATE);
-
+        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);
@@ -373 +436 @@
 
         /* try with a new file name */
-        param_len = 6;
+        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_len += clistr_push(cli, &param[6], "\\newfile.dat", -1, STR_TERMINATE);
-
+        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, "\\newfile.dat", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-        cli_rmdir(cli, "\\newfile.dat");
+        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  */
-        cli_mkdir(cli, "\\testdir");
-        param_len = 2;
-        SSVAL(param, 0, level);
-        param_len += clistr_push(cli, &param[2], "\\testdir", -1, STR_TERMINATE);
-
+        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, "\\testdir");
+        cli_rmdir(cli, dname);
         if (NT_STATUS_IS_OK(status)) return True;
 
@@ -413 +490 @@
         }
 
-        cli_open(cli, fname, O_RDWR | O_CREAT | O_TRUNC, 
+        cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, 
                          DENY_NONE, &fnum);
-        cli_open(cli, "\\", O_RDONLY, DENY_NONE, &dnum);
+        cli_openx(cli, "\\", O_RDONLY, DENY_NONE, &dnum);
 
         for (op=OP_MIN; op<=OP_MAX; op++) {

vendor/current/source3/torture/t_strappend.c

@@ -6 +6 @@
 
 #include "includes.h"
-#include <assert.h>
+#include "torture/proto.h"
 
-int main(int argc, char *argv[])
+bool run_local_sprintf_append(int dummy)
 {
         TALLOC_CTX *mem_ctx;
         char *string = NULL;
-        int len = 0;
-        int bufsize = 4;
+        ssize_t len = 0;
+        size_t bufsize = 4;
         int i;
 
@@ -19 +19 @@
         if (mem_ctx == NULL) {
                 fprintf(stderr, "talloc_init failed\n");
-                return 1;
+                return false;
         }
 
@@ -31 +31 @@
 
 
-        for (i=0; i<(100000); i++) {
+        for (i=0; i<(10000); i++) {
                 if (i%1000 == 0) {
-                        printf("%d %d\r", i, bufsize);
+                        printf("%d %lld\r", i, (long long int)bufsize);
                         fflush(stdout);
                 }
                 sprintf_append(mem_ctx, &string, &len, &bufsize, "%d\n", i);
-                assert(strlen(string) == len);
+                if (strlen(string) != len) {
+                        fprintf(stderr, "sprintf_append failed: strlen(string) %lld != len %lld\n",
+                                (long long int)strlen(string), (long long int)len);
+                        return false;
+                }
         }
 
         talloc_destroy(mem_ctx);
 
-        return 0;
+        return true;
 }

vendor/current/source3/torture/test_addrchange.c

@@ -20 +20 @@
 #include "includes.h"
 #include "lib/addrchange.h"
+#include "lib/util/tevent_ntstatus.h"
 #include "proto.h"
 
@@ -31 +32 @@
         int i;
 
-        ev = tevent_context_init(talloc_tos());
+        ev = samba_tevent_context_init(talloc_tos());
         if (ev == NULL) {
                 d_fprintf(stderr, "tevent_context_init failed\n");

vendor/current/source3/torture/test_async_echo.c

@@ -47 +47 @@
 }
 
-static void cli_close_done(struct tevent_req *req)
+static void write_andx_done(struct tevent_req *req)
 {
         int *done = (int *)tevent_req_callback_data_void(req);
@@ -55 +55 @@
         status = cli_write_andx_recv(req, &written);
         TALLOC_FREE(req);
-        printf("close returned %s\n", nt_errstr(status));
+        printf("cli_write_andx returned %s\n", nt_errstr(status));
         *done -= 1;
 }
@@ -69 +69 @@
         bool ret = false;
         int i, num_reqs;
-        uint8_t buf[32768];
+        uint8_t buf[65536];
 
         printf("Starting ASYNC_ECHO\n");
 
-        ev = tevent_context_init(talloc_tos());
+        ev = samba_tevent_context_init(talloc_tos());
         if (ev == NULL) {
                 printf("tevent_context_init failed\n");
@@ -83 +83 @@
                 goto fail;
         }
-        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_rpcecho.syntax_id,
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_rpcecho,
                                           &p);
         if (!NT_STATUS_IS_OK(status)) {
@@ -112 +112 @@
 
         for (i=0; i<10; i++) {
-                req = cli_write_andx_send(ev, ev, cli, 4711, 0, buf, 0, sizeof(buf));
+                req = cli_write_andx_send(ev, ev, cli, 4711, 0, buf, 0,
+                                          sizeof(buf));
                 if (req == NULL) {
-                        printf("cli_close_send failed\n");
+                        printf("cli_write_andx_send failed\n");
                         goto fail;
                 }
-                tevent_req_set_callback(req, cli_close_done, &num_reqs);
+                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));
+                req = cli_echo_send(ev, ev, cli, 1,
+                                    data_blob_const("hello", 5));
                 if (req == NULL) {
                         printf("cli_echo_send failed\n");

vendor/current/source3/torture/test_case_insensitive.c

@@ -50 +50 @@
                 goto rmdir;
         }
-        status = cli_open(cli, "x\\y", O_RDWR|O_CREAT, 0, &fnum);
+        status = cli_openx(cli, "x\\y", O_RDWR|O_CREAT, 0, &fnum);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("cli_open failed: %s\n", nt_errstr(status));
+                printf("cli_openx failed: %s\n", nt_errstr(status));
 
                 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {

vendor/current/source3/torture/test_ntlm_auth.py

@@ -28 +28 @@
 
 class ReadChildError(Exception):
-        pass
+    pass
 
 class WriteChildError(Exception):
-        pass
+    pass
 
 def readLine(pipe):
-        """readLine(pipe) -> str
-        Read a line from the child's pipe, returns the string read.
-        Throws ReadChildError if the read fails.
-        """
-        buf = os.read(pipe, 2047)
-        newline = buf.find('\n')
-        if newline == -1:
-                raise ReadChildError()
-        return buf[:newline]
+    """readLine(pipe) -> str
+    Read a line from the child's pipe, returns the string read.
+    Throws ReadChildError if the read fails.
+    """
+    buf = os.read(pipe, 2047)
+    newline = buf.find('\n')
+    if newline == -1:
+        raise ReadChildError()
+    return buf[:newline]
 
 def writeLine(pipe, buf):
-        """writeLine(pipe, buf) -> nul
-        Write a line to the child's pipe.
-        Raises WriteChildError if the write fails.
-        """
-        written = os.write(pipe, buf)
-        if written != len(buf):
-                raise WriteChildError()
-        os.write(pipe, "\n")
+    """writeLine(pipe, buf) -> nul
+    Write a line to the child's pipe.
+    Raises WriteChildError if the write fails.
+    """
+    written = os.write(pipe, buf)
+    if written != len(buf):
+        raise WriteChildError()
+    os.write(pipe, "\n")
 
 def parseCommandLine():
-        """parseCommandLine() -> (opts, ntlm_auth_path)
-        Parse the command line.
-        Return a tuple consisting of the options and the path to ntlm_auth.
-        """
-        usage = "usage: %prog [options] path/to/ntlm_auth"
-        parser = OptionParser(usage)
-
-        parser.set_defaults(client_username="foo")
-        parser.set_defaults(client_password="secret")
-        parser.set_defaults(client_domain="FOO")
-        parser.set_defaults(client_helper="ntlmssp-client-1")
-
-        parser.set_defaults(server_username="foo")
-        parser.set_defaults(server_password="secret")
-        parser.set_defaults(server_domain="FOO")
-        parser.set_defaults(server_helper="squid-2.5-ntlmssp")
-        parser.set_defaults(config_file="/etc/samba/smb.conf")
-
-        parser.add_option("--client-username", dest="client_username",\
-                                help="User name for the client. [default: foo]")
-        parser.add_option("--client-password", dest="client_password",\
-                                help="Password the client will send. [default: secret]")
-        parser.add_option("--client-domain", dest="client_domain",\
-                                help="Domain the client authenticates for. [default: FOO]")
-        parser.add_option("--client-helper", dest="client_helper",\
-                                help="Helper mode for the ntlm_auth client. [default: ntlmssp-client-1]")
-
-        parser.add_option("--server-username", dest="server_username",\
-                                help="User name server uses for local auth. [default: foo]")
-        parser.add_option("--server-password", dest="server_password",\
-                                help="Password server uses for local auth. [default: secret]")
-        parser.add_option("--server-domain", dest="server_domain",\
-                                help="Domain server uses for local auth. [default: FOO]")
-        parser.add_option("--server-helper", dest="server_helper",\
-                                help="Helper mode for the ntlm_auth server. [default: squid-2.5-server]")
-
-        parser.add_option("-s", "--configfile", dest="config_file",\
-                                help="Path to smb.conf file. [default:/etc/samba/smb.conf")
-
-        (opts, args) = parser.parse_args()
-        if len(args) != 1:
-                parser.error("Invalid number of arguments.")
-
-        if not os.access(args[0], os.X_OK):
-                parser.error("%s is not executable." % args[0])
-
-        return (opts, args[0])
+    """parseCommandLine() -> (opts, ntlm_auth_path)
+    Parse the command line.
+    Return a tuple consisting of the options and the path to ntlm_auth.
+    """
+    usage = "usage: %prog [options] path/to/ntlm_auth"
+    parser = OptionParser(usage)
+
+    parser.set_defaults(client_username="foo")
+    parser.set_defaults(client_password="secret")
+    parser.set_defaults(client_domain="FOO")
+    parser.set_defaults(client_helper="ntlmssp-client-1")
+
+    parser.set_defaults(server_username="foo")
+    parser.set_defaults(server_password="secret")
+    parser.set_defaults(server_domain="FOO")
+    parser.set_defaults(server_helper="squid-2.5-ntlmssp")
+    parser.set_defaults(config_file="/etc/samba/smb.conf")
+
+    parser.add_option("--client-username", dest="client_username",\
+                help="User name for the client. [default: foo]")
+    parser.add_option("--client-password", dest="client_password",\
+                help="Password the client will send. [default: secret]")
+    parser.add_option("--client-domain", dest="client_domain",\
+                help="Domain the client authenticates for. [default: FOO]")
+    parser.add_option("--client-helper", dest="client_helper",\
+                help="Helper mode for the ntlm_auth client. [default: ntlmssp-client-1]")
+    parser.add_option("--client-use-cached-creds", dest="client_use_cached_creds",\
+                help="Use winbindd credentials cache (rather than default username/pw)", action="store_true")
+
+    parser.add_option("--target-hostname", dest="target_hostname",\
+                help="Target hostname for kerberos")
+    parser.add_option("--target-service", dest="target_service",\
+                help="Target service for kerberos")
+
+
+    parser.add_option("--server-username", dest="server_username",\
+                help="User name server uses for local auth. [default: foo]")
+    parser.add_option("--server-password", dest="server_password",\
+                help="Password server uses for local auth. [default: secret]")
+    parser.add_option("--server-domain", dest="server_domain",\
+                help="Domain server uses for local auth. [default: FOO]")
+    parser.add_option("--server-helper", dest="server_helper",\
+                help="Helper mode for the ntlm_auth server. [default: squid-2.5-server]")
+    parser.add_option("--server-use-winbindd", dest="server_use_winbindd",\
+                help="Use winbindd to check the password (rather than default username/pw)", action="store_true")
+    parser.add_option("--require-membership-of", dest="sid",\
+                help="Require that the user is a member of this group to authenticate.")
+
+
+    parser.add_option("-s", "--configfile", dest="config_file",\
+                help="Path to smb.conf file. [default:/etc/samba/smb.conf")
+
+    (opts, args) = parser.parse_args()
+    if len(args) != 1:
+        parser.error("Invalid number of arguments.")
+
+    if not os.access(args[0], os.X_OK):
+        parser.error("%s is not executable." % args[0])
+
+    return (opts, args[0])
 
 
 def main():
-        """main() -> int
-        Run the test.
-        Returns 0 if test succeeded, <>0 otherwise.
-        """
-        (opts, ntlm_auth_path) = parseCommandLine()
-
-        (client_in_r,  client_in_w)  = os.pipe()
-        (client_out_r, client_out_w) = os.pipe()
-
-        client_pid = os.fork()
-
-        if not client_pid:
-                # We're in the client child
-                os.close(0)
-                os.close(1)
-
-                os.dup2(client_out_r, 0)
-                os.close(client_out_r)
-                os.close(client_out_w)
-
-                os.dup2(client_in_w, 1)
-                os.close(client_in_r)
-                os.close(client_in_w)
-
-                client_args = []
-                client_args.append("--helper-protocol=%s" % opts.client_helper)
-                client_args.append("--username=%s" % opts.client_username)
-                client_args.append("--password=%s" % opts.client_password)
-                client_args.append("--domain=%s" % opts.client_domain)
-                client_args.append("--configfile=%s" % opts.config_file)
-
-                os.execv(ntlm_auth_path, client_args)
-
-        client_in = client_in_r
-        os.close(client_in_w)
-
-        client_out = client_out_w
-        os.close(client_out_r)
-
-        (server_in_r,  server_in_w)  = os.pipe()
-        (server_out_r, server_out_w) = os.pipe()
-
-        server_pid = os.fork()
-
-        if not server_pid:
-                # We're in the server child
-                os.close(0)
-                os.close(1)
-
-                os.dup2(server_out_r, 0)
-                os.close(server_out_r)
-                os.close(server_out_w)
-
-                os.dup2(server_in_w, 1)
-                os.close(server_in_r)
-                os.close(server_in_w)
-
-                server_args = []
-                server_args.append("--helper-protocol=%s" % opts.server_helper)
-                server_args.append("--username=%s" % opts.server_username)
-                server_args.append("--password=%s" % opts.server_password)
-                server_args.append("--domain=%s" % opts.server_domain)
-                server_args.append("--configfile=%s" % opts.config_file)
-
-                os.execv(ntlm_auth_path, server_args)
-
-        server_in = server_in_r
-        os.close(server_in_w)
-
-        server_out = server_out_w
-        os.close(server_out_r)
-
-        # We're in the parent
-        writeLine(client_out, "YR")
-        buf = readLine(client_in)
-
-        if buf.count("YR ", 0, 3) != 1:
-                sys.exit(1)
-
-        writeLine(server_out, buf)
-        buf = readLine(server_in)
-
-        if buf.count("TT ", 0, 3) != 1:
-                sys.exit(2)
-
-        writeLine(client_out, buf)
-        buf = readLine(client_in)
-
-        if buf.count("AF ", 0, 3) != 1:
-                sys.exit(3)
-
-        # Client sends 'AF <base64 blob>' but server expects 'KK <abse64 blob>'
-        buf = buf.replace("AF", "KK", 1)
-
-        writeLine(server_out, buf)
-        buf = readLine(server_in)
-
-        if buf.count("AF ", 0, 3) != 1:
-                sys.exit(4)
-
-        os.close(server_in)
-        os.close(server_out)
-        os.close(client_in)
-        os.close(client_out)
-        os.waitpid(server_pid, 0)
-        os.waitpid(client_pid, 0)
-        sys.exit(0)
+    """main() -> int
+    Run the test.
+    Returns 0 if test succeeded, <>0 otherwise.
+    """
+    (opts, ntlm_auth_path) = parseCommandLine()
+
+    (client_in_r,  client_in_w)  = os.pipe()
+    (client_out_r, client_out_w) = os.pipe()
+
+    client_pid = os.fork()
+
+    if not client_pid:
+        # We're in the client child
+        os.close(0)
+        os.close(1)
+
+        os.dup2(client_out_r, 0)
+        os.close(client_out_r)
+        os.close(client_out_w)
+
+        os.dup2(client_in_w, 1)
+        os.close(client_in_r)
+        os.close(client_in_w)
+
+        client_args = []
+        client_args.append("--helper-protocol=%s" % opts.client_helper)
+        client_args.append("--username=%s" % opts.client_username)
+        if opts.client_use_cached_creds:
+            client_args.append("--use-cached-creds")
+        else:
+            client_args.append("--password=%s" % opts.client_password)
+        client_args.append("--domain=%s" % opts.client_domain)
+        client_args.append("--configfile=%s" % opts.config_file)
+        if opts.target_service:
+            client_args.append("--target-service=%s" % opts.target_service)
+        if opts.target_hostname:
+            client_args.append("--target-hostname=%s" % opts.target_hostname)
+
+        os.execv(ntlm_auth_path, client_args)
+
+    client_in = client_in_r
+    os.close(client_in_w)
+
+    client_out = client_out_w
+    os.close(client_out_r)
+
+    (server_in_r,  server_in_w)  = os.pipe()
+    (server_out_r, server_out_w) = os.pipe()
+
+    server_pid = os.fork()
+
+    if not server_pid:
+        # We're in the server child
+        os.close(0)
+        os.close(1)
+
+        os.dup2(server_out_r, 0)
+        os.close(server_out_r)
+        os.close(server_out_w)
+
+        os.dup2(server_in_w, 1)
+        os.close(server_in_r)
+        os.close(server_in_w)
+
+        server_args = []
+        server_args.append("--helper-protocol=%s" % opts.server_helper)
+        if not opts.server_use_winbindd:
+            server_args.append("--username=%s" % opts.server_username)
+            server_args.append("--password=%s" % opts.server_password)
+            server_args.append("--domain=%s" % opts.server_domain)
+            if opts.sid:
+                raise Exception("Server must be using winbindd for require-membership-of.")
+        else:
+            if opts.sid:
+                server_args.append("--require-membership-of=%s" % opts.sid)
+
+        server_args.append("--configfile=%s" % opts.config_file)
+
+        os.execv(ntlm_auth_path, server_args)
+
+    server_in = server_in_r
+    os.close(server_in_w)
+
+    server_out = server_out_w
+    os.close(server_out_r)
+
+    if opts.client_helper == "ntlmssp-client-1" and opts.server_helper == "squid-2.5-ntlmssp":
+
+        # We're in the parent
+        writeLine(client_out, "YR")
+        buf = readLine(client_in)
+
+        if buf.count("YR ", 0, 3) != 1:
+            sys.exit(1)
+
+        writeLine(server_out, buf)
+        buf = readLine(server_in)
+
+        if buf.count("TT ", 0, 3) != 1:
+            sys.exit(2)
+
+        writeLine(client_out, buf)
+        buf = readLine(client_in)
+
+        if buf.count("AF ", 0, 3) != 1:
+            sys.exit(3)
+
+        # Client sends 'AF <base64 blob>' but server expects 'KK <abse64 blob>'
+        buf = buf.replace("AF", "KK", 1)
+
+        writeLine(server_out, buf)
+        buf = readLine(server_in)
+
+        if buf.count("AF ", 0, 3) != 1:
+            sys.exit(4)
+
+
+    elif opts.client_helper == "ntlmssp-client-1" and opts.server_helper == "gss-spnego":
+        # We're in the parent
+        writeLine(client_out, "YR")
+        buf = readLine(client_in)
+
+        if buf.count("YR ", 0, 3) != 1:
+            sys.exit(1)
+
+        writeLine(server_out, buf)
+        buf = readLine(server_in)
+
+        if buf.count("TT ", 0, 3) != 1:
+            sys.exit(2)
+
+        writeLine(client_out, buf)
+        buf = readLine(client_in)
+
+        if buf.count("AF ", 0, 3) != 1:
+            sys.exit(3)
+
+        # Client sends 'AF <base64 blob>' but server expects 'KK <abse64 blob>'
+        buf = buf.replace("AF", "KK", 1)
+
+        writeLine(server_out, buf)
+        buf = readLine(server_in)
+
+        if buf.count("AF * ", 0, 5) != 1:
+            sys.exit(4)
+
+
+    elif opts.client_helper == "gss-spnego-client" and opts.server_helper == "gss-spnego":
+        # We're in the parent
+        writeLine(server_out, "YR")
+        buf = readLine(server_in)
+
+        while True:
+            if buf.count("AF ", 0, 3) != 1 and buf.count("TT ", 0, 3) != 1:
+                sys.exit(1)
+
+            writeLine(client_out, buf)
+            buf = readLine(client_in)
+
+            if buf.count("AF", 0, 2) == 1:
+                break
+
+            if buf.count("AF ", 0, 5) != 1 and buf.count("KK ", 0, 3) != 1 and buf.count("TT ", 0, 3) != 1:
+                sys.exit(2)
+
+            writeLine(server_out, buf)
+            buf = readLine(server_in)
+
+            if buf.count("AF * ", 0, 5) == 1:
+                break
+
+    else:
+        sys.exit(5)
+
+    if opts.client_helper == "ntlmssp-client-1":
+        writeLine(client_out, "GK")
+        buf = readLine(client_in)
+
+        if buf.count("GK ", 0, 3) != 1:
+            sys.exit(4)
+
+        writeLine(client_out, "GF")
+        buf = readLine(client_in)
+
+        if buf.count("GF ", 0, 3) != 1:
+            sys.exit(4)
+
+    if opts.server_helper == "squid-2.5-ntlmssp":
+        writeLine(server_out, "GK")
+        buf = readLine(server_in)
+
+        if buf.count("GK ", 0, 3) != 1:
+            sys.exit(4)
+
+        writeLine(server_out, "GF")
+        buf = readLine(server_in)
+
+        if buf.count("GF ", 0, 3) != 1:
+            sys.exit(4)
+
+    os.close(server_in)
+    os.close(server_out)
+    os.close(client_in)
+    os.close(client_out)
+    os.waitpid(server_pid, 0)
+    os.waitpid(client_pid, 0)
+    sys.exit(0)
 
 if __name__ == "__main__":
-        main()
-
-
+    main()
+
+

vendor/current/source3/torture/test_posix_append.c

@@ -34 +34 @@
         NTSTATUS status;
         uint16_t fnum;
-        SMB_OFF_T size;
+        off_t size;
         uint8_t c = '\0';
         bool ret = false;
@@ -58 +58 @@
                 FILE_OVERWRITE_IF,
                 FILE_NON_DIRECTORY_FILE|FILE_DELETE_ON_CLOSE,
-                0, &fnum);
+                0, &fnum, NULL);
 
         if (!NT_STATUS_IS_OK(status)) {

vendor/current/source3/torture/torture.c

@@ -27 +27 @@
 #include "tldap_util.h"
 #include "../librpc/gen_ndr/svcctl.h"
-#include "memcache.h"
+#include "../lib/util/memcache.h"
 #include "nsswitch/winbind_client.h"
-#include "dbwrap.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_open.h"
+#include "dbwrap/dbwrap_rbt.h"
 #include "talloc_dict.h"
 #include "async_smb.h"
@@ -38 +40 @@
 #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"
 
 extern char *optarg;
 extern int optind;
 
-static fstring host, workgroup, share, password, username, myname;
-static int max_protocol = PROTOCOL_NT1;
+fstring host, workgroup, share, password, username, myname;
 static const char *sockops="TCP_NODELAY";
-static int nprocs=1;
+int torture_nprocs=1;
 static int port_to_use=0;
 int torture_numops=100;
@@ -55 +59 @@
 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 int signing_state = Undefined;
+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);
-
-
-/* return a pointer to a anonymous shared memory segment of size "size"
-   which will persist across fork() but will disappear when all processes
-   exit 
-
-   The memory is not zeroed 
-
-   This function uses system5 shared memory. It takes advantage of a property
-   that the memory is not destroyed if it is attached when the id is removed
-   */
-void *shm_setup(int size)
-{
-        int shmid;
-        void *ret;
-
-#ifdef __QNXNTO__
-        shmid = shm_open("private", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
-        if (shmid == -1) {
-                printf("can't get shared memory\n");
-                exit(1);
-        }
-        shm_unlink("private");
-        if (ftruncate(shmid, size) == -1) {
-                printf("can't set shared memory size\n");
-                exit(1);
-        }
-        ret = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
-        if (ret == MAP_FAILED) {
-                printf("can't map shared memory\n");
-                exit(1);
-        }
-#else
-        shmid = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR);
-        if (shmid == -1) {
-                printf("can't get shared memory\n");
-                exit(1);
-        }
-        ret = (void *)shmat(shmid, 0, 0);
-        if (!ret || ret == (void *)-1) {
-                printf("can't attach to shared memory\n");
-                return NULL;
-        }
-        /* the following releases the ipc, but note that this process
-           and all its children will still have access to the memory, its
-           just that the shmid is no longer valid for other shm calls. This
-           means we don't leave behind lots of shm segments after we exit 
-
-           See Stevens "advanced programming in unix env" for details
-           */
-        shmctl(shmid, IPC_RMID, 0);
-#endif
-
-        return ret;
-}
 
 /********************************************************************
@@ -128 +80 @@
                         const char *sharename)
 {
-        uint16 major, minor;
-        uint32 caplow, caphigh;
+        uint16_t major, minor;
+        uint32_t caplow, caphigh;
         NTSTATUS status;
 
@@ -177 +129 @@
 static struct cli_state *open_nbt_connection(void)
 {
-        struct nmb_name called, calling;
-        struct sockaddr_storage ss;
         struct cli_state *c;
         NTSTATUS status;
-
-        make_nmb_name(&calling, myname, 0x0);
-        make_nmb_name(&called , host, 0x20);
-
-        zero_sockaddr(&ss);
-
-        if (!(c = cli_initialise_ex(signing_state))) {
-                printf("Failed initialize cli_struct to connect with %s\n", host);
-                return NULL;
-        }
-
-        c->port = port_to_use;
-
-        status = cli_connect(c, host, &ss);
+        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 (use_kerberos) {
+                flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
+        }
+
+        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) );
@@ -200 +160 @@
         }
 
-        c->use_kerberos = use_kerberos;
-
-        c->timeout = 120000; /* set a really long timeout (2 minutes) */
-        if (use_oplocks) c->use_oplocks = True;
-        if (use_level_II_oplocks) c->use_level_II_oplocks = True;
-
-        if (!cli_session_request(c, &calling, &called)) {
-                /*
-                 * Well, that failed, try *SMBSERVER ...
-                 * However, we must reconnect as well ...
-                 */
-                status = cli_connect(c, host, &ss);
-                if (!NT_STATUS_IS_OK(status)) {
-                        printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
-                        return NULL;
-                }
-
-                make_nmb_name(&called, "*SMBSERVER", 0x20);
-                if (!cli_session_request(c, &calling, &called)) {
-                        printf("%s rejected the session\n",host);
-                        printf("We tried with a called name of %s & %s\n",
-                                host, "*SMBSERVER");
-                        cli_shutdown(c);
-                        return NULL;
-                }
-        }
+        cli_set_timeout(c, 120000); /* set a really long timeout (2 minutes) */
 
         return c;
@@ -234 +169 @@
 ****************************************************************************/
 
-static bool cli_bad_session_request(struct cli_state *cli,
+static bool cli_bad_session_request(int fd,
                          struct nmb_name *calling, struct nmb_name *called)
 {
-        char *p;
-        int len = 4;
-        int namelen = 0;
-        char *tmp;
-
-        memcpy(&(cli->calling), calling, sizeof(*calling));
-        memcpy(&(cli->called ), called , sizeof(*called ));
-
-        /* put in the destination name */
-
-        tmp = name_mangle(talloc_tos(), cli->called.name,
-                          cli->called.name_type);
-        if (tmp == NULL) {
-                return false;
-        }
-
-        p = cli->outbuf+len;
-        namelen = name_len((unsigned char *)tmp, talloc_get_size(tmp));
-        if (namelen > 0) {
-                memcpy(p, tmp, namelen);
-                len += namelen;
-        }
-        TALLOC_FREE(tmp);
+        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) */
-        *p = 100;
-
-        /* and my name */
-
-        tmp = name_mangle(talloc_tos(), cli->calling.name,
-                          cli->calling.name_type);
-        if (tmp == NULL) {
-                return false;
-        }
-
-        p = cli->outbuf+len;
-        namelen = name_len((unsigned char *)tmp, talloc_get_size(tmp));
-        if (namelen > 0) {
-                memcpy(p, tmp, namelen);
-                len += namelen;
-        }
-        TALLOC_FREE(tmp);
-        /* Deliberately corrupt the name len (first byte) */
-        *p = 100;
-
-        /* send a session request (RFC 1002) */
-        /* setup the packet length
+        *((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
@@ -290 +220 @@
          * CRH.
          */
-        len -= 4;
-        _smb_setlen(cli->outbuf,len);
-        SCVAL(cli->outbuf,0,0x81);
-
-        cli_send_smb(cli);
-        DEBUG(5,("Sent session request\n"));
-
-        if (!cli_receive_smb(cli))
-                return False;
-
-        if (CVAL(cli->inbuf,0) != 0x82) {
-                /* This is the wrong place to put the error... JRA. */
-                cli->rap_error = CVAL(cli->inbuf,4);
-                return False;
+
+        _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;
         }
-        return(True);
-}
-
-static struct cli_state *open_bad_nbt_connection(void)
-{
-        struct nmb_name called, calling;
-        struct sockaddr_storage ss;
-        struct cli_state *c;
-        NTSTATUS status;
-
-        make_nmb_name(&calling, myname, 0x0);
-        make_nmb_name(&called , host, 0x20);
-
-        zero_sockaddr(&ss);
-
-        if (!(c = cli_initialise_ex(signing_state))) {
-                printf("Failed initialize cli_struct to connect with %s\n", host);
-                return NULL;
-        }
-
-        c->port = 139;
-
-        status = cli_connect(c, host, &ss);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
-                return NULL;
-        }
-
-        c->timeout = 4000; /* set a short timeout (4 seconds) */
-
-        if (!cli_bad_session_request(c, &calling, &called)) {
-                printf("Failed to connect with %s. Error %s\n", host, nt_errstr(status) );
-                return NULL;
-        }
-
-        return c;
-}
-
+
+        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
@@ -427 +356 @@
         }
 
-        (*c)->timeout = 120000; /* set a really long timeout (2 minutes) */
+        cli_set_timeout(*c, 120000); /* set a really long timeout (2 minutes) */
 
         if (do_encrypt) {
@@ -468 +397 @@
 }
 
-bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
-{
-        uint16 old_vuid = cli->vuid;
-        fstring old_user_name;
+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);
         size_t passlen = strlen(password);
         NTSTATUS status;
         bool ret;
 
-        fstrcpy(old_user_name, cli->user_name);
-        cli->vuid = 0;
-        ret = NT_STATUS_IS_OK(cli_session_setup(cli, username,
-                                                password, passlen,
-                                                password, passlen,
-                                                workgroup));
-        *new_vuid = cli->vuid;
-        cli->vuid = old_vuid;
-        status = cli_set_username(cli, old_user_name);
-        if (!NT_STATUS_IS_OK(status)) {
-                return false;
-        }
+        cli_state_set_uid(cli, 0);
+        status = cli_session_setup(cli, username,
+                                   password, passlen,
+                                   password, passlen,
+                                   workgroup);
+        ret = NT_STATUS_IS_OK(status);
+        *new_vuid = cli_state_get_uid(cli);
+        cli_state_set_uid(cli, old_vuid);
         return ret;
 }
@@ -509 +446 @@
 
 
+/* 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, struct cli_state *c, 
-                        uint8 eclass, uint32 ecode, NTSTATUS nterr)
-{
-        if (cli_is_dos_error(c)) {
-                uint8 cclass;
-                uint32 num;
+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 */
 
-                cli_dos_error(c, &cclass, &num);
+                cclass = NT_STATUS_DOS_CLASS(status);
+                num = NT_STATUS_DOS_CODE(status);
 
                 if (eclass != cclass || ecode != num) {
@@ -525 +497 @@
                                (int)cclass, (int)num);
                         printf(" expected %d/%d %s (line=%d)\n", 
-                               (int)eclass, (int)ecode, nt_errstr(nterr), line);
+                               (int)eclass, (int)ecode, nt_errstr(nterr),
+                               line);
                         return False;
                 }
 
         } else {
-                NTSTATUS status;
-
                 /* Check NT error */
 
-                status = cli_nt_error(c);
-
                 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);
+                        printf("unexpected error code %s\n",
+                               nt_errstr(status));
+                        printf(" expected %s (line=%d)\n", nt_errstr(nterr),
+                               line);
                         return False;
                 }
@@ -547 +518 @@
 
 
-static bool wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
-{
-        while (!cli_lock(c, fnum, offset, len, -1, WRITE_LOCK)) {
-                if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
-        }
-        return True;
+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;
 }
 
@@ -566 +547 @@
         char buf[1024];
         bool correct = True;
+        size_t nread = 0;
         NTSTATUS status;
 
         memset(buf, '\0', sizeof(buf));
 
-        status = cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL, 
+        status = cli_openx(c, lockfname, O_RDWR | O_CREAT | O_EXCL, 
                          DENY_NONE, &fnum2);
         if (!NT_STATUS_IS_OK(status)) {
-                status = cli_open(c, lockfname, O_RDWR, DENY_NONE, &fnum2);
-        }
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("open of %s failed (%s)\n", lockfname, cli_errstr(c));
+                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;
         }
@@ -592 +575 @@
                 }
 
-                if (!NT_STATUS_IS_OK(cli_open(c, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL, &fnum))) {
-                        printf("open failed (%s)\n", cli_errstr(c));
+                status = cli_openx(c, fname, O_RDWR | O_CREAT | O_TRUNC,
+                                  DENY_ALL, &fnum);
+                if (!NT_STATUS_IS_OK(status)) {
+                        printf("open failed (%s)\n", nt_errstr(status));
                         correct = False;
                         break;
@@ -618 +603 @@
                 pid2 = 0;
 
-                if (cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid)) != sizeof(pid)) {
-                        printf("read failed (%s)\n", cli_errstr(c));
-                        correct = False;
+                status = cli_read(c, fnum, (char *)&pid2, 0, sizeof(pid),
+                                  &nread);
+                if (!NT_STATUS_IS_OK(status)) {
+                        printf("read failed (%s)\n", nt_errstr(status));
+                        correct = false;
+                } else if (nread != sizeof(pid)) {
+                        printf("read/write compare failed: "
+                               "recv %ld req %ld\n", (unsigned long)nread,
+                               (unsigned long)sizeof(pid));
+                        correct = false;
                 }
 
@@ -628 +620 @@
                 }
 
-                if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
-                        printf("close failed (%s)\n", cli_errstr(c));
+                status = cli_close(c, fnum);
+                if (!NT_STATUS_IS_OK(status)) {
+                        printf("close failed (%s)\n", nt_errstr(status));
                         correct = False;
                 }
 
-                if (!NT_STATUS_IS_OK(cli_unlink(c, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                        printf("unlink failed (%s)\n", cli_errstr(c));
+                status = cli_unlink(c, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
+                if (!NT_STATUS_IS_OK(status)) {
+                        printf("unlink failed (%s)\n", nt_errstr(status));
                         correct = False;
                 }
 
-                if (!NT_STATUS_IS_OK(cli_unlock(c, fnum2, n*sizeof(int), sizeof(int)))) {
-                        printf("unlock failed (%s)\n", cli_errstr(c));
+                status = cli_unlock(c, fnum2, n*sizeof(int), sizeof(int));
+                if (!NT_STATUS_IS_OK(status)) {
+                        printf("unlock failed (%s)\n", nt_errstr(status));
                         correct = False;
                 }
@@ -659 +654 @@
         cli = current_cli;
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         ret = rw_torture(cli);
@@ -678 +673 @@
         unsigned count;
         unsigned countprev = 0;
-        ssize_t sent = 0;
+        size_t sent = 0;
         bool correct = True;
         NTSTATUS status = NT_STATUS_OK;
 
         srandom(1);
-        for (i = 0; i < sizeof(buf); i += sizeof(uint32))
+        for (i = 0; i < sizeof(buf); i += sizeof(uint32_t))
         {
                 SIVAL(buf, i, sys_random());
@@ -690 +685 @@
         if (procnum == 0)
         {
-                if (!NT_STATUS_IS_OK(cli_unlink(c, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                        printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c));
-                }
-
-                if (!NT_STATUS_IS_OK(cli_open(c, lockfname, O_RDWR | O_CREAT | O_EXCL, 
-                                 DENY_NONE, &fnum))) {
+                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, cli_errstr(c));
+                                        lockfname, nt_errstr(status));
                         return False;
                 }
@@ -705 +705 @@
                 for (i = 0; i < 500 && fnum == (uint16_t)-1; i++)
                 {
-                        status = cli_open(c, lockfname, O_RDONLY, 
+                        status = cli_openx(c, lockfname, O_RDONLY, 
                                          DENY_NONE, &fnum);
-                        if (!NT_STATUS_IS_OK(status)) {
+                        if (NT_STATUS_IS_OK(status)) {
                                 break;
                         }
@@ -714 +714 @@
                 if (!NT_STATUS_IS_OK(status)) {
                         printf("second open read-only of %s failed (%s)\n",
-                                        lockfname, cli_errstr(c));
+                                        lockfname, nt_errstr(status));
                         return False;
                 }
@@ -738 +738 @@
 
                         status = cli_writeall(c, fnum, 0, (uint8_t *)buf+count,
-                                              count, (size_t)sent, NULL);
+                                              count, sent, NULL);
                         if (!NT_STATUS_IS_OK(status)) {
                                 printf("write failed (%s)\n",
@@ -747 +747 @@
                 else
                 {
-                        sent = cli_read(c, fnum, buf_rd+count, count,
-                                                  sizeof(buf)-count);
-                        if (sent < 0)
-                        {
+                        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,
-                                       cli_errstr(c));
+                                       nt_errstr(status));
                                 correct = False;
                                 sent = 0;
-                        }
-                        if (sent > 0)
-                        {
+                        } else if (sent > 0) {
                                 if (memcmp(buf_rd+count, buf+count, sent) != 0)
                                 {
@@ -771 +768 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(c, fnum))) {
-                printf("close failed (%s)\n", cli_errstr(c));
+        status = cli_close(c, fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close failed (%s)\n", nt_errstr(status));
                 correct = False;
         }
@@ -788 +786 @@
         char buf_rd[131072];
         bool correct = True;
-        ssize_t bytes_read;
-
-        if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink failed (%s) (normal, this file should not exist)\n", cli_errstr(c1));
-        }
-
-        if (!NT_STATUS_IS_OK(cli_open(c1, lockfname, O_RDWR | O_CREAT | O_EXCL, 
-                         DENY_NONE, &fnum1))) {
+        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, cli_errstr(c1));
-                return False;
-        }
-        if (!NT_STATUS_IS_OK(cli_open(c2, lockfname, O_RDONLY, 
-                         DENY_NONE, &fnum2))) {
+                                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, cli_errstr(c2));
+                                lockfname, nt_errstr(status));
                 cli_close(c1, fnum1);
                 return False;
         }
 
-        for (i=0;i<torture_numops;i++)
+        for (i = 0; i < torture_numops; i++)
         {
-                NTSTATUS status;
                 size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
                 if (i % 10 == 0) {
@@ -826 +827 @@
                 }
 
-                if ((bytes_read = cli_read(c2, fnum2, buf_rd, 0, buf_size)) != buf_size) {
-                        printf("read failed (%s)\n", cli_errstr(c2));
-                        printf("read %d, expected %ld\n", (int)bytes_read, 
+                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;
@@ -842 +849 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(c2, fnum2))) {
-                printf("close failed (%s)\n", cli_errstr(c2));
+        status = cli_close(c2, fnum2);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close failed (%s)\n", nt_errstr(status));
                 correct = False;
         }
-        if (!NT_STATUS_IS_OK(cli_close(c1, fnum1))) {
-                printf("close failed (%s)\n", cli_errstr(c1));
+
+        status = cli_close(c1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close failed (%s)\n", nt_errstr(status));
                 correct = False;
         }
 
-        if (!NT_STATUS_IS_OK(cli_unlink(c1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink failed (%s)\n", cli_errstr(c1));
+        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;
         }
@@ -867 +878 @@
                 return False;
         }
-        cli_sockopt(cli1, sockops);
-        cli_sockopt(cli2, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
+        smbXcli_conn_set_sockopt(cli2->conn, sockops);
 
         printf("starting readwritetest\n");
@@ -898 +909 @@
         cli = current_cli;
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         printf("run_readwritemulti: fname %s\n", randomfname);
@@ -910 +921 @@
 }
 
-static bool run_readwritelarge_internal(int max_xmit_k)
+static bool run_readwritelarge_internal(void)
 {
         static struct cli_state *cli1;
         uint16_t fnum1;
         const char *lockfname = "\\large.dat";
-        SMB_OFF_T fsize;
+        off_t fsize;
         char buf[126*1024];
         bool correct = True;
+        NTSTATUS status;
 
         if (!torture_open_connection(&cli1, 0)) {
                 return False;
         }
-        cli_sockopt(cli1, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
         memset(buf,'\0',sizeof(buf));
 
-        cli1->max_xmit = max_xmit_k*1024;
-
-        if (signing_state == Required) {
-                /* Horrible cheat to force
-                   multiple signed outstanding
-                   packets against a Samba server.
-                */
-                cli1->is_samba = false;
-        }
-
         printf("starting readwritelarge_internal\n");
 
         cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
+        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;
         }
@@ -946 +950 @@
         cli_writeall(cli1, fnum1, 0, (uint8_t *)buf, 0, sizeof(buf), NULL);
 
-        if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
-                                     cli1, fnum1, NULL, &fsize, NULL, NULL,
-                                     NULL, NULL, NULL))) {
-                printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
+        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;
         }
@@ -962 +966 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close failed (%s)\n", nt_errstr(status));
                 correct = False;
         }
 
-        if (!NT_STATUS_IS_OK(cli_unlink(cli1, lockfname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink failed (%s)\n", cli_errstr(cli1));
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_open(cli1, lockfname, O_RDWR | O_CREAT | O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open read/write of %s failed (%s)\n", lockfname, cli_errstr(cli1));
-                return False;
-        }
-
-        cli1->max_xmit = 4*1024;
+        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);
 
-        if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
-                                     cli1, fnum1, NULL, &fsize, NULL, NULL,
-                                     NULL, NULL, NULL))) {
-                printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
+        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;
         }
@@ -1012 +1018 @@
 #endif
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close failed (%s)\n", nt_errstr(status));
                 correct = False;
         }
@@ -1025 +1032 @@
 static bool run_readwritelarge(int dummy)
 {
-        return run_readwritelarge_internal(128);
+        return run_readwritelarge_internal();
 }
 
@@ -1031 +1038 @@
 {
         bool ret;
-        signing_state = Required;
-        ret = run_readwritelarge_internal(2);
-        signing_state = Undefined;
+        signing_state = SMB_SIGNING_REQUIRED;
+        ret = run_readwritelarge_internal();
+        signing_state = SMB_SIGNING_DEFAULT;
         return ret;
 }
@@ -1057 +1064 @@
         nbio_id = client;
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         nb_setup(cli);
@@ -1146 +1153 @@
         bool correct = True;
 
-        nbio_shmem(nprocs);
+        nbio_shmem(torture_nprocs);
 
         nbio_id = -1;
@@ -1175 +1182 @@
         time_t t1, t2;
         unsigned lock_timeout;
+        NTSTATUS status;
 
         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
                 return False;
         }
-        cli_sockopt(cli1, sockops);
-        cli_sockopt(cli2, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
+        smbXcli_conn_set_sockopt(cli2->conn, sockops);
 
         printf("starting locktest1\n");
@@ -1186 +1194 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum2))) {
-                printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-        if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum3))) {
-                printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli2));
-                return False;
-        }
-
-        if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
-                printf("lock1 failed (%s)\n", cli_errstr(cli1));
-                return False;
-        }
-
-
-        if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
+        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;
+                return false;
         } else {
-                if (!check_error(__LINE__, cli2, ERRDOS, ERRlock, 
-                                 NT_STATUS_LOCK_NOT_GRANTED)) return False;
-        }
-
+                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);
-        if (cli_lock(cli2, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
+        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;
+                return false;
         } else {
-                if (!check_error(__LINE__, cli2, ERRDOS, ERRlock, 
-                                 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
+                if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
+                                      NT_STATUS_FILE_LOCK_CONFLICT)) {
+                        return false;
+                }
         }
         t2 = time(NULL);
@@ -1233 +1252 @@
                (unsigned int)(t2-t1), lock_timeout);
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
-                printf("close1 failed (%s)\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (cli_lock(cli2, fnum3, 0, 4, 0, WRITE_LOCK)) {
+        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;
+                return false;
         } else {
-                if (!check_error(__LINE__, cli2, ERRDOS, ERRlock, 
-                                 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close2 failed (%s)\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli2, fnum3))) {
-                printf("close3 failed (%s)\n", cli_errstr(cli2));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink failed (%s)\n", cli_errstr(cli1));
+                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;
         }
@@ -1282 +1308 @@
         static struct cli_state *cli;
         const char *fname = "\\tcontest.tmp";
-        uint16 fnum1;
-        uint16 cnum1, cnum2, cnum3;
-        uint16 vuid1, vuid2;
+        uint16_t fnum1;
+        uint16_t cnum1, cnum2, cnum3;
+        uint16_t vuid1, vuid2;
         char buf[4];
         bool ret = True;
@@ -1294 +1320 @@
                 return False;
         }
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         printf("starting tcontest\n");
@@ -1300 +1326 @@
         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
-                return False;
-        }
-
-        cnum1 = cli->cnum;
-        vuid1 = cli->vuid;
+        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);
@@ -1314 +1341 @@
         }
 
-        status = cli_tcon_andx(cli, share, "?????",
-                               password, strlen(password)+1);
+        status = cli_tree_connect(cli, share, "?????",
+                                  password, strlen(password)+1);
         if (!NT_STATUS_IS_OK(status)) {
                 printf("%s refused 2nd tree connect (%s)\n", host,
@@ -1323 +1350 @@
         }
 
-        cnum2 = cli->cnum;
+        cnum2 = cli_state_get_tid(cli);
         cnum3 = MAX(cnum1, cnum2) + 1; /* any invalid number */
-        vuid2 = cli->vuid + 1;
+        vuid2 = cli_state_get_uid(cli) + 1;
 
         /* try a write with the wrong tid */
-        cli->cnum = cnum2;
+        cli_state_set_tid(cli, cnum2);
 
         status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
@@ -1341 +1368 @@
 
         /* try a write with an invalid tid */
-        cli->cnum = cnum3;
+        cli_state_set_tid(cli, cnum3);
 
         status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
@@ -1353 +1380 @@
 
         /* try a write with an invalid vuid */
-        cli->vuid = vuid2;
-        cli->cnum = cnum1;
+        cli_state_set_uid(cli, vuid2);
+        cli_state_set_tid(cli, cnum1);
 
         status = cli_writeall(cli, fnum1, 0, (uint8_t *)buf, 130, 4, NULL);
@@ -1365 +1392 @@
         }
 
-        cli->cnum = cnum1;
-        cli->vuid = vuid1;
-
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
-                printf("close failed (%s)\n", cli_errstr(cli));
-                return False;
-        }
-
-        cli->cnum = cnum2;
+        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));
+                return False;
+        }
+
+        cli_state_set_tid(cli, cnum2);
 
         status = cli_tdis(cli);
@@ -1381 +1409 @@
         }
 
-        cli->cnum = cnum1;
+        cli_state_set_tid(cli, cnum1);
 
         if (!torture_close_connection(cli)) {
@@ -1397 +1425 @@
 {
         static struct cli_state *cli;
-        uint16 cnum, max_xmit;
+        uint16_t cnum, max_xmit;
         char *service;
         NTSTATUS status;
@@ -1404 +1432 @@
                 return False;
         }
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         printf("starting tcon2 test\n");
@@ -1439 +1467 @@
         bool ret;
 
-        status = cli_tcon_andx(cli, myshare, devtype,
-                               password, strlen(password)+1);
+        status = cli_tree_connect(cli, myshare, devtype,
+                                  password, strlen(password)+1);
 
         if (NT_STATUS_IS_OK(expected_error)) {
@@ -1467 +1495 @@
                         ret = False;
                 } else {
-                        if (NT_STATUS_EQUAL(cli_nt_error(cli),
-                                            expected_error)) {
+                        if (NT_STATUS_EQUAL(status, expected_error)) {
                                 ret = True;
                         } else {
@@ -1556 +1583 @@
         uint16_t fnum1, fnum2, fnum3;
         bool correct = True;
+        NTSTATUS status;
 
         if (!torture_open_connection(&cli, 0)) {
@@ -1561 +1589 @@
         }
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         printf("starting locktest2\n");
@@ -1569 +1597 @@
         cli_setpid(cli, 1);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum2))) {
-                printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli));
+        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;
         }
@@ -1581 +1611 @@
         cli_setpid(cli, 2);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum3))) {
-                printf("open3 of %s failed (%s)\n", fname, cli_errstr(cli));
+        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;
         }
@@ -1588 +1619 @@
         cli_setpid(cli, 1);
 
-        if (!cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
-                printf("lock1 failed (%s)\n", cli_errstr(cli));
-                return False;
-        }
-
-        if (cli_lock(cli, fnum1, 0, 4, 0, WRITE_LOCK)) {
+        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;
+                correct = false;
         } else {
-                if (!check_error(__LINE__, cli, ERRDOS, ERRlock, 
-                                 NT_STATUS_LOCK_NOT_GRANTED)) return False;
-        }
-
-        if (cli_lock(cli, fnum2, 0, 4, 0, WRITE_LOCK)) {
+                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;
+                correct = false;
         } else {
-                if (!check_error(__LINE__, cli, ERRDOS, ERRlock, 
-                                 NT_STATUS_LOCK_NOT_GRANTED)) return False;
-        }
-
-        if (cli_lock(cli, fnum2, 0, 4, 0, READ_LOCK)) {
+                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;
+                correct = false;
         } else {
-                if (!check_error(__LINE__, cli, ERRDOS, ERRlock, 
-                                 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
-        }
-
-        if (!cli_lock(cli, fnum1, 100, 4, 0, WRITE_LOCK)) {
-                printf("lock at 100 failed (%s)\n", cli_errstr(cli));
+                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);
@@ -1626 +1668 @@
         }
 
-        if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 4))) {
+        status = cli_unlock(cli, fnum1, 0, 4);
+        if (NT_STATUS_IS_OK(status)) {
                 printf("unlock1 succeeded! This is a locking bug\n");
-                correct = False;
+                correct = false;
         } else {
-                if (!check_error(__LINE__, cli, 
-                                 ERRDOS, ERRlock, 
-                                 NT_STATUS_RANGE_NOT_LOCKED)) return False;
-        }
-
-        if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 8))) {
+                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;
+                correct = false;
         } else {
-                if (!check_error(__LINE__, cli, 
-                                 ERRDOS, ERRlock, 
-                                 NT_STATUS_RANGE_NOT_LOCKED)) return False;
-        }
-
-        if (cli_lock(cli, fnum3, 0, 4, 0, WRITE_LOCK)) {
+                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;
+                correct = false;
         } else {
-                if (!check_error(__LINE__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
+                if (!check_both_error(__LINE__, status, ERRDOS, ERRlock,
+                                      NT_STATUS_LOCK_NOT_GRANTED)) {
+                        return false;
+                }
         }
 
         cli_setpid(cli, 1);
 
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum1))) {
-                printf("close1 failed (%s)\n", cli_errstr(cli));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum2))) {
-                printf("close2 failed (%s)\n", cli_errstr(cli));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum3))) {
-                printf("close3 failed (%s)\n", cli_errstr(cli));
+        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;
         }
@@ -1689 +1742 @@
         uint16_t fnum1, fnum2;
         int i;
-        uint32 offset;
+        uint32_t offset;
         bool correct = True;
-
-#define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
+        NTSTATUS status;
+
+#define NEXT_OFFSET offset += (~(uint32_t)0) / torture_numops
 
         if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
                 return False;
         }
-        cli_sockopt(cli1, sockops);
-        cli_sockopt(cli2, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
+        smbXcli_conn_set_sockopt(cli2->conn, sockops);
 
         printf("starting locktest3\n");
@@ -1704 +1758 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-        if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
-                printf("open2 of %s failed (%s)\n", fname, cli_errstr(cli2));
+        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;
         }
@@ -1715 +1773 @@
         for (offset=i=0;i<torture_numops;i++) {
                 NEXT_OFFSET;
-                if (!cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
+
+                status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
+                if (!NT_STATUS_IS_OK(status)) {
                         printf("lock1 %d failed (%s)\n", 
                                i,
-                               cli_errstr(cli1));
+                               nt_errstr(status));
                         return False;
                 }
 
-                if (!cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
+                status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
+                if (!NT_STATUS_IS_OK(status)) {
                         printf("lock2 %d failed (%s)\n", 
                                i,
-                               cli_errstr(cli1));
+                               nt_errstr(status));
                         return False;
                 }
@@ -1733 +1794 @@
                 NEXT_OFFSET;
 
-                if (cli_lock(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
+                status = cli_lock32(cli1, fnum1, offset-2, 1, 0, WRITE_LOCK);
+                if (NT_STATUS_IS_OK(status)) {
                         printf("error: lock1 %d succeeded!\n", i);
                         return False;
                 }
 
-                if (cli_lock(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
+                status = cli_lock32(cli2, fnum2, offset-1, 1, 0, WRITE_LOCK);
+                if (NT_STATUS_IS_OK(status)) {
                         printf("error: lock2 %d succeeded!\n", i);
                         return False;
                 }
 
-                if (cli_lock(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
+                status = cli_lock32(cli1, fnum1, offset-1, 1, 0, WRITE_LOCK);
+                if (NT_STATUS_IS_OK(status)) {
                         printf("error: lock3 %d succeeded!\n", i);
                         return False;
                 }
 
-                if (cli_lock(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
+                status = cli_lock32(cli2, fnum2, offset-2, 1, 0, WRITE_LOCK);
+                if (NT_STATUS_IS_OK(status)) {
                         printf("error: lock4 %d succeeded!\n", i);
                         return False;
@@ -1757 +1822 @@
                 NEXT_OFFSET;
 
-                if (!NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, offset-1, 1))) {
+                status = cli_unlock(cli1, fnum1, offset-1, 1);
+                if (!NT_STATUS_IS_OK(status)) {
                         printf("unlock1 %d failed (%s)\n", 
                                i,
-                               cli_errstr(cli1));
+                               nt_errstr(status));
                         return False;
                 }
 
-                if (!NT_STATUS_IS_OK(cli_unlock(cli2, fnum2, offset-2, 1))) {
+                status = cli_unlock(cli2, fnum2, offset-2, 1);
+                if (!NT_STATUS_IS_OK(status)) {
                         printf("unlock2 %d failed (%s)\n", 
                                i,
-                               cli_errstr(cli1));
+                               nt_errstr(status));
                         return False;
                 }
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close1 failed (%s)\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
-                printf("close2 failed (%s)\n", cli_errstr(cli2));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close1 failed (%s)\n", nt_errstr(status));
+                return False;
+        }
+
+        status = cli_close(cli2, fnum2);
+        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;
         }
@@ -1798 +1868 @@
 
         return correct;
+}
+
+static bool test_cli_read(struct cli_state *cli, uint16_t fnum,
+                           char *buf, off_t offset, size_t size,
+                           size_t *nread, size_t expect)
+{
+        NTSTATUS status;
+        size_t l_nread;
+
+        status = cli_read(cli, fnum, buf, offset, size, &l_nread);
+
+        if(!NT_STATUS_IS_OK(status)) {
+                return false;
+        } else if (l_nread != expect) {
+                return false;
+        }
+
+        if (nread) {
+                *nread = l_nread;
+        }
+
+        return true;
 }
 
@@ -1821 +1913 @@
         }
 
-        cli_sockopt(cli1, sockops);
-        cli_sockopt(cli2, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
+        smbXcli_conn_set_sockopt(cli2->conn, sockops);
 
         printf("starting locktest4\n");
@@ -1828 +1920 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
-        cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
+        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));
@@ -1841 +1933 @@
         }
 
-        ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
-              cli_lock(cli1, fnum1, 2, 4, 0, WRITE_LOCK);
+        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 = cli_lock(cli1, fnum1, 10, 4, 0, READ_LOCK) &&
-              cli_lock(cli1, fnum1, 12, 4, 0, READ_LOCK);
+        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 = cli_lock(cli1, fnum1, 20, 4, 0, WRITE_LOCK) &&
-              cli_lock(cli2, fnum2, 22, 4, 0, WRITE_LOCK);
+        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 = cli_lock(cli1, fnum1, 30, 4, 0, READ_LOCK) &&
-              cli_lock(cli2, fnum2, 32, 4, 0, READ_LOCK);
+        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), cli_lock(cli1, fnum1, 40, 4, 0, WRITE_LOCK)) &&
-              (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 42, 4, 0, WRITE_LOCK));
+        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), cli_lock(cli1, fnum1, 50, 4, 0, READ_LOCK)) &&
-              (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 52, 4, 0, READ_LOCK));
+        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 = cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK) &&
-              cli_lock(cli1, fnum1, 60, 4, 0, READ_LOCK);
+        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 = cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK) &&
-              cli_lock(cli1, fnum1, 70, 4, 0, WRITE_LOCK);
+        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 = cli_lock(cli1, fnum1, 80, 4, 0, READ_LOCK) &&
-              cli_lock(cli1, fnum1, 80, 4, 0, WRITE_LOCK);
+        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 = cli_lock(cli1, fnum1, 90, 4, 0, WRITE_LOCK) &&
-              cli_lock(cli1, fnum1, 90, 4, 0, READ_LOCK);
+        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), cli_lock(cli1, fnum1, 100, 4, 0, WRITE_LOCK)) &&
-              (cli_setpid(cli1, 2), cli_lock(cli1, fnum1, 100, 4, 0, READ_LOCK));
+        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 = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
-              cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
+        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);
@@ -1903 +2001 @@
 
 
-        ret = cli_lock(cli1, fnum1, 120, 4, 0, WRITE_LOCK) &&
-              (cli_read(cli2, fnum2, buf, 120, 4) == 4);
+        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");
 
-        ret = cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK);
+        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,
@@ -1918 +2017 @@
 
 
-        ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
-              cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
+        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));
@@ -1926 +2025 @@
 
 
-        ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
-              cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
+        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)) &&
-              (cli_read(cli2, fnum2, buf, 150, 4) == 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))) &&
@@ -1936 +2035 @@
         printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
 
-        ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
+        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)) &&
-              (cli_read(cli2, fnum2, buf, 160, 4) == 4);                
+              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 = cli_lock(cli1, fnum1, 170, 4, 0, WRITE_LOCK) &&
+        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)) &&
-              (cli_read(cli2, fnum2, buf, 170, 4) == 4);                
+              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 = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
-              cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
+        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)) &&
-              (cli_read(cli2, fnum2, buf, 190, 4) == 4);                
+              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");
@@ -1963 +2062 @@
         cli_close(cli1, fnum1);
         cli_close(cli2, fnum2);
-        cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
-        cli_open(cli1, fname, O_RDWR, DENY_NONE, &f);
-        ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
-              cli_lock(cli1, f, 0, 1, 0, READ_LOCK) &&
+        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_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1)) &&
-              cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
+              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);
@@ -2003 +2102 @@
         }
 
-        cli_sockopt(cli1, sockops);
-        cli_sockopt(cli2, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
+        smbXcli_conn_set_sockopt(cli2->conn, sockops);
 
         printf("starting locktest5\n");
@@ -2010 +2109 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
-        cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2);
-        cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum3);
+        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));
@@ -2025 +2124 @@
 
         /* Check for NT bug... */
-        ret = cli_lock(cli1, fnum1, 0, 8, 0, READ_LOCK) &&
-                  cli_lock(cli1, fnum3, 0, 1, 0, READ_LOCK);
+        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_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
-        ret = cli_lock(cli1, fnum1, 7, 1, 0, WRITE_LOCK);
+        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_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
+        cli_openx(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
         cli_unlock(cli1, fnum3, 0, 1);
 
-        ret = cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK) &&
-              cli_lock(cli1, fnum1, 1, 1, 0, READ_LOCK);
+        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");
 
-        ret = cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
+        status = cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK);
+        ret = NT_STATUS_IS_OK(status);
         EXPECTED(ret, False);
 
@@ -2049 +2150 @@
         cli_unlock(cli2, fnum2, 0, 4);
 
-        ret = cli_lock(cli1, fnum3, 0, 4, 0, READ_LOCK);
+        status = cli_lock32(cli1, fnum3, 0, 4, 0, READ_LOCK);
+        ret = NT_STATUS_IS_OK(status);
         EXPECTED(ret, False);
 
@@ -2058 +2160 @@
 
         /* Stack 2 more locks here. */
-        ret = cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK) &&
-                  cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK);
+        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);
@@ -2068 +2170 @@
 
         ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
-                        cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
+              NT_STATUS_IS_OK(cli_lock32(cli2, fnum2, 0, 4, 0, READ_LOCK));
 
         EXPECTED(ret, True);
@@ -2091 +2193 @@
 
         /* Ensure connection 2 can get a write lock. */
-        ret = cli_lock(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
+        status = cli_lock32(cli2, fnum2, 0, 4, 0, WRITE_LOCK);
+        ret = NT_STATUS_IS_OK(status);
         EXPECTED(ret, True);
 
@@ -2128 +2231 @@
         }
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         printf("starting locktest6\n");
@@ -2137 +2240 @@
                 cli_unlink(cli, fname[i], FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-                cli_open(cli, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum);
+                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_open(cli, fname[i], O_RDWR, DENY_NONE, &fnum);
+                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);
@@ -2163 +2266 @@
         char buf[200];
         bool correct = False;
+        size_t nread;
         NTSTATUS status;
 
@@ -2169 +2273 @@
         }
 
-        cli_sockopt(cli1, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
 
         printf("starting locktest7\n");
@@ -2175 +2279 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
+        cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1);
 
         memset(buf, 0, sizeof(buf));
@@ -2188 +2292 @@
         cli_setpid(cli1, 1);
 
-        if (!cli_lock(cli1, fnum1, 130, 4, 0, READ_LOCK)) {
-                printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1));
+        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 {
@@ -2195 +2301 @@
         }
 
-        if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
-                printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
+        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 {
@@ -2217 +2329 @@
         cli_setpid(cli1, 2);
 
-        if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
-                printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
+        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");
@@ -2239 +2358 @@
         cli_unlock(cli1, fnum1, 130, 4);
 
-        if (!cli_lock(cli1, fnum1, 130, 4, 0, WRITE_LOCK)) {
-                printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1));
+        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 {
@@ -2246 +2366 @@
         }
 
-        if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
-                printf("pid1 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
+        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 {
@@ -2264 +2390 @@
         cli_setpid(cli1, 2);
 
-        if (cli_read(cli1, fnum1, buf, 130, 4) != 4) {
-                printf("pid2 unable to read the range 130:4, error was %s\n", cli_errstr(cli1));
-                if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_FILE_LOCK_CONFLICT)) {
+        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)\n");
+                printf("pid2 successfully read the range 130:4 (should be denied) recv %ld\n",
+                       (unsigned long)nread);
                 goto fail;
         }
@@ -2321 +2450 @@
         }
 
-        cli_sockopt(cli1, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
 
         printf("starting locktest8\n");
@@ -2327 +2456 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        status = cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
+        status = cli_openx(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_WRITE,
                           &fnum1);
         if (!NT_STATUS_IS_OK(status)) {
-                d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
+                d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status));
                 return false;
         }
@@ -2336 +2465 @@
         memset(buf, 0, sizeof(buf));
 
-        status = cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum2);
-        if (!NT_STATUS_IS_OK(status)) {
-                d_fprintf(stderr, "cli_open second time returned %s\n",
-                          cli_errstr(cli1));
+        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;
         }
 
-        if (!cli_lock(cli1, fnum2, 1, 1, 0, READ_LOCK)) {
+        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", cli_errstr(cli1));
+                       "%s\n", nt_errstr(status));
                 goto fail;
         }
@@ -2351 +2481 @@
         status = cli_close(cli1, fnum1);
         if (!NT_STATUS_IS_OK(status)) {
-                d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
+                d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
                 goto fail;
         }
 
-        status = cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1);
-        if (!NT_STATUS_IS_OK(status)) {
-                d_fprintf(stderr, "cli_open third time returned %s\n",
-                          cli_errstr(cli1));
+        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;
         }
@@ -2382 +2512 @@
 
 static bool got_alarm;
-static int alarm_fd;
+static struct cli_state *alarm_cli;
 
 static void alarm_handler(int dummy)
@@ -2391 +2521 @@
 static void alarm_handler_parent(int dummy)
 {
-        close(alarm_fd);
+        smbXcli_conn_disconnect(alarm_cli->conn, NT_STATUS_OK);
 }
 
@@ -2515 +2645 @@
         }
 
-        cli_sockopt(cli1, sockops);
-
-        status = cli_open(cli1, fname, O_RDWR, DENY_NONE,
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
+
+        status = cli_openx(cli1, fname, O_RDWR, DENY_NONE,
                           &fnum);
         if (!NT_STATUS_IS_OK(status)) {
-                d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
+                d_fprintf(stderr, "cli_openx returned %s\n", nt_errstr(status));
                 return false;
         }
 
         /* Ensure the child has the lock. */
-        if (cli_lock(cli1, fnum, 0, 4, 0, WRITE_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;
@@ -2541 +2672 @@
 
         /* Wait 20 seconds for the lock. */
-        alarm_fd = cli1->fd;
+        alarm_cli = cli1;
         CatchSignal(SIGALRM, alarm_handler_parent);
         alarm(20);
@@ -2547 +2678 @@
         start = timeval_current();
 
-        if (!cli_lock(cli1, fnum, 0, 4, -1, WRITE_LOCK)) {
+        status = cli_lock32(cli1, fnum, 0, 4, -1, WRITE_LOCK);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
-                       "%s\n", cli_errstr(cli1));
+                       "%s\n", nt_errstr(status));
                 goto fail_nofd;
         }
@@ -2561 +2693 @@
         status = cli_close(cli1, fnum);
         if (!NT_STATUS_IS_OK(status)) {
-                d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
+                d_fprintf(stderr, "cli_close(fnum1) %s\n", nt_errstr(status));
                 goto fail;
         }
@@ -2592 +2724 @@
                 return False;
         }
-        cli_sockopt(cli1, sockops);
-        cli_sockopt(cli2, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
+        smbXcli_conn_set_sockopt(cli2->conn, sockops);
 
         printf("starting fdpasstest\n");
@@ -2599 +2731 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        status = cli_writeall(cli1, fnum1, 0, (uint8_t *)"hello world\n", 0,
+        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)) {
@@ -2611 +2745 @@
         }
 
-        cli2->vuid = cli1->vuid;
-        cli2->cnum = cli1->cnum;
-        cli2->pid = cli1->pid;
-
-        if (cli_read(cli2, fnum1, buf, 0, 13) == 13) {
-                printf("read succeeded! nasty security hole [%s]\n",
-                       buf);
-                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;
         }
 
@@ -2634 +2767 @@
 {
         struct cli_state *cli;
-        uint16 new_vuid;
-        uint16 saved_vuid;
-        uint16 new_cnum;
-        uint16 saved_cnum;
+        uint16_t new_vuid;
+        uint16_t saved_vuid;
+        uint16_t new_cnum;
+        uint16_t saved_cnum;
         const char *fname = "\\fdsess.tst";
         const char *fname1 = "\\fdsess1.tst";
@@ -2648 +2781 @@
         if (!torture_open_connection(&cli, 0))
                 return False;
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         if (!torture_cli_session_setup2(cli, &new_vuid))
                 return False;
 
-        saved_cnum = cli->cnum;
-        if (!NT_STATUS_IS_OK(cli_tcon_andx(cli, share, "?????", "", 1)))
-                return False;
-        new_cnum = cli->cnum;
-        cli->cnum = saved_cnum;
+        saved_cnum = cli_state_get_tid(cli);
+        if (!NT_STATUS_IS_OK(cli_tree_connect(cli, share, "?????", "", 1)))
+                return False;
+        new_cnum = cli_state_get_tid(cli);
+        cli_state_set_tid(cli, saved_cnum);
 
         printf("starting fdsesstest\n");
@@ -2664 +2797 @@
         cli_unlink(cli, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
-                return False;
-        }
-
-        status = cli_writeall(cli, fnum1, 0, (uint8_t *)"hello world\n", 0, 13,
+        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)) {
@@ -2676 +2810 @@
         }
 
-        saved_vuid = cli->vuid;
-        cli->vuid = new_vuid;
-
-        if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
-                printf("read succeeded with different vuid! nasty security hole [%s]\n",
-                       buf);
-                ret = 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_open(cli, fname1, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum2))) {
+        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);
@@ -2695 +2829 @@
         }
 
-        cli->vuid = saved_vuid;
+        cli_state_set_uid(cli, saved_vuid);
 
         /* Try with same vuid, different cnum. */
-        cli->cnum = new_cnum;
-
-        if (cli_read(cli, fnum1, buf, 0, 13) == 13) {
-                printf("read succeeded with different cnum![%s]\n",
-                       buf);
-                ret = False;
-        }
-
-        cli->cnum = saved_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);
@@ -2727 +2860 @@
         uint16_t fnum;
         bool correct = True;
+        NTSTATUS status;
 
         if (!torture_open_connection(&cli, 0)) {
@@ -2732 +2866 @@
         }
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         printf("starting unlink test\n");
@@ -2740 +2874 @@
         cli_setpid(cli, 1);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
-                return False;
-        }
-
-        if (NT_STATUS_IS_OK(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_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__, cli, ERRDOS, ERRbadshare, 
+                correct = check_error(__LINE__, status, ERRDOS, ERRbadshare,
                                       NT_STATUS_SHARING_VIOLATION);
         }
@@ -2772 +2909 @@
 {
         struct cli_state *cli;
-        const char *ftemplate = "\\maxfid.%d.%d";
         fstring fname;
         uint16_t fnums[0x11000];
@@ -2778 +2914 @@
         int retries=4;
         bool correct = True;
+        NTSTATUS status;
 
         cli = current_cli;
@@ -2786 +2923 @@
         }
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         for (i=0; i<0x11000; i++) {
-                slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
-                if (!NT_STATUS_IS_OK(cli_open(cli, fname, 
-                                        O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnums[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, cli_errstr(cli));
+                               fname, nt_errstr(status));
                         printf("maximum fnum is %d\n", i);
                         break;
@@ -2804 +2942 @@
         printf("cleaning up\n");
         for (;i>=0;i--) {
-                slprintf(fname,sizeof(fname)-1,ftemplate, i,(int)getpid());
+                slprintf(fname,sizeof(fname)-1,"\\maxfid.%d.%d", i,(int)getpid());
                 cli_close(cli, fnums[i]);
-                if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
+
+                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, cli_errstr(cli));
+                               fname, nt_errstr(status));
                         correct = False;
                 }
@@ -2841 +2981 @@
         printf("starting negprot nowait test\n");
 
-        ev = tevent_context_init(talloc_tos());
+        ev = samba_tevent_context_init(talloc_tos());
         if (ev == NULL) {
                 return false;
@@ -2854 +2994 @@
                 struct tevent_req *req;
 
-                req = cli_negprot_send(ev, ev, cli);
+                req = smbXcli_negprot_send(ev, ev, cli->conn, cli->timeout,
+                                           PROTOCOL_CORE, PROTOCOL_NT1);
                 if (req == NULL) {
                         TALLOC_FREE(ev);
@@ -2880 +3021 @@
 static bool run_bad_nbt_session(int dummy)
 {
-        static struct cli_state *cli;
+        struct nmb_name called, calling;
+        struct sockaddr_storage ss;
+        NTSTATUS status;
+        int fd;
+        bool ret;
 
         printf("starting bad nbt session test\n");
 
-        if (!(cli = open_bad_nbt_connection())) {
-                return False;
-        }
-
-        cli_shutdown(cli);
+        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;
@@ -2921 +3084 @@
                 cli_api(cli, 
                         param, param_len, 8,  
-                        NULL, 0, BUFFER_SIZE, 
+                        NULL, 0, CLI_BUFFER_SIZE,
                         &rparam, &rprcnt,     
                         &rdata, &rdrcnt);
@@ -2934 +3097 @@
         }
 
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+
         printf("finished random ipc test\n");
 
@@ -2941 +3107 @@
 
 
-static void browse_callback(const char *sname, uint32 stype, 
+static void browse_callback(const char *sname, uint32_t stype,
                             const char *comment, void *state)
 {
@@ -2995 +3161 @@
         const char *fname = "\\attrib123456789.tst";
         bool correct = True;
+        NTSTATUS status;
 
         printf("starting attrib test\n");
@@ -3003 +3170 @@
 
         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-        cli_open(cli, fname, 
+        cli_openx(cli, fname, 
                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
         cli_close(cli, fnum);
-        if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
-                printf("getatr failed (%s)\n", cli_errstr(cli));
+
+        status = cli_getatr(cli, fname, NULL, NULL, &t);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("getatr failed (%s)\n", nt_errstr(status));
                 correct = False;
         }
@@ -3020 +3189 @@
         t2 = t-60*60*24; /* 1 day ago */
 
-        if (!NT_STATUS_IS_OK(cli_setatr(cli, fname, 0, t2))) {
-                printf("setatr failed (%s)\n", cli_errstr(cli));
+        status = cli_setatr(cli, fname, 0, t2);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("setatr failed (%s)\n", nt_errstr(status));
                 correct = True;
         }
 
-        if (!NT_STATUS_IS_OK(cli_getatr(cli, fname, NULL, NULL, &t))) {
-                printf("getatr failed (%s)\n", cli_errstr(cli));
+        status = cli_getatr(cli, fname, NULL, NULL, &t);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("getatr failed (%s)\n", nt_errstr(status));
                 correct = True;
         }
@@ -3056 +3227 @@
         struct cli_state *cli;
         uint16_t fnum;
-        SMB_OFF_T size;
+        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;
@@ -3062 +3233 @@
         const char *dname = "\\trans2";
         const char *fname2 = "\\trans2\\trans2.tst";
-        char pname[1024];
+        char *pname;
         bool correct = True;
         NTSTATUS status;
@@ -3081 +3252 @@
 
         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-        cli_open(cli, fname, 
-                        O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
-        if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
-                                     cli, fnum, NULL, &size, &c_time_ts,
-                                     &a_time_ts, &w_time_ts,
-                                     &m_time_ts, NULL))) {
-                printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli));
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_qfilename(cli, fnum, pname, sizeof(pname)))) {
-                printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
+        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;
         }
-
-        if (strcmp(pname, fname)) {
+        else if (strcmp(pname, fname)) {
                 printf("qfilename gave different name? [%s] [%s]\n",
                        fname, pname);
@@ -3107 +3276 @@
 
         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, 
-                        O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
+        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;
         }
@@ -3120 +3290 @@
                 correct = False;
         } else {
+                time_t t = time(NULL);
+
                 if (c_time != m_time) {
                         printf("create time=%s", ctime(&c_time));
@@ -3125 +3297 @@
                         printf("This system appears to have sticky create times\n");
                 }
-                if (a_time % (60*60) == 0) {
+                if ((abs(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");
@@ -3131 +3303 @@
                 }
 
-                if (abs(m_time - time(NULL)) > 60*60*24*7) {
+                if (abs(m_time - t) > 60*60*24*7) {
                         printf("ERROR: totally incorrect times - maybe word reversed? mtime=%s", ctime(&m_time));
                         correct = False;
@@ -3139 +3311 @@
 
         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-        cli_open(cli, fname, 
+        cli_openx(cli, fname, 
                         O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
         cli_close(cli, fnum);
@@ -3160 +3332 @@
         /* check if the server updates the directory modification time
            when creating a new file */
-        if (!NT_STATUS_IS_OK(cli_mkdir(cli, dname))) {
-                printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli));
+        status = cli_mkdir(cli, dname);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("ERROR: mkdir failed (%s)\n", nt_errstr(status));
                 correct = False;
         }
@@ -3172 +3345 @@
         }
 
-        cli_open(cli, fname2, 
+        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);
@@ -3207 +3380 @@
 {
         uint8_t *buf = NULL;
-        uint32 len;
+        uint32_t len;
         NTSTATUS status;
 
         status = cli_qfileinfo(talloc_tos(), pcli, fnum, level, 0,
-                               pcli->max_xmit, &buf, &len);
+                               CLI_BUFFER_SIZE, NULL, &buf, &len);
         if (!NT_STATUS_IS_OK(status)) {
                 printf("ERROR: qfileinfo (%d) failed (%s)\n", level,
@@ -3217 +3390 @@
         } else {
                 printf("qfileinfo: level %d, len = %u\n", level, len);
-                dump_data(0, (uint8 *)buf, len);
+                dump_data(0, (uint8_t *)buf, len);
                 printf("\n");
         }
@@ -3238 +3411 @@
         }
 
-        cli_open(cli, fname, 
+        cli_openx(cli, fname, 
                         O_RDWR | O_CREAT , DENY_NONE, &fnum);
 
@@ -3266 +3439 @@
         uint16_t fnum1;
         bool correct = True;
+        NTSTATUS status;
 
         printf("starting oplock test 1\n");
@@ -3275 +3449 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        cli_sockopt(cli1, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
 
         cli1->use_oplocks = True;
 
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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;
         }
@@ -3289 +3465 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close2 failed (%s)\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink failed (%s)\n", cli_errstr(cli1));
+        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;
         }
@@ -3317 +3495 @@
         bool correct = True;
         volatile bool *shared_correct;
-
-        shared_correct = (volatile bool *)shm_setup(sizeof(bool));
+        size_t nread;
+        NTSTATUS status;
+
+        shared_correct = (volatile bool *)anonymous_shared_allocate(sizeof(bool));
         *shared_correct = True;
 
@@ -3332 +3512 @@
         }
 
-        cli1->use_oplocks = True;
-        cli1->use_level_II_oplocks = True;
-
         if (!torture_open_connection(&cli2, 1)) {
                 use_level_II_oplocks = False;
@@ -3341 +3518 @@
         }
 
-        cli2->use_oplocks = True;
-        cli2->use_level_II_oplocks = True;
-
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        cli_sockopt(cli1, sockops);
-        cli_sockopt(cli2, sockops);
-
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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;
         }
@@ -3360 +3536 @@
         if (fork() == 0) {
                 /* Child code */
-                if (!NT_STATUS_IS_OK(cli_open(cli2, fname, O_RDWR, DENY_NONE, &fnum2))) {
-                        printf("second open of %s failed (%s)\n", fname, cli_errstr(cli1));
+                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);
@@ -3368 +3545 @@
                 sleep(2);
 
-                if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
-                        printf("close2 failed (%s)\n", cli_errstr(cli1));
+                status = cli_close(cli2, fnum2);
+                if (!NT_STATUS_IS_OK(status)) {
+                        printf("close2 failed (%s)\n", nt_errstr(status));
                         *shared_correct = False;
                 }
@@ -3380 +3558 @@
         /* Ensure cli1 processes the break. Empty file should always return 0
          * bytes.  */
-
-        if (cli_read(cli1, fnum1, buf, 0, 4) != 0) {
-                printf("read on fnum1 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        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. */
-
-        if (!cli_lock(cli1, fnum1, 0, 4, 0, READ_LOCK)) {
-                printf("lock failed (%s)\n", cli_errstr(cli1));
+        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;
         }
@@ -3398 +3580 @@
         sleep(2);
 
-        if (!cli_lock(cli1, fnum1, 0, 4, 0, WRITE_LOCK)) {
-                printf("lock failed (%s)\n", cli_errstr(cli1));
+        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;
         }
@@ -3407 +3590 @@
         sleep(2);
 
-        cli_read(cli1, fnum1, buf, 0, 4);
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close1 failed (%s)\n", cli_errstr(cli1));
+        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;
         }
@@ -3416 +3600 @@
         sleep(4);
 
-        if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink failed (%s)\n", cli_errstr(cli1));
+        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;
         }
@@ -3434 +3619 @@
 }
 
-/* handler for oplock 3 tests */
-static NTSTATUS oplock3_handler(struct cli_state *cli, uint16_t fnum, unsigned char level)
-{
-        printf("got oplock break fnum=%d level=%d\n",
-               fnum, level);
-        return cli_oplock_ack(cli, fnum, level);
-}
-
-static bool run_oplock3(int dummy)
-{
+struct oplock4_state {
+        struct tevent_context *ev;
         struct cli_state *cli;
-        const char *fname = "\\oplockt3.dat";
-        uint16_t fnum;
-        char buf[4] = "abcd";
-        bool correct = True;
-        volatile bool *shared_correct;
-
-        shared_correct = (volatile bool *)shm_setup(sizeof(bool));
-        *shared_correct = True;
-
-        printf("starting oplock test 3\n");
-
-        if (fork() == 0) {
-                /* Child code */
-                use_oplocks = True;
-                use_level_II_oplocks = True;
-                if (!torture_open_connection(&cli, 0)) {
-                        *shared_correct = False;
-                        exit(0);
-                } 
-                sleep(2);
-                /* try to trigger a oplock break in parent */
-                cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
-                cli_writeall(cli, fnum, 0, (uint8_t *)buf, 0, 4, NULL);
-                exit(0);
-        }
-
-        /* parent code */
-        use_oplocks = True;
-        use_level_II_oplocks = True;
-        if (!torture_open_connection(&cli, 1)) { /* other is forked */
-                return False;
-        }
-        cli_oplock_handler(cli, oplock3_handler);
-        cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum);
-        cli_writeall(cli, fnum, 0, (uint8_t *)buf, 0, 4, NULL);
-        cli_close(cli, fnum);
-        cli_open(cli, fname, O_RDWR, DENY_NONE, &fnum);
-        cli->timeout = 20000;
-        cli_receive_smb(cli);
-        printf("finished oplock test 3\n");
-
-        return (correct && *shared_correct);
-
-/* What are we looking for here?  What's sucess and what's FAILURE? */
-}
-
-/* handler for oplock 4 tests */
-bool *oplock4_shared_correct;
-
-static NTSTATUS oplock4_handler(struct cli_state *cli, uint16_t fnum, unsigned char level)
-{
-        printf("got oplock break fnum=%d level=%d\n",
-               fnum, level);
-        *oplock4_shared_correct = true;
-        cli_oplock_ack(cli, fnum, level);
-        return NT_STATUS_UNSUCCESSFUL; /* Cause cli_receive_smb to return. */
-}
+        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";
@@ -3513 +3641 @@
         bool correct = true;
 
-        oplock4_shared_correct = (bool *)shm_setup(sizeof(bool));
-        *oplock4_shared_correct = false;
+        bool got_break;
+
+        struct oplock4_state *state;
 
         printf("starting oplock test 4\n");
@@ -3533 +3662 @@
         cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        cli_sockopt(cli1, sockops);
-        cli_sockopt(cli2, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
+        smbXcli_conn_set_sockopt(cli2->conn, sockops);
 
         /* Create the file. */
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return false;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close1 failed (%s)\n", cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_nt_hardlink(cli1, fname, fname_ln))) {
-                printf("nt hardlink failed (%s)\n", cli_errstr(cli1));
+        status = cli_nt_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. */
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return false;
-        }
-
-        status = cli_open(cli1, fname_ln, O_RDWR, DENY_NONE, &fnum2);
+        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",
@@ -3572 +3706 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close1 failed (%s)\n", cli_errstr(cli1));
+        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;
-        cli1->use_level_II_oplocks = true;
-
         cli2->use_oplocks = true;
-        cli2->use_level_II_oplocks = true;
-
-        cli_oplock_handler(cli1, oplock4_handler);
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return false;
-        }
-
-        if (fork() == 0) {
-                /* Child code */
-                if (!NT_STATUS_IS_OK(cli_open(cli2, fname_ln, O_RDWR, DENY_NONE, &fnum2))) {
-                        printf("open of %s failed (%s)\n", fname_ln, cli_errstr(cli1));
-                        *oplock4_shared_correct = false;
-                        exit(0);
-                }
-
-                if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
-                        printf("close2 failed (%s)\n", cli_errstr(cli1));
-                        *oplock4_shared_correct = false;
-                }
-
-                exit(0);
-        }
-
-        sleep(2);
-
-        /* Process the oplock break. */
-        cli_receive_smb(cli1);
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close1 failed (%s)\n", cli_errstr(cli1));
+
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close1 failed (%s)\n", nt_errstr(status));
                 correct = false;
         }
-        if (!NT_STATUS_IS_OK(cli_unlink(cli1, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink failed (%s)\n", cli_errstr(cli1));
+
+        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;
         }
@@ -3628 +3794 @@
         }
 
-        if (!*oplock4_shared_correct) {
+        if (!got_break) {
                 correct = false;
         }
@@ -3637 +3803 @@
 }
 
+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;
+        }
+}
 
 /*
@@ -3648 +3851 @@
         uint16_t fnum1 = (uint16_t)-1;
         uint16_t fnum2 = (uint16_t)-1;
-        bool correct = True;
+        bool correct = false;
+        NTSTATUS status;
 
         printf("starting delete test\n");
@@ -3656 +3860 @@
         }
 
-        cli_sockopt(cli1, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
 
         /* Test 1 - this should delete the file on close. */
@@ -3663 +3867 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
-                                   0, FILE_OVERWRITE_IF, 
-                                   FILE_DELETE_ON_CLOSE, 0, &fnum1))) {
-                printf("[1] open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[1] close failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("[1] close failed (%s)\n", nt_errstr(status));
                 goto fail;
         }
 
-        if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR, DENY_NONE, &fnum1))) {
+        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);
-                correct = False;
                 goto fail;
         }
@@ -3690 +3894 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS,
-                                   FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, 
-                                   FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("[2] open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
-                printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[2] close failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("[2] close failed (%s)\n", nt_errstr(status));
                 goto fail;
         }
 
-        if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
+        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);
-                if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                        printf("[2] close failed (%s)\n", cli_errstr(cli1));
-                        correct = False;
-                        goto fail;
+                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);
-        } else
-                printf("second delete on close test succeeded.\n");
+                goto fail;
+        }
+
+        printf("second delete on close test succeeded.\n");
 
         /* Test 3 - ... */
@@ -3725 +3931 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("[3] open - 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
@@ -3735 +3943 @@
            with SHARE_DELETE. */
 
-        if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
-                        FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0, 0, &fnum2))) {
+        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);
-                correct = False;
                 goto fail;
         }
 
         /* This should succeed. */
-
-        if (!NT_STATUS_IS_OK(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))) {
-                printf("[3] open  - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
-                printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[3] close 1 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("[3] close 1 failed (%s)\n", nt_errstr(status));
                 goto fail;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
-                printf("[3] close 2 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        status = cli_close(cli1, fnum2);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("[3] close 2 failed (%s)\n", nt_errstr(status));
                 goto fail;
         }
@@ -3771 +3982 @@
         /* This should fail - file should no longer be there. */
 
-        if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
+        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);
-                if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                        printf("[3] close failed (%s)\n", cli_errstr(cli1));
+                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);
-                correct = False;
                 goto fail;
-        } else
-                printf("third delete on close test succeeded.\n");
+        }
+
+        printf("third delete on close test succeeded.\n");
 
         /* Test 4 ... */
@@ -3786 +3999 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(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))) {
-                printf("[4] open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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. */
-        if (!NT_STATUS_IS_OK(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))) {
-                printf("[4] open  - 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum2))) {
-                printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        status = cli_close(cli1, fnum2);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("[4] close - 1 failed (%s)\n", nt_errstr(status));
                 goto fail;
         }
 
-        if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
-                printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        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. */
-        if (NT_STATUS_IS_OK(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))) {
+        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 );
-                correct = False;
                 goto fail;
-        } else
-                printf("fourth delete on close test succeeded.\n");
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        }
+
+        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 ... */
@@ -3833 +4053 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum1))) {
-                printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
@@ -3841 +4061 @@
         /* This should fail - only allowed on NT opens with DELETE access. */
 
-        if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
+        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");
-                correct = False;
                 goto fail;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("[5] close failed (%s)\n", nt_errstr(status));
                 goto fail;
         }
@@ -3859 +4079 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(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))) {
-                printf("[6] open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
@@ -3869 +4091 @@
         /* This should fail - only allowed on NT opens with DELETE access. */
 
-        if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
+        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");
-                correct = False;
                 goto fail;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("[6] close failed (%s)\n", nt_errstr(status));
                 goto fail;
         }
@@ -3887 +4109 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
-                                   FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("[7] open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
+        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");
-                correct = False;
                 goto fail;
         }
 
-        if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, false))) {
+        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");
-                correct = False;
                 goto fail;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        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. */
-
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
-                printf("[5] open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("[7] close - 2 failed (%s)\n", nt_errstr(status));
                 goto fail;
         }
@@ -3928 +4151 @@
         printf("seventh delete on close test succeeded.\n");
 
-        /* Test 7 ... */
+        /* Test 8 ... */
         cli_setatr(cli1, fname, 0, 0);
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
@@ -3934 +4157 @@
         if (!torture_open_connection(&cli2, 1)) {
                 printf("[8] failed to open second connection.\n");
-                correct = False;
                 goto fail;
         }
 
-        cli_sockopt(cli1, sockops);
-
-        if (!NT_STATUS_IS_OK(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))) {
-                printf("[8] open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(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))) {
-                printf("[8] open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
+        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");
-                correct = False;
                 goto fail;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("[8] close - 1 failed (%s)\n", nt_errstr(status));
                 goto fail;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
-                printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2));
-                correct = False;
+        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.. */
-        if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
+        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;
-                correct = False;
-        } else
-                printf("eighth delete on close test succeeded.\n");
+        }
+
+        printf("eighth delete on close test succeeded.\n");
+
+        /* Test 9 ... */
 
         /* This should fail - we need to set DELETE_ACCESS. */
-        if (NT_STATUS_IS_OK(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))) {
+        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);
-                correct = False;
                 goto fail;
         }
@@ -3992 +4224 @@
         printf("ninth delete on close test succeeded.\n");
 
-        if (!NT_STATUS_IS_OK(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))) {
-                printf("[10] open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        /* 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. */
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[10] close failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        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.. */
-        if (NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_NONE, &fnum1))) {
+        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;
-                correct = False;
-        } else
-                printf("tenth delete on close test succeeded.\n");
+        }
+
+        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);
 
-        /* What error do we get when attempting to open a read-only file with
-           delete access ? */
+        /* Can we open a read-only file with delete access? */
 
         /* Create a readonly file. */
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA,
-                                   FILE_ATTRIBUTE_READONLY, FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("[11] open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                correct = False;
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("[11] close failed (%s)\n", cli_errstr(cli1));
-                correct = False;
+        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. */
-        if (NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES|DELETE_ACCESS,
-                                   0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
-                                   FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("[11] open of %s succeeded should have been denied with ACCESS_DENIED!\n", fname);
-                cli_close(cli1, fnum1);
+        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;
-                correct = False;
-        } else {
-                NTSTATUS nterr = cli_nt_error(cli1);
-                if (!NT_STATUS_EQUAL(nterr,NT_STATUS_ACCESS_DENIED)) {
-                        printf("[11] open of %s should have been denied with ACCESS_DENIED! Got error %s\n", fname, nt_errstr(nterr));
-                        goto fail;
-                        correct = False;
-                } else {
-                        printf("eleventh delete on close test succeeded.\n");
-                }
-        }
+        }
+
+        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:
@@ -4070 +4406 @@
         if (cli2 && !torture_close_connection(cli2)) {
                 correct = False;
+        }
+        return correct;
+}
+
+
+/*
+  Test wildcard delete.
+ */
+static bool run_wild_deletetest(int dummy)
+{
+        struct cli_state *cli = NULL;
+        const char *dname = "\\WTEST";
+        const char *fname = "\\WTEST\\A";
+        const char *wunlink_name = "\\WTEST\\*";
+        uint16_t fnum1 = (uint16_t)-1;
+        bool correct = false;
+        NTSTATUS status;
+
+        printf("starting wildcard delete test\n");
+
+        if (!torture_open_connection(&cli, 0)) {
+                return false;
+        }
+
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
+
+        cli_unlink(cli, fname, 0);
+        cli_rmdir(cli, dname);
+        status = cli_mkdir(cli, dname);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("mkdir of %s failed %s!\n", dname, nt_errstr(status));
+                goto fail;
+        }
+        status = cli_openx(cli, fname, O_CREAT|O_RDONLY, DENY_NONE, &fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("open of %s failed %s!\n", fname, nt_errstr(status));
+                goto fail;
+        }
+        status = cli_close(cli, fnum1);
+        fnum1 = -1;
+
+        /*
+         * Note the unlink attribute-type of zero. This should
+         * map into FILE_ATTRIBUTE_NORMAL at the server even
+         * on a wildcard delete.
+         */
+
+        status = cli_unlink(cli, wunlink_name, 0);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("unlink of %s failed %s!\n",
+                        wunlink_name, nt_errstr(status));
+                goto fail;
+        }
+
+        printf("finished wildcard delete test\n");
+
+        correct = true;
+
+  fail:
+
+        if (fnum1 != (uint16_t)-1) cli_close(cli, fnum1);
+        cli_unlink(cli, fname, 0);
+        cli_rmdir(cli, dname);
+
+        if (cli && !torture_close_connection(cli)) {
+                correct = false;
         }
         return correct;
@@ -4094 +4496 @@
         cli_unlink(cli, fname_ln, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         /* Create the file. */
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
-                return false;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum))) {
-                printf("close1 failed (%s)\n", cli_errstr(cli));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_nt_hardlink(cli, fname, fname_ln))) {
-                printf("nt hardlink failed (%s)\n", cli_errstr(cli));
+        status = cli_nt_hardlink(cli, fname, fname_ln);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("nt hardlink failed (%s)\n", nt_errstr(status));
                 return false;
         }
@@ -4117 +4522 @@
                         FILE_ATTRIBUTE_NORMAL,
                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
-                        FILE_OPEN_IF, 0, 0, &fnum);
+                        FILE_OPEN_IF, 0, 0, &fnum, NULL);
         if (!NT_STATUS_IS_OK(status)) {
                 printf("ntcreate of %s failed (%s)\n", fname, nt_errstr(status));
@@ -4127 +4532 @@
                         FILE_ATTRIBUTE_NORMAL,
                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
-                        FILE_OPEN_IF, 0, 0, &fnum1);
+                        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));
@@ -4201 +4606 @@
         }
 
-        cli_sockopt(cli, sockops);
-
-        d_printf("Capabilities 0x%08x\n", cli->capabilities);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
+
+        d_printf("Capabilities 0x%08x\n", smb1cli_conn_capabilities(cli->conn));
 
         if (!torture_close_connection(cli)) {
@@ -4242 +4647 @@
         bool correct = True;
         uint16_t fnum1, fnum2;
+        NTSTATUS status;
 
         printf("starting xcopy test\n");
@@ -4249 +4655 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
-                                   FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 
-                                   0x4044, 0, &fnum1))) {
-                printf("First open failed - %s\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0,
-                                   SECOND_DESIRED_ACCESS, 0,
-                                   FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, 
-                                   0x200000, 0, &fnum2))) {
-                printf("second open failed - %s\n", cli_errstr(cli1));
+        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;
         }
@@ -4293 +4699 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_READ, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("First open failed - %s\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
-                printf("First rename failed (SHARE_READ) (this is correct) - %s\n", cli_errstr(cli1));
+
+        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);
+        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");
@@ -4306 +4716 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close - 1 failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close - 1 failed (%s)\n", nt_errstr(status));
                 return False;
         }
@@ -4319 +4730 @@
                               FILE_SHARE_DELETE|FILE_SHARE_READ,
 #endif
-                              FILE_OVERWRITE_IF, 0, 0, &fnum1);
-        if (!NT_STATUS_IS_OK(status)) {
-                printf("Second open failed - %s\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
-                printf("Second rename failed (SHARE_DELETE | SHARE_READ) - this should have succeeded - %s\n", cli_errstr(cli1));
+                              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);
+        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 {
@@ -4332 +4744 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close - 2 failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close - 2 failed (%s)\n", nt_errstr(status));
                 return False;
         }
@@ -4340 +4753 @@
         cli_unlink(cli1, fname1, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, READ_CONTROL_ACCESS, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("Third open failed - %s\n", cli_errstr(cli1));
+        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;
         }
@@ -4352 +4767 @@
 
         if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2))) {
+                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum2, NULL))) {
                 printf("Fourth open failed - %s\n", cli_errstr(cli1));
                 return False;
@@ -4368 +4783 @@
 #endif
 
-        if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
-                printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", cli_errstr(cli1));
+        status = cli_rename(cli1, fname, fname1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("Third rename failed (SHARE_NONE) - this should have succeeded - %s\n", nt_errstr(status));
                 correct = False;
         } else {
@@ -4375 +4791 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close - 3 failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close - 3 failed (%s)\n", nt_errstr(status));
                 return False;
         }
@@ -4385 +4802 @@
         /*----*/
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, GENERIC_READ_ACCESS, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("Fourth open failed - %s\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
-                printf("Fourth rename failed (SHARE_READ | SHARE_WRITE) (this is correct) - %s\n", cli_errstr(cli1));
+        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);
+        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");
@@ -4398 +4819 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close - 4 failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close - 4 failed (%s)\n", nt_errstr(status));
                 return False;
         }
@@ -4408 +4830 @@
         /*--*/
 
-        if (!NT_STATUS_IS_OK(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))) {
-                printf("Fifth open failed - %s\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_rename(cli1, fname, fname1))) {
-                printf("Fifth rename failed (SHARE_READ | SHARE_WRITE | SHARE_DELETE) - this should have succeeded - %s ! \n",
-                        cli_errstr(cli1));
+        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);
+        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", cli_errstr(cli1));
+                printf("Fifth rename succeeded (SHARE_READ | SHARE_WRITE | SHARE_DELETE) (this is correct) - %s\n", nt_errstr(status));
         }
 
@@ -4427 +4852 @@
 
         /* if (!NT_STATUS_OP(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, &fnum2))) {
+                                   FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                   FILE_OVERWRITE_IF, 0, 0, &fnum2, NULL))) {
           printf("Opening original file after rename of open file fails: %s\n",
               cli_errstr(cli1));
@@ -4437 +4863 @@
 
         /*--*/
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close - 5 failed (%s)\n", cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname1, &attr, NULL, NULL))) {
+        status = cli_getatr(cli1, fname1, &attr, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
                 printf("getatr on file %s failed - %s ! \n",
-                        fname1,
-                        cli_errstr(cli1));
+                        fname1, nt_errstr(status));
                 correct = False;
         } else {
@@ -4477 +4904 @@
         uint16_t fnum;
         int num_pipes = 0;
+        NTSTATUS status;
 
         printf("starting pipenumber test\n");
@@ -4483 +4911 @@
         }
 
-        cli_sockopt(cli1, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
         while(1) {
-                if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, pipe_name, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF, 0, 0, &fnum))) {
-                        printf("Open of pipe %s failed with error (%s)\n", pipe_name, cli_errstr(cli1));
+                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;
                 }
@@ -4509 +4940 @@
         uint16_t fnum1, fnum2;
         char buf[20];
-        SMB_OFF_T fsize;
+        off_t fsize;
         bool correct = True;
         char *tmp_path;
@@ -4523 +4954 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        cli_sockopt(cli1, sockops);
-
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close2 failed (%s)\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_setatr(cli1, fname, FILE_ATTRIBUTE_READONLY, 0))) {
-                printf("cli_setatr failed (%s)\n", cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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. */
-        cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
-
-        if (check_error(__LINE__, cli1, ERRDOS, ERRnoaccess, 
+        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");
@@ -4561 +4996 @@
         cli_setatr(cli1, fname, 0, 0);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY, DENY_WRITE, &fnum1))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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. */
-        cli_open(cli1, fname, O_RDWR, DENY_ALL, &fnum2);
-
-        if (check_error(__LINE__, cli1, ERRDOS, ERRbadshare, 
+        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");
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close2 failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close2 failed (%s)\n", nt_errstr(status));
                 return False;
         }
@@ -4584 +5021 @@
 
         /* Test truncate open disposition on file opened for read. */
-
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum1))) {
-                printf("(3) open (1) of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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;
         }
@@ -4600 +5037 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("(3) close1 failed (%s)\n", cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
-                printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
+        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;
         }
@@ -4617 +5056 @@
 
         /* Now test if we can truncate a file opened for readonly. */
-
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDONLY|O_TRUNC, DENY_NONE, &fnum1))) {
-                printf("(3) open (2) of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close2 failed (%s)\n", cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, NULL, &fsize, NULL))) {
-                printf("(3) getatr failed (%s)\n", cli_errstr(cli1));
+        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;
         }
@@ -4643 +5084 @@
 
         printf("Do ctemp tests\n");
-        if (!NT_STATUS_IS_OK(cli_ctemp(cli1, talloc_tos(), "\\", &fnum1, &tmp_path))) {
-                printf("ctemp failed (%s)\n", cli_errstr(cli1));
-                return False;
-        }
+        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);
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close of temp failed (%s)\n", cli_errstr(cli1));
-        }
-        if (!NT_STATUS_IS_OK(cli_unlink(cli1, tmp_path, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
-                printf("unlink of temp failed (%s)\n", cli_errstr(cli1));
+        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));
         }
 
@@ -4664 +5110 @@
         cli_unlink(cli2, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        cli_sockopt(cli2, sockops);
+        smbXcli_conn_set_sockopt(cli2->conn, sockops);
 
         printf("TEST #1 testing 2 non-io opens (no delete)\n");
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("TEST #1 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
-                printf("TEST #1 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("TEST #1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-        if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
-                printf("TEST #1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
+        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;
         }
@@ -4695 +5147 @@
         printf("TEST #2 testing 2 non-io opens (first with delete)\n");
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("TEST #2 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
-                printf("TEST #2 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("TEST #2 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-        if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
-                printf("TEST #2 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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;
         }
@@ -4722 +5182 @@
         printf("TEST #3 testing 2 non-io opens (second with delete)\n");
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("TEST #3 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
-                printf("TEST #3 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("TEST #3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-        if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
-                printf("TEST #3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
+        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;
         }
@@ -4749 +5217 @@
         printf("TEST #4 testing 2 non-io opens (both with delete)\n");
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("TEST #4 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum2))) {
-                printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
-                return False;
-        }
-
-        printf("TEST #4 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("TEST #4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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;
         }
@@ -4774 +5249 @@
         printf("TEST #5 testing 2 non-io opens (both with delete - both with file share delete)\n");
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_DELETE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("TEST #5 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, DELETE_ACCESS|FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_DELETE, FILE_OPEN_IF, 0, 0, &fnum2))) {
-                printf("TEST #5 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("TEST #5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
-                printf("TEST #5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
+        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;
         }
@@ -4802 +5285 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("TEST #6 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli2, fname, 0, FILE_READ_ATTRIBUTES, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_READ, FILE_OPEN_IF, 0, 0, &fnum2))) {
-                printf("TEST #6 open 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("TEST #6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(cli2, fnum2))) {
-                printf("TEST #6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
+        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;
         }
@@ -4830 +5319 @@
         cli_unlink(cli1, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                printf("TEST #7 open 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
-                return False;
-        }
-
-        if (NT_STATUS_IS_OK(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))) {
-                printf("TEST #7 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
-                return False;
-        }
-
-        printf("TEST #7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
-
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("TEST #7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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;
         }
@@ -4856 +5352 @@
         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);
+                                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));
@@ -4864 +5360 @@
 
         /* Write to ensure we have to update the file time. */
-        status = cli_writeall(cli1, fnum1, 0, (uint8_t *)"TEST DATA\n", 0, 10,
+        status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
                               NULL);
         if (!NT_STATUS_IS_OK(status)) {
@@ -4892 +5388 @@
 NTSTATUS torture_setup_unix_extensions(struct cli_state *cli)
 {
-        uint16 major, minor;
-        uint32 caplow, caphigh;
+        uint16_t major, minor;
+        uint32_t caplow, caphigh;
         NTSTATUS status;
 
@@ -4936 +5432 @@
         bool correct = false;
         NTSTATUS status;
+        size_t nread;
+        const char *fname_windows = "windows_file";
+        uint16_t fnum2 = (uint16_t)-1;
 
         printf("Starting simple POSIX open test\n");
@@ -4943 +5442 @@
         }
 
-        cli_sockopt(cli1, sockops);
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
 
         status = torture_setup_unix_extensions(cli1);
@@ -4958 +5457 @@
         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. */
-        if (!NT_STATUS_IS_OK(cli_posix_mkdir(cli1, dname, 0777))) {
-                printf("POSIX mkdir of %s failed (%s)\n", dname, cli_errstr(cli1));
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
-                printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 1000))) {
-                printf("ftruncate failed (%s)\n", cli_errstr(cli1));
+        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 */
-        if (!NT_STATUS_IS_OK(cli_posix_stat(cli1, fname, &sbuf))) {
-                printf("stat failed (%s)\n", cli_errstr(cli1));
+        status = cli_posix_stat(cli1, fname, &sbuf);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("stat failed (%s)\n", nt_errstr(status));
                 goto out;
         }
@@ -4987 +5493 @@
         }
 
+        /* 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. */
-        if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 0))) {
-                printf("ftruncate failed (%s)\n", cli_errstr(cli1));
+        status = cli_ftruncate(cli1, fnum1, 0);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("ftruncate failed (%s)\n", nt_errstr(status));
                 goto out;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close failed (%s)\n", cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
-                printf("POSIX open of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_posix_unlink(cli1, fname))) {
-                printf("POSIX unlink of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close(2) failed (%s)\n", cli_errstr(cli1));
+        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. */
-        if (NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDONLY, 0, &fnum1))) {
+        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;
@@ -5022 +5541 @@
 
         /* Create again to test open with O_TRUNC. */
-        if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
-                printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_ftruncate(cli1, fnum1, 1000))) {
-                printf("ftruncate failed (%s)\n", cli_errstr(cli1));
+        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 */
-        if (!NT_STATUS_IS_OK(cli_posix_stat(cli1, fname, &sbuf))) {
-                printf("stat failed (%s)\n", cli_errstr(cli1));
+        status = cli_posix_stat(cli1, fname, &sbuf);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("stat failed (%s)\n", nt_errstr(status));
                 goto out;
         }
@@ -5044 +5566 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close(2) failed (%s)\n", cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_WRONLY|O_TRUNC, 0600, &fnum1))) {
-                printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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 */
-        if (!NT_STATUS_IS_OK(cli_posix_stat(cli1, fname, &sbuf))) {
-                printf("stat failed (%s)\n", cli_errstr(cli1));
+        status = cli_posix_stat(cli1, fname, &sbuf);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("stat failed (%s)\n", nt_errstr(status));
                 goto out;
         }
@@ -5066 +5591 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                printf("close failed (%s)\n", cli_errstr(cli1));
+        status = cli_close(cli1, fnum1);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("close failed (%s)\n", nt_errstr(status));
                 goto out;
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_unlink(cli1, fname))) {
-                printf("POSIX unlink of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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;
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1))) {
+        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, cli_errstr(cli1));
+                        dname, nt_errstr(status));
                 goto out;
         }
@@ -5085 +5613 @@
 
         /* What happens when we try and POSIX open a directory for write ? */
-        if (NT_STATUS_IS_OK(cli_posix_open(cli1, dname, O_RDWR, 0, &fnum1))) {
+        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", fname);
                 goto out;
         } else {
-                if (!check_error(__LINE__, cli1, ERRDOS, EISDIR,
+                if (!check_both_error(__LINE__, status, ERRDOS, EISDIR,
                                 NT_STATUS_FILE_IS_A_DIRECTORY)) {
                         goto out;
@@ -5096 +5625 @@
 
         /* Create the file. */
-        if (!NT_STATUS_IS_OK(cli_posix_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, 0600, &fnum1))) {
-                printf("POSIX create of %s failed (%s)\n", fname, cli_errstr(cli1));
+        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, (uint8_t *)"TEST DATA\n", 0, 10,
+        status = cli_writeall(cli1, fnum1, 0, (const uint8_t *)"TEST DATA\n", 0, 10,
                               NULL);
         if (!NT_STATUS_IS_OK(status)) {
@@ -5112 +5643 @@
 
         /* Now create a hardlink. */
-        if (!NT_STATUS_IS_OK(cli_posix_hardlink(cli1, fname, hname))) {
-                printf("POSIX hardlink of %s failed (%s)\n", hname, cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_posix_symlink(cli1, fname, sname))) {
-                printf("POSIX symlink of %s failed (%s)\n", sname, cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_posix_open(cli1, hname, O_RDONLY, 0, &fnum1))) {
-                printf("POSIX open of %s failed (%s)\n", hname, cli_errstr(cli1));
+        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;
         }
 
-        if (cli_read(cli1, fnum1, buf, 0, 10) != 10) {
-                printf("POSIX read of %s failed (%s)\n", hname, cli_errstr(cli1));
+        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;
         }
@@ -5140 +5680 @@
 
         /* Do a POSIX lock/unlock. */
-        if (!NT_STATUS_IS_OK(cli_posix_lock(cli1, fnum1, 0, 100, true, READ_LOCK))) {
-                printf("POSIX lock failed %s\n", cli_errstr(cli1));
+        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. */
-        if (!NT_STATUS_IS_OK(cli_posix_unlock(cli1, fnum1, 10, 80))) {
-                printf("POSIX unlock failed %s\n", cli_errstr(cli1));
+        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;
         }
@@ -5155 +5697 @@
         /* Open the symlink for read - this should fail. A POSIX
            client should not be doing opens on a symlink. */
-        if (NT_STATUS_IS_OK(cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1))) {
+        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;
         } else {
-                if (!check_error(__LINE__, cli1, ERRDOS, ERRbadpath,
+                if (!check_both_error(__LINE__, status, ERRDOS, ERRbadpath,
                                 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
                         printf("POSIX open of %s should have failed "
                                 "with NT_STATUS_OBJECT_PATH_NOT_FOUND, "
                                 "failed with %s instead.\n",
-                                sname, cli_errstr(cli1));
+                                sname, nt_errstr(status));
                         goto out;
                 }
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf)))) {
-                printf("POSIX readlink on %s failed (%s)\n", sname, cli_errstr(cli1));
+        status = cli_posix_readlink(cli1, sname, namebuf, sizeof(namebuf));
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("POSIX readlink on %s failed (%s)\n", sname, nt_errstr(status));
                 goto out;
         }
@@ -5180 +5724 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_rmdir(cli1, dname))) {
-                printf("POSIX rmdir failed (%s)\n", cli_errstr(cli1));
+        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");
@@ -5193 +5791 @@
                 cli_close(cli1, fnum1);
                 fnum1 = (uint16_t)-1;
+        }
+
+        if (fnum2 != (uint16_t)-1) {
+                cli_close(cli1, fnum2);
+                fnum2 = (uint16_t)-1;
         }
 
@@ -5203 +5806 @@
         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)) {
@@ -5211 +5816 @@
 }
 
-
-static uint32 open_attrs_table[] = {
+/*
+  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;
+        struct security_descriptor *sd_sym = 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. */
+        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("cli_posix_open of %s failed (%s)\n",
+                        sname,
+                        nt_errstr(status));
+                goto out;
+        }
+
+        /* Get the Windows ACL on the symlink handle. Should fail */
+        status = cli_query_secdesc(cli,
+                                fnum,
+                                frame,
+                                &sd_sym);
+
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
+                printf("cli_query_secdesc on a symlink gave %s. "
+                        "Should be NT_STATUS_ACCESS_DENIED.\n",
+                        nt_errstr(status));
+                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 Windows ACL on the symlink handle. Should fail */
+        status = cli_set_security_descriptor(cli,
+                                fnum,
+                                SECINFO_DACL,
+                                sd);
+
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
+                printf("cli_query_secdesc 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_getacl 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 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; i<num_eas; i++) {
+                if (strcmp(eas[i].name, ea_name) == 0 &&
+                                eas[i].value.length == strlen(ea_value)+1 &&
+                                memcmp(eas[i].value.data,
+                                        ea_value,
+                                        eas[i].value.length) == 0) {
+                        break;
+                }
+        }
+
+        if (i == num_eas) {
+                printf("Didn't find EA on pathname %s\n",
+                        fname);
+                goto out;
+        }
+
+        num_eas = 0;
+        TALLOC_FREE(eas);
+
+        /* Get the EA list on the symlink. Should return empty list. */
+        status = cli_get_ea_list_path(cli,
+                                sname,
+                                frame,
+                                &num_eas,
+                                &eas);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("cli_get_ea_list_path failed (%s)\n",
+                        nt_errstr(status));
+                goto out;
+        }
+
+        if (num_eas != 0) {
+                printf("cli_get_ea_list_path failed (%s)\n",
+                        nt_errstr(status));
+                goto out;
+        }
+
+        /* Set an EA on the symlink. Should fail. */
+        status = cli_set_ea_path(cli,
+                                sname,
+                                ea_name,
+                                ea_value,
+                                strlen(ea_value)+1);
+
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
+                printf("cli_set_ea_path on a symlink gave %s. "
+                        "Should be NT_STATUS_ACCESS_DENIED.\n",
+                        nt_errstr(status));
+                goto out;
+        }
+
+        printf("EA 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;
+}
+
+static uint32_t open_attrs_table[] = {
                 FILE_ATTRIBUTE_NORMAL,
                 FILE_ATTRIBUTE_ARCHIVE,
@@ -5234 +6213 @@
 struct trunc_open_results {
         unsigned int num;
-        uint32 init_attr;
-        uint32 trunc_attr;
-        uint32 result_attr;
+        uint32_t init_attr;
+        uint32_t trunc_attr;
+        uint32_t result_attr;
 };
 
@@ -5274 +6253 @@
         uint16_t fnum1;
         bool correct = True;
-        uint16 attr;
+        uint16_t attr;
         unsigned int i, j, k, l;
+        NTSTATUS status;
 
         printf("starting open attr test\n");
@@ -5283 +6263 @@
         }
 
-        cli_sockopt(cli1, sockops);
-
-        for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32); i++) {
+        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);
-                if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_WRITE_DATA, open_attrs_table[i],
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 0, 0, &fnum1))) {
-                        printf("open %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
+
+                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;
                 }
 
-                if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                        printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1));
+                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); j++) {
-                        if (!NT_STATUS_IS_OK(cli_ntcreate(cli1, fname, 0, FILE_READ_DATA|FILE_WRITE_DATA, open_attrs_table[j],
-                                           FILE_SHARE_NONE, FILE_OVERWRITE, 0, 0, &fnum1))) {
+                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) {
@@ -5307 +6295 @@
                                                                 k, open_attrs_table[i],
                                                                 open_attrs_table[j],
-                                                                fname, NT_STATUS_V(cli_nt_error(cli1)), cli_errstr(cli1));
+                                                                fname, NT_STATUS_V(status), nt_errstr(status));
                                                 correct = False;
                                         }
                                 }
-                                if (NT_STATUS_V(cli_nt_error(cli1)) != NT_STATUS_V(NT_STATUS_ACCESS_DENIED)) {
+
+                                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],
-                                                        cli_errstr(cli1));
+                                                        nt_errstr(status));
                                         correct = False;
                                 }
@@ -5324 +6313 @@
                         }
 
-                        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
-                                printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1));
+                        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;
                         }
 
-                        if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname, &attr, NULL, NULL))) {
-                                printf("getatr(2) failed (%s)\n", cli_errstr(cli1));
+                        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;
                         }
@@ -5397 +6388 @@
         }
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         srandom(0);
@@ -5403 +6394 @@
                 fstring fname;
                 slprintf(fname, sizeof(fname), "\\%x", (int)random());
-                if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
+                if (!NT_STATUS_IS_OK(cli_openx(cli, fname, O_RDWR|O_CREAT, DENY_NONE, &fnum))) {
                         fprintf(stderr,"Failed to open %s\n", fname);
                         return False;
@@ -5483 +6474 @@
         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
-                printf("open of %s failed (%s)\n", fname, cli_errstr(cli));
+        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;
         }
@@ -5497 +6489 @@
                 printf("ioctl test with device = 0x%x\n", device);
                 for (function=0;function<0x100;function++) {
-                        uint32 code = (device<<16) | function;
+                        uint32_t code = (device<<16) | function;
 
                         status = cli_raw_ioctl(cli, fnum, code, &blob);
@@ -5525 +6517 @@
         uint16_t fnum;
         bool ret;
+        NTSTATUS status;
 
         if (!torture_open_connection(&cli, 0)) {
@@ -5537 +6530 @@
         cli_rmdir(cli, "\\chkpath.dir");
 
-        if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir"))) {
-                printf("mkdir1 failed : %s\n", cli_errstr(cli));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\chkpath.dir\\dir2"))) {
-                printf("mkdir2 failed : %s\n", cli_errstr(cli));
-                return False;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_open(cli, "\\chkpath.dir\\foo.txt", O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
-                printf("open1 failed (%s)\n", cli_errstr(cli));
+        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);
 
-        if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir"))) {
-                printf("chkpath1 failed: %s\n", cli_errstr(cli));
+        status = cli_chkpath(cli, "\\chkpath.dir");
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("chkpath1 failed: %s\n", nt_errstr(status));
                 ret = False;
         }
 
-        if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dir2"))) {
-                printf("chkpath2 failed: %s\n", cli_errstr(cli));
+        status = cli_chkpath(cli, "\\chkpath.dir\\dir2");
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("chkpath2 failed: %s\n", nt_errstr(status));
                 ret = False;
         }
 
-        if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\foo.txt"))) {
-                ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath, 
+        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 {
@@ -5571 +6571 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\bar.txt"))) {
-                ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile, 
+        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 existant file should fail\n");
+                printf("* chkpath on a non existent file should fail\n");
                 ret = False;
         }
 
-        if (!NT_STATUS_IS_OK(cli_chkpath(cli, "\\chkpath.dir\\dirxx\\bar.txt"))) {
-                ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath, 
+        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 {
@@ -5618 +6620 @@
 
         cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0,
-                                   FIRST_DESIRED_ACCESS, FILE_ATTRIBUTE_ARCHIVE,
-                                   FILE_SHARE_NONE, FILE_OVERWRITE_IF, 
-                                   0x4044, 0, &fnum))) {
-                printf("open failed - %s\n", cli_errstr(cli));
+
+        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;
@@ -5712 +6716 @@
         }
 
-        /* Try and delete a non existant EA. */
+        /* 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-existant EA 'foo' should succeed. %s\n",
+                printf("deleting non-existent EA 'foo' should succeed. %s\n",
                        nt_errstr(status));
                 correct = False;
@@ -5742 +6746 @@
         }
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         cli_list(cli, "\\LISTDIR\\*", 0, del_fn, cli);
@@ -5754 +6758 @@
                 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))) {
+                                   FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF,
+                                   0, 0, &fnum, NULL))) {
                         fprintf(stderr,"Failed to open %s\n", fname);
                         return False;
@@ -5818 +6823 @@
         NTSTATUS status;
 
-        uint32 error;
-
-        uint32 flgs2, errnum;
-        uint8 errclass;
+        uint32_t error;
+
+        uint32_t errnum;
+        uint8_t errclass;
 
         NTSTATUS nt_status;
@@ -5829 +6834 @@
         /* NT-Error connection */
 
+        disable_spnego = true;
         if (!(c_nt = open_nbt_connection())) {
-                return False;
-        }
-
-        c_nt->use_spnego = False;
-
-        status = cli_negprot(c_nt);
+                disable_spnego = false;
+                return False;
+        }
+        disable_spnego = false;
+
+        status = smbXcli_negprot(c_nt->conn, c_nt->timeout, PROTOCOL_CORE,
+                                 PROTOCOL_NT1);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -5844 +6851 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_session_setup(c_nt, "", "", 0, "", 0,
-                                               workgroup))) {
-                printf("%s rejected the NT-error initial session setup (%s)\n",host, cli_errstr(c_nt));
+        status = cli_session_setup(c_nt, "", "", 0, "", 0, workgroup);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("%s rejected the NT-error initial session setup (%s)\n",host, nt_errstr(status));
                 return False;
         }
@@ -5852 +6859 @@
         /* DOS-Error connection */
 
+        disable_spnego = true;
+        force_dos_errors = true;
         if (!(c_dos = open_nbt_connection())) {
-                return False;
-        }
-
-        c_dos->use_spnego = False;
-        c_dos->force_dos_errors = True;
-
-        status = cli_negprot(c_dos);
+                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);
         if (!NT_STATUS_IS_OK(status)) {
                 printf("%s rejected the DOS-error negprot (%s)\n", host,
@@ -5867 +6878 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_session_setup(c_dos, "", "", 0, "", 0,
-                                               workgroup))) {
-                printf("%s rejected the DOS-error initial session setup (%s)\n",host, cli_errstr(c_dos));
-                return False;
-        }
+        status = cli_session_setup(c_dos, "", "", 0, "", 0, workgroup);
+        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++) {
                 fstr_sprintf(user, "%X", error);
 
-                if (NT_STATUS_IS_OK(cli_session_setup(c_nt, user, 
-                                                      password, strlen(password),
-                                                      password, strlen(password),
-                                                      workgroup))) {
+                status = cli_session_setup(c_nt, user,
+                                           password, strlen(password),
+                                           password, strlen(password),
+                                           workgroup);
+                if (NT_STATUS_IS_OK(status)) {
                         printf("/** Session setup succeeded.  This shouldn't happen...*/\n");
                 }
 
-                flgs2 = SVAL(c_nt->inbuf,smb_flg2);
-
                 /* Case #1: 32-bit NT errors */
-                if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
-                        nt_status = NT_STATUS(IVAL(c_nt->inbuf,smb_rcls));
+                if (!NT_STATUS_IS_DOS(status)) {
+                        nt_status = status;
                 } else {
                         printf("/** Dos error on NT connection! (%s) */\n", 
-                               cli_errstr(c_nt));
+                               nt_errstr(status));
                         nt_status = NT_STATUS(0xc0000000);
                 }
 
-                if (NT_STATUS_IS_OK(cli_session_setup(c_dos, user, 
-                                                      password, strlen(password),
-                                                      password, strlen(password),
-                                                      workgroup))) {
+                status = cli_session_setup(c_dos, user,
+                                           password, strlen(password),
+                                           password, strlen(password),
+                                           workgroup);
+                if (NT_STATUS_IS_OK(status)) {
                         printf("/** Session setup succeeded.  This shouldn't happen...*/\n");
                 }
-                flgs2 = SVAL(c_dos->inbuf,smb_flg2), errnum;
 
                 /* Case #1: 32-bit NT errors */
-                if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
+                if (NT_STATUS_IS_DOS(status)) {
                         printf("/** NT error on DOS connection! (%s) */\n", 
-                               cli_errstr(c_nt));
+                               nt_errstr(status));
                         errnum = errclass = 0;
                 } else {
-                        cli_dos_error(c_dos, &errclass, &errnum);
+                        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(NT_STATUS(error)), 
-                               get_nt_error_c_code(nt_status));
+                               get_nt_error_c_code(talloc_tos(), NT_STATUS(error)), 
+                               get_nt_error_c_code(talloc_tos(), nt_status));
                 }
 
@@ -5920 +6935 @@
                        smb_dos_err_class(errclass), 
                        smb_dos_err_name(errclass, errnum), 
-                       get_nt_error_c_code(NT_STATUS(error)));
+                       get_nt_error_c_code(talloc_tos(), NT_STATUS(error)));
         }
         return True;
@@ -5937 +6952 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(
-                        c, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
-                        FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF,
-                        FILE_DELETE_ON_CLOSE, 0, &fnum))) {
-                d_printf("open %s failed: %s\n", fname, cli_errstr(c));
+        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;
         }
@@ -5957 +6972 @@
                 }
 
-                d_printf("\r%d   ", (int)c->vuid);
+                d_printf("\r%d   ", (int)cli_state_get_uid(c));
 
                 status = cli_ulogoff(c);
@@ -5965 +6980 @@
                         return false;
                 }
-                c->vuid = 0;
         }
 
@@ -5977 +6991 @@
         bool result = true;
 
-        subst = talloc_sub_specified(talloc_tos(), str, user, domain, uid, gid);
+        subst = talloc_sub_specified(talloc_tos(), str, user, NULL, domain, uid, gid);
 
         if (strcmp(subst, expected) != 0) {
@@ -5994 +7008 @@
         uint16_t fnum;
         NTSTATUS status;
-        status = cli_open_recv(req, &fnum);
+        status = cli_openx_recv(req, &fnum);
         TALLOC_FREE(req);
 
-        d_printf("cli_open_recv returned %s: %d\n",
+        d_printf("cli_openx_recv returned %s: %d\n",
                  nt_errstr(status),
                  NT_STATUS_IS_OK(status) ? fnum : -1);
@@ -6030 +7044 @@
 {
         struct cli_state *cli1;
-        struct event_context *evt = event_context_init(NULL);
+        struct tevent_context *evt = samba_tevent_context_init(NULL);
         struct tevent_req *reqs[3], *smbreqs[3];
         bool done = false;
@@ -6041 +7055 @@
         }
 
-        cli_sockopt(cli1, sockops);
-
-        reqs[0] = cli_open_create(talloc_tos(), evt, cli1, "\\test",
+        smbXcli_conn_set_sockopt(cli1->conn, sockops);
+
+        reqs[0] = cli_openx_create(talloc_tos(), evt, cli1, "\\test",
                                   O_CREAT|O_RDWR, 0, &smbreqs[0]);
         if (reqs[0] == NULL) return false;
@@ -6050 +7064 @@
 
         reqs[1] = cli_write_andx_create(talloc_tos(), evt, cli1, 0, 0,
-                                        (uint8_t *)str, 0, strlen(str)+1,
+                                        (const uint8_t *)str, 0, strlen(str)+1,
                                         smbreqs, 1, &smbreqs[1]);
         if (reqs[1] == NULL) return false;
@@ -6059 +7073 @@
         tevent_req_set_callback(reqs[2], chain1_close_completion, &done);
 
-        status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
+        status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
         if (!NT_STATUS_IS_OK(status)) {
                 return false;
@@ -6065 +7079 @@
 
         while (!done) {
-                event_loop_once(evt);
+                tevent_loop_once(evt);
         }
 
@@ -6091 +7105 @@
 {
         struct cli_state *cli1;
-        struct event_context *evt = event_context_init(NULL);
+        struct tevent_context *evt = samba_tevent_context_init(NULL);
         struct tevent_req *reqs[2], *smbreqs[2];
         bool done = false;
@@ -6097 +7111 @@
 
         printf("starting chain2 test\n");
-        status = cli_start_connection(&cli1, global_myname(), host, NULL,
-                                      port_to_use, Undefined, 0);
-        if (!NT_STATUS_IS_OK(status)) {
-                return False;
-        }
-
-        cli_sockopt(cli1, sockops);
+        status = cli_start_connection(&cli1, lp_netbios_name(), host, NULL,
+                                      port_to_use, SMB_SIGNING_DEFAULT, 0);
+        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,
@@ -6115 +7129 @@
         tevent_req_set_callback(reqs[1], chain2_tcon_completion, &done);
 
-        status = cli_smb_chain_send(smbreqs, ARRAY_SIZE(smbreqs));
+        status = smb1cli_req_chain_submit(smbreqs, ARRAY_SIZE(smbreqs));
         if (!NT_STATUS_IS_OK(status)) {
                 return false;
@@ -6121 +7135 @@
 
         while (!done) {
-                event_loop_once(evt);
+                tevent_loop_once(evt);
         }
 
@@ -6176 +7190 @@
         uint16_t fnum;
 
-        status = cli_ntcreate_recv(subreq, &fnum);
+        status = cli_ntcreate_recv(subreq, &fnum, NULL);
         TALLOC_FREE(subreq);
-        if (!NT_STATUS_IS_OK(status)) {
+        if (tevent_req_nterror(req, status)) {
                 DEBUG(10, ("cli_ntcreate_recv returned %s\n",
                            nt_errstr(status)));
-                tevent_req_nterror(req, status);
                 return;
         }
@@ -6199 +7212 @@
 
         status = cli_close_recv(subreq);
-        if (!NT_STATUS_IS_OK(status)) {
+        if (tevent_req_nterror(req, status)) {
                 DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
-                tevent_req_nterror(req, status);
                 return;
         }
@@ -6456 +7468 @@
         }
 
-        ev = tevent_context_init(talloc_tos());
+        ev = samba_tevent_context_init(talloc_tos());
         if (ev == NULL) {
                 d_printf("tevent_context_init failed\n");
@@ -6481 +7493 @@
                                       FILE_SHARE_DELETE,
                                       FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
-                                      &dnum);
+                                      &dnum, NULL);
 
                 if (!NT_STATUS_IS_OK(status)) {
@@ -6539 +7551 @@
         NTSTATUS status;
         time_t change_time, access_time, write_time;
-        SMB_OFF_T size;
+        off_t size;
         uint16_t mode;
 
@@ -6547 +7559 @@
         }
 
-        cli_sockopt(cli, sockops);
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(
-                        cli, fname, 0, GENERIC_ALL_ACCESS|DELETE_ACCESS,
-                        FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, 0, 0, &fnum))) {
-                d_printf("open %s failed: %s\n", fname, cli_errstr(cli));
+        smbXcli_conn_set_sockopt(cli->conn, 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;
         }
@@ -6565 +7578 @@
         d_printf("alt_name: %s\n", alt_name);
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, alt_name, O_RDONLY, DENY_NONE, &fnum))) {
-                d_printf("cli_open(%s) failed: %s\n", alt_name,
-                         cli_errstr(cli));
+        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;
         }
@@ -6608 +7622 @@
         double seconds;
         double kbytes;
+        NTSTATUS status;
 
         printf("starting windows_write test\n");
@@ -6614 +7629 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_open(cli1, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum))) {
-                printf("open failed (%s)\n", cli_errstr(cli1));
-                return False;
-        }
-
-        cli_sockopt(cli1, sockops);
+        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();
@@ -6626 +7642 @@
                 uint8_t c = 0;
                 off_t start = i * torture_blocksize;
-                NTSTATUS status;
                 size_t to_pull = torture_blocksize - 1;
 
@@ -6659 +7674 @@
 }
 
+static size_t calc_expected_return(struct cli_state *cli, size_t len_requested)
+{
+        size_t max_pdu = 0x1FFFF;
+
+        if (cli->server_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);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto out;
+                }
+
+                status = cli_session_setup(cli2,
+                                        username,
+                                        password,
+                                        strlen(password)+1,
+                                        password,
+                                        strlen(password)+1,
+                                        workgroup);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto out;
+                }
+
+                status = cli_tree_connect(cli2,
+                                        share,
+                                        "?????",
+                                        password,
+                                        strlen(password)+1);
+                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 bool run_cli_echo(int dummy)
 {
@@ -6668 +8019 @@
                 return false;
         }
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         status = cli_echo(cli, 5, data_blob_const("hello", 5));
@@ -6692 +8043 @@
         }
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         /* Ok - now save then logoff our current user. */
-        old_vuid = cli->vuid;
+        old_vuid = cli_state_get_uid(cli);
 
         status = cli_ulogoff(cli);
@@ -6705 +8056 @@
         }
 
-        cli->vuid = old_vuid;
+        cli_state_set_uid(cli, old_vuid);
 
         /* Try an operation. */
@@ -6716 +8067 @@
         } else {
                 /* Should be bad uid. */
-                if (!check_error(__LINE__, cli, ERRSRV, ERRbaduid,
-                                NT_STATUS_USER_SESSION_DELETED)) {
+                if (!check_error(__LINE__, status, ERRSRV, ERRbaduid,
+                                 NT_STATUS_USER_SESSION_DELETED)) {
                         correct = false;
                         goto out;
@@ -6723 +8074 @@
         }
 
-        old_cnum = cli->cnum;
+        old_cnum = cli_state_get_tid(cli);
 
         /* Now try a SMBtdis with the invald vuid set to zero. */
-        cli->vuid = 0;
+        cli_state_set_uid(cli, 0);
 
         /* This should succeed. */
@@ -6739 +8090 @@
         }
 
-        cli->vuid = old_vuid;
-        cli->cnum = old_cnum;
+        cli_state_set_uid(cli, old_vuid);
+        cli_state_set_tid(cli, old_cnum);
 
         /* This should fail. */
@@ -6750 +8101 @@
         } else {
                 /* Should be bad tid. */
-                if (!check_error(__LINE__, cli, ERRSRV, ERRinvnid,
+                if (!check_error(__LINE__, status, ERRSRV, ERRinvnid,
                                 NT_STATUS_NETWORK_NAME_DELETED)) {
                         correct = false;
@@ -6813 +8164 @@
 
         if (strchr(force_shortname_chars, i)) {
-                if (!finfo->short_name[0]) {
+                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",
@@ -6819 +8170 @@
                         s->val = true;
                 }
-        } else if (finfo->short_name[0]){
+        } else if (finfo->short_name){
                 /* Shortname created when it should not be. */
                 d_printf("(%s) ERROR: Shortname %s was created for file %s\n",
@@ -6835 +8186 @@
         int i;
         struct sn_state s;
-        char fname[20];
+        char fname[40];
+        NTSTATUS status;
 
         printf("starting shortname test\n");
@@ -6843 +8195 @@
         }
 
-        cli_sockopt(cli, sockops);
+        smbXcli_conn_set_sockopt(cli->conn, sockops);
 
         cli_list(cli, "\\shortname\\*", 0, shortname_del_fn, cli);
@@ -6849 +8201 @@
         cli_rmdir(cli, "\\shortname");
 
-        if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\shortname"))) {
+        status = cli_mkdir(cli, "\\shortname");
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("(%s) cli_mkdir of \\shortname failed: %s\n",
-                        __location__, cli_errstr(cli));
+                        __location__, nt_errstr(status));
                 correct = false;
                 goto out;
         }
 
-        strlcpy(fname, "\\shortname\\", sizeof(fname));
-        strlcat(fname, "test .txt", sizeof(fname));
+        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++) {
-                NTSTATUS status;
                 uint16_t fnum = (uint16_t)-1;
 
@@ -6873 +8231 @@
 
                 status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL,
-                                   FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OVERWRITE_IF, 0, 0, &fnum);
+                                   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, cli_errstr(cli));
+                                __location__, fname, nt_errstr(status));
                         correct = false;
                         goto out;
@@ -6883 +8242 @@
 
                 s.matched = 0;
-                cli_list(cli, "\\shortname\\test*.*", 0, shortname_list_fn,
-                         &s);
+                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, cli_errstr(cli));
+                                __location__, fname, nt_errstr(status));
                         correct = false;
                         goto out;
                 }
-                if (!NT_STATUS_IS_OK(cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
+
+                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, cli_errstr(cli));
+                                __location__, fname, nt_errstr(status));
                         correct = false;
                         goto out;
@@ -6980 +8341 @@
         d_printf("defaultNamingContext: %s\n", basedn);
 
-        ev = tevent_context_init(talloc_tos());
+        ev = samba_tevent_context_init(talloc_tos());
         if (ev == NULL) {
                 d_printf("tevent_context_init failed\n");
@@ -7056 +8417 @@
         sleep(3);
 
-        status = cli_open(cli, fname, O_RDWR | O_CREAT | O_EXCL,
+        status = cli_openx(cli, fname, O_RDWR | O_CREAT | O_EXCL,
                          DENY_NONE, &fnum);
         if (!NT_STATUS_IS_OK(status)) {
-                printf("cli_open failed: %s\n", nt_errstr(status));
+                printf("cli_openx failed: %s\n", nt_errstr(status));
                 goto out;
         }
@@ -7097 +8458 @@
         NTSTATUS status;
         time_t change_time, access_time, write_time;
-        SMB_OFF_T size;
+        off_t size;
         uint16_t mode, fnum;
         bool ret = true;
@@ -7114 +8475 @@
         }
 
-        cli_qpathinfo1(cli, streamname, &change_time, &access_time, &write_time,
-                      &size, &mode);
-        status = cli_nt_error(cli);
-
+        status = cli_qpathinfo1(cli, streamname, &change_time, &access_time,
+                                &write_time, &size, &mode);
         if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
                 printf("pathinfo returned %s, expected "
@@ -7129 +8488 @@
                               FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
                               FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
-                              FILE_OPEN, 0, 0, &fnum);
+                              FILE_OPEN, 0, 0, &fnum, NULL);
 
         if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
@@ -7197 +8556 @@
 }
 
+static void parse_fn(time_t timeout, DATA_BLOB blob, void *private_data)
+{
+        return;
+}
+
 static bool run_local_gencache(int dummy)
 {
@@ -7202 +8566 @@
         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)) {
@@ -7208 +8582 @@
         }
 
-        if (!gencache_get("foo", NULL, NULL)) {
+        if (!gencache_get("foo", NULL, NULL, NULL)) {
                 d_printf("%s: gencache_get() failed\n", __location__);
                 return False;
         }
 
-        if (!gencache_get("foo", &val, &tm)) {
+        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;
@@ -7221 +8605 @@
                 d_printf("%s: gencache_get() returned %s, expected %s\n",
                          __location__, val, "bar");
-                SAFE_FREE(val);
-                return False;
-        }
-
-        SAFE_FREE(val);
+                TALLOC_FREE(val);
+                return False;
+        }
+
+        TALLOC_FREE(val);
 
         if (!gencache_del("foo")) {
@@ -7237 +8621 @@
         }
 
-        if (gencache_get("foo", &val, &tm)) {
+        if (gencache_get("foo", talloc_tos(), &val, &tm)) {
                 d_printf("%s: gencache_get() on deleted entry "
                          "succeeded\n", __location__);
@@ -7251 +8635 @@
         }
 
-        if (!gencache_get_data_blob("foo", &blob, NULL, NULL)) {
+        if (!gencache_get_data_blob("foo", talloc_tos(), &blob, NULL, NULL)) {
                 d_printf("%s: gencache_get_data_blob() failed\n", __location__);
                 return False;
@@ -7275 +8659 @@
         }
 
-        if (gencache_get_data_blob("foo", &blob, NULL, NULL)) {
+        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;
         }
 
@@ -7291 +8689 @@
         bool ret = false;
         NTSTATUS status;
-
-        rec = db->fetch_locked(db, db, string_tdb_data(key));
+        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 = rec->store(rec, data, 0);
+        status = dbwrap_record_store(rec, data, 0);
         if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, "store failed: %s\n", nt_errstr(status));
@@ -7304 +8703 @@
         TALLOC_FREE(rec);
 
-        rec = db->fetch_locked(db, db, string_tdb_data(key));
+        rec = dbwrap_fetch_locked(db, db, string_tdb_data(key));
         if (rec == NULL) {
                 d_fprintf(stderr, "second fetch_locked failed\n");
                 goto done;
         }
-        if ((rec->value.dsize != data.dsize)
-            || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
+
+        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;
@@ -7321 +8722 @@
 }
 
+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)
 {
@@ -7326 +8742 @@
         bool ret = false;
         int i;
+        NTSTATUS status;
+        int count = 0;
+        int count2 = 0;
 
         db = db_open_rbt(NULL);
@@ -7368 +8787 @@
 
         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:
@@ -7374 +8814 @@
 }
 
+
+/*
+  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;
+}
+
+
 struct talloc_dict_test {
         int content;
@@ -7389 +8926 @@
         struct talloc_dict *dict;
         struct talloc_dict_test *t;
-        int key, count;
+        int key, count, res;
+        bool ok;
 
         dict = talloc_dict_init(talloc_tos());
@@ -7403 +8941 @@
         key = 1;
         t->content = 1;
-        if (!talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), t)) {
+        ok = talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), &t);
+        if (!ok) {
                 return false;
         }
 
         count = 0;
-        if (talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count) != 0) {
+        res = talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count);
+        if (res == -1) {
                 return false;
         }
 
         if (count != 1) {
+                return false;
+        }
+
+        if (count != res) {
                 return false;
         }
@@ -7438 +8982 @@
         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;
         }
@@ -7452 +9012 @@
 }
 
+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) {
         struct dom_sid *sid = talloc(NULL, struct dom_sid);
-        static const char good_binary_sid[] = {
+        static const uint8_t good_binary_sid[] = {
                 0x1, /* revision number */
                 15, /* num auths */
@@ -7475 +9064 @@
         };
 
-        static const char long_binary_sid[] = {
+        static const uint8_t long_binary_sid[] = {
                 0x1, /* revision number */
                 15, /* num auths */
@@ -7499 +9088 @@
         };
 
-        static const char long_binary_sid2[] = {
+        static const uint8_t long_binary_sid2[] = {
                 0x1, /* revision number */
                 32, /* num auths */
@@ -7591 +9180 @@
         }
         else {
-                if (StrCaseCmp(stype, ":$DATA") != 0) {
+                if (strcasecmp_m(stype, ":$DATA") != 0) {
                         /*
                          * If there is an explicit stream type, so far we only
@@ -7626 +9215 @@
                  * upper-case the type field
                  */
-                strupper_m(strchr_m(stream, ':')+1);
+                (void)strupper_m(strchr_m(stream, ':')+1);
         }
 
@@ -7733 +9322 @@
         bool ret = false;
 
-        cache = memcache_init(NULL, 100);
+        cache = memcache_init(NULL, sizeof(void *) == 8 ? 200 : 100);
 
         if (cache == NULL) {
@@ -7825 +9414 @@
 }
 
-static bool run_local_wbclient(int dummy)
-{
-        struct event_context *ev;
+static bool run_wbclient_multi_ping(int dummy)
+{
+        struct tevent_context *ev;
         struct wb_context **wb_ctx;
         struct winbindd_request wb_req;
@@ -7835 +9424 @@
         BlockSignals(True, SIGPIPE);
 
-        ev = tevent_context_init_byname(talloc_tos(), "epoll");
+        ev = tevent_context_init(talloc_tos());
         if (ev == NULL) {
                 goto fail;
         }
 
-        wb_ctx = TALLOC_ARRAY(ev, struct wb_context *, nprocs);
+        wb_ctx = talloc_array(ev, struct wb_context *, torture_nprocs);
         if (wb_ctx == NULL) {
                 goto fail;
@@ -7848 +9437 @@
         wb_req.cmd = WINBINDD_PING;
 
-        d_printf("nprocs=%d, numops=%d\n", (int)nprocs, (int)torture_numops);
-
-        for (i=0; i<nprocs; i++) {
+        d_printf("torture_nprocs=%d, numops=%d\n", (int)torture_nprocs, (int)torture_numops);
+
+        for (i=0; i<torture_nprocs; i++) {
                 wb_ctx[i] = wb_context_init(ev, NULL);
                 if (wb_ctx[i] == NULL) {
@@ -7868 +9457 @@
         i = 0;
 
-        while (i < nprocs * torture_numops) {
-                event_loop_once(ev);
+        while (i < torture_nprocs * torture_numops) {
+                tevent_loop_once(ev);
         }
 
@@ -7904 +9493 @@
         int i;
 
-        ev = event_context_init(frame);
+        ev = samba_tevent_context_init(frame);
         if (ev == NULL) {
                 goto fail;
@@ -7918 +9507 @@
                 }
                 tevent_req_set_callback(reqs[i], getaddrinfo_finished,
-                                        (void *)names[i]);
+                                        discard_const_p(void, names[i]));
         }
 
@@ -7934 +9523 @@
 {
         struct db_record *rec;
-        uint32_t *val;
+        uint32_t val;
         bool ret = false;
         NTSTATUS status;
-
-        rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
+        TDB_DATA value;
+
+        rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
         if (rec == NULL) {
                 printf(__location__ "fetch_lock failed\n");
@@ -7944 +9534 @@
         }
 
-        if (rec->value.dsize != sizeof(uint32_t)) {
+        value = dbwrap_record_get_value(rec);
+
+        if (value.dsize != sizeof(uint32_t)) {
                 printf(__location__ "value.dsize = %d\n",
-                       (int)rec->value.dsize);
+                       (int)value.dsize);
                 goto fail;
         }
 
-        val = (uint32_t *)rec->value.dptr;
-        *val += 1;
-
-        status = rec->store(rec, make_tdb_data((uint8_t *)val,
-                                               sizeof(uint32_t)),
-                            0);
+        memcpy(&val, value.dptr, sizeof(val));
+        val += 1;
+
+        status = dbwrap_record_store(
+                rec, make_tdb_data((uint8_t *)&val, sizeof(val)), 0);
         if (!NT_STATUS_IS_OK(status)) {
                 printf(__location__ "store failed: %s\n",
@@ -7975 +9566 @@
         uint32_t initial;
         int res;
+        TDB_DATA value;
 
         db = db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT,
-                     O_RDWR|O_CREAT, 0600);
+                     O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_1,
+                     DBWRAP_FLAG_NONE);
         if (db == NULL) {
                 printf("Could not open transtest.db\n");
@@ -7983 +9576 @@
         }
 
-        res = db->transaction_start(db);
-        if (res == -1) {
+        res = dbwrap_transaction_start(db);
+        if (res != 0) {
                 printf(__location__ "transaction_start failed\n");
                 return false;
         }
 
-        rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
+        rec = dbwrap_fetch_locked(db, db, string_term_tdb_data("transtest"));
         if (rec == NULL) {
                 printf(__location__ "fetch_lock failed\n");
@@ -7995 +9588 @@
         }
 
-        if (rec->value.dptr == NULL) {
+        value = dbwrap_record_get_value(rec);
+
+        if (value.dptr == NULL) {
                 initial = 0;
-                status = rec->store(
+                status = dbwrap_record_store(
                         rec, make_tdb_data((uint8_t *)&initial,
                                            sizeof(initial)),
@@ -8010 +9605 @@
         TALLOC_FREE(rec);
 
-        res = db->transaction_commit(db);
-        if (res == -1) {
+        res = dbwrap_transaction_commit(db);
+        if (res != 0) {
                 printf(__location__ "transaction_commit failed\n");
                 return false;
@@ -8020 +9615 @@
                 int i;
 
-                res = db->transaction_start(db);
-                if (res == -1) {
+                res = dbwrap_transaction_start(db);
+                if (res != 0) {
                         printf(__location__ "transaction_start failed\n");
                         break;
                 }
 
-                if (!dbwrap_fetch_uint32(db, "transtest", &val)) {
-                        printf(__location__ "dbwrap_fetch_uint32 failed\n");
+                status = dbwrap_fetch_uint32_bystring(db, "transtest", &val);
+                if (!NT_STATUS_IS_OK(status)) {
+                        printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
+                               nt_errstr(status));
                         break;
                 }
@@ -8037 +9634 @@
                 }
 
-                if (!dbwrap_fetch_uint32(db, "transtest", &val2)) {
-                        printf(__location__ "dbwrap_fetch_uint32 failed\n");
+                status = dbwrap_fetch_uint32_bystring(db, "transtest", &val2);
+                if (!NT_STATUS_IS_OK(status)) {
+                        printf(__location__ "dbwrap_fetch_uint32 failed: %s\n",
+                               nt_errstr(status));
                         break;
                 }
@@ -8050 +9649 @@
                 printf("val2=%d\r", val2);
 
-                res = db->transaction_commit(db);
-                if (res == -1) {
+                res = dbwrap_transaction_commit(db);
+                if (res != 0) {
                         printf(__location__ "transaction_commit failed\n");
                         break;
@@ -8101 +9700 @@
         TALLOC_FREE(ev);
         return result;
+}
+
+static bool run_local_hex_encode_buf(int dummy)
+{
+        char buf[17];
+        uint8_t src[8];
+        int i;
+
+        for (i=0; i<sizeof(src); i++) {
+                src[i] = i;
+        }
+        hex_encode_buf(buf, src, sizeof(src));
+        if (strcmp(buf, "0001020304050607") != 0) {
+                return false;
+        }
+        hex_encode_buf(buf, NULL, 0);
+        if (buf[0] != '\0') {
+                return false;
+        }
+        return true;
+}
+
+static const char *remove_duplicate_addrs2_test_strings_vector[] = {
+        "0.0.0.0",
+        "::0",
+        "1.2.3.1",
+        "0.0.0.0",
+        "0.0.0.0",
+        "1.2.3.2",
+        "1.2.3.3",
+        "1.2.3.4",
+        "1.2.3.5",
+        "::0",
+        "1.2.3.6",
+        "1.2.3.7",
+        "::0",
+        "::0",
+        "::0",
+        "1.2.3.8",
+        "1.2.3.9",
+        "1.2.3.10",
+        "1.2.3.11",
+        "1.2.3.12",
+        "1.2.3.13",
+        "1001:1111:1111:1000:0:1111:1111:1111",
+        "1.2.3.1",
+        "1.2.3.2",
+        "1.2.3.3",
+        "1.2.3.12",
+        "::0",
+        "::0"
+};
+
+static const char *remove_duplicate_addrs2_test_strings_result[] = {
+        "1.2.3.1",
+        "1.2.3.2",
+        "1.2.3.3",
+        "1.2.3.4",
+        "1.2.3.5",
+        "1.2.3.6",
+        "1.2.3.7",
+        "1.2.3.8",
+        "1.2.3.9",
+        "1.2.3.10",
+        "1.2.3.11",
+        "1.2.3.12",
+        "1.2.3.13",
+        "1001:1111:1111:1000:0:1111:1111:1111"
+};
+
+static bool run_local_remove_duplicate_addrs2(int dummy)
+{
+        struct ip_service test_vector[28];
+        int count, i;
+
+        /* Construct the sockaddr_storage test vector. */
+        for (i = 0; i < 28; i++) {
+                struct addrinfo hints;
+                struct addrinfo *res = NULL;
+                int ret;
+
+                memset(&hints, '\0', sizeof(hints));
+                hints.ai_flags = AI_NUMERICHOST;
+                ret = getaddrinfo(remove_duplicate_addrs2_test_strings_vector[i],
+                                NULL,
+                                &hints,
+                                &res);
+                if (ret) {
+                        fprintf(stderr, "getaddrinfo failed on [%s]\n",
+                                remove_duplicate_addrs2_test_strings_vector[i]);
+                        return false;
+                }
+                memset(&test_vector[i], '\0', sizeof(test_vector[i]));
+                memcpy(&test_vector[i].ss,
+                        res->ai_addr,
+                        res->ai_addrlen);
+                freeaddrinfo(res);
+        }
+
+        count = remove_duplicate_addrs2(test_vector, i);
+
+        if (count != 14) {
+                fprintf(stderr, "count wrong (%d) 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].ss);
+
+                if (strcmp(addr, remove_duplicate_addrs2_test_strings_result[i]) != 0) {
+                        fprintf(stderr, "mismatch on [%d] [%s] [%s]\n",
+                                i,
+                                addr,
+                                remove_duplicate_addrs2_test_strings_result[i]);
+                        return false;
+                }
+        }
+
+        printf("run_local_remove_duplicate_addrs2: success\n");
+        return true;
 }
 
@@ -8168 +9890 @@
         synccount = 0;
 
-        child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*nprocs);
+        child_status = (volatile pid_t *)anonymous_shared_allocate(sizeof(pid_t)*torture_nprocs);
         if (!child_status) {
                 printf("Failed to setup shared memory\n");
@@ -8174 +9896 @@
         }
 
-        child_status_out = (volatile bool *)shm_setup(sizeof(bool)*nprocs);
+        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");
@@ -8180 +9902 @@
         }
 
-        for (i = 0; i < nprocs; i++) {
+        for (i = 0; i < torture_nprocs; i++) {
                 child_status[i] = 0;
                 child_status_out[i] = True;
@@ -8187 +9909 @@
         start = timeval_current();
 
-        for (i=0;i<nprocs;i++) {
+        for (i=0;i<torture_nprocs;i++) {
                 procnum = i;
                 if (fork() == 0) {
@@ -8215 +9937 @@
         do {
                 synccount = 0;
-                for (i=0;i<nprocs;i++) {
+                for (i=0;i<torture_nprocs;i++) {
                         if (child_status[i]) synccount++;
                 }
-                if (synccount == nprocs) break;
+                if (synccount == torture_nprocs) break;
                 smb_msleep(10);
         } while (timeval_elapsed(&start) < 30);
 
-        if (synccount != nprocs) {
-                printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
+        if (synccount != torture_nprocs) {
+                printf("FAILED TO START %d CLIENTS (started %d)\n", torture_nprocs, synccount);
                 *result = False;
                 return timeval_elapsed(&start);
@@ -8231 +9953 @@
         start = timeval_current();
 
-        for (i=0;i<nprocs;i++) {
+        for (i=0;i<torture_nprocs;i++) {
                 child_status[i] = 0;
         }
 
-        printf("%d clients started\n", nprocs);
-
-        for (i=0;i<nprocs;i++) {
+        printf("%d clients started\n", torture_nprocs);
+
+        for (i=0;i<torture_nprocs;i++) {
                 while (waitpid(0, &status, 0) == -1 && errno == EINTR) /* noop */ ;
         }
@@ -8243 +9965 @@
         printf("\n");
 
-        for (i=0;i<nprocs;i++) {
+        for (i=0;i<torture_nprocs;i++) {
                 if (!child_status_out[i]) {
                         *result = False;
@@ -8280 +10002 @@
         {"OPLOCK1",  run_oplock1, 0},
         {"OPLOCK2",  run_oplock2, 0},
-        {"OPLOCK3",  run_oplock3, 0},
         {"OPLOCK4",  run_oplock4, 0},
         {"DIR",  run_dirtest, 0},
@@ -8296 +10017 @@
         {"POSIX", run_simple_posix_open_test, 0},
         {"POSIX-APPEND", run_posix_append, 0},
+        {"POSIX-SYMLINK-ACL", run_acl_symlink_test, 0},
+        {"POSIX-SYMLINK-EA", run_ea_symlink_test, 0},
+        {"CASE-INSENSITIVE-CREATE", run_case_insensitive_create, 0},
         {"ASYNC-ECHO", run_async_echo, 0},
         { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
@@ -8306 +10030 @@
         {"RENAME", run_rename, 0},
         {"DELETE", run_deletetest, 0},
+        {"WILDDELETE", run_wild_deletetest, 0},
         {"DELETE-LN", run_deletetest_ln, 0},
         {"PROPERTIES", run_properties, 0},
@@ -8325 +10050 @@
         { "CHAIN1", run_chain1, 0},
         { "CHAIN2", run_chain2, 0},
+        { "CHAIN3", run_chain3, 0},
         { "WINDOWS-WRITE", run_windows_write, 0},
+        { "LARGE_READX", run_large_readx, 0},
+        { "NTTRANS-CREATE", run_nttrans_create, 0},
+        { "NTTRANS-FSCTL", run_nttrans_fsctl, 0},
         { "CLI_ECHO", run_cli_echo, 0},
         { "GETADDRINFO", run_getaddrinfo_send, 0},
@@ -8331 +10060 @@
         { "STREAMERROR", run_streamerror },
         { "NOTIFY-BENCH", run_notify_bench },
+        { "NOTIFY-BENCH2", run_notify_bench2 },
+        { "NOTIFY-BENCH3", run_notify_bench3 },
         { "BAD-NBT-SESSION", run_bad_nbt_session },
         { "SMB-ANY-CONNECT", run_smb_any_connect },
+        { "NOTIFY-ONLINE", run_notify_online },
+        { "SMB2-BASIC", run_smb2_basic },
+        { "SMB2-NEGPROT", run_smb2_negprot },
+        { "SMB2-SESSION-RECONNECT", run_smb2_session_reconnect },
+        { "SMB2-TCON-DEPENDENCE", run_smb2_tcon_dependence },
+        { "SMB2-MULTI-CHANNEL", run_smb2_multi_channel },
+        { "SMB2-SESSION-REAUTH", run_smb2_session_reauth },
+        { "CLEANUP1", run_cleanup1 },
+        { "CLEANUP2", run_cleanup2 },
+        { "CLEANUP3", run_cleanup3 },
+        { "CLEANUP4", run_cleanup4 },
+        { "OPLOCK-CANCEL", run_oplock_cancel },
         { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
         { "LOCAL-GENCACHE", run_local_gencache, 0},
         { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 0},
+        { "LOCAL-DBWRAP-WATCH1", run_dbwrap_watch1, 0 },
+        { "LOCAL-MESSAGING-READ1", run_messaging_read1, 0 },
+        { "LOCAL-MESSAGING-READ2", run_messaging_read2, 0 },
+        { "LOCAL-MESSAGING-READ3", run_messaging_read3, 0 },
+        { "LOCAL-MESSAGING-READ4", run_messaging_read4, 0 },
+        { "LOCAL-MESSAGING-FDPASS1", run_messaging_fdpass1, 0 },
+        { "LOCAL-MESSAGING-FDPASS2", run_messaging_fdpass2, 0 },
+        { "LOCAL-MESSAGING-FDPASS2a", run_messaging_fdpass2a, 0 },
+        { "LOCAL-MESSAGING-FDPASS2b", run_messaging_fdpass2b, 0 },
         { "LOCAL-BASE64", run_local_base64, 0},
         { "LOCAL-RBTREE", run_local_rbtree, 0},
         { "LOCAL-MEMCACHE", run_local_memcache, 0},
         { "LOCAL-STREAM-NAME", run_local_stream_name, 0},
-        { "LOCAL-WBCLIENT", run_local_wbclient, 0},
+        { "WBCLIENT-MULTI-PING", run_wbclient_multi_ping, 0},
         { "LOCAL-string_to_sid", run_local_string_to_sid, 0},
+        { "LOCAL-sid_to_string", run_local_sid_to_string, 0},
         { "LOCAL-binary_to_sid", run_local_binary_to_sid, 0},
         { "LOCAL-DBTRANS", run_local_dbtrans, 0},
         { "LOCAL-TEVENT-SELECT", run_local_tevent_select, 0},
-        { "LOCAL-TDB-OPENER", run_local_tdb_opener, 0 },
-        { "LOCAL-TDB-WRITER", run_local_tdb_writer, 0 },
+        { "LOCAL-CONVERT-STRING", run_local_convert_string, 0},
+        { "LOCAL-CONV-AUTH-INFO", run_local_conv_auth_info, 0},
+        { "LOCAL-sprintf_append", run_local_sprintf_append, 0},
+        { "LOCAL-hex_encode_buf", run_local_hex_encode_buf, 0},
+        { "LOCAL-IDMAP-TDB-COMMON", run_idmap_tdb_common_test, 0},
+        { "LOCAL-remove_duplicate_addrs2", run_local_remove_duplicate_addrs2, 0},
+        { "local-tdb-opener", run_local_tdb_opener, 0 },
+        { "local-tdb-writer", run_local_tdb_writer, 0 },
+        { "LOCAL-DBWRAP-CTDB", run_local_dbwrap_ctdb, 0 },
+        { "LOCAL-BENCH-PTHREADPOOL", run_bench_pthreadpool, 0 },
+        { "qpathinfo-bufsize", run_qpathinfo_bufsize, 0 },
         {NULL, NULL, 0}};
 
-
+/*
+ * dummy function to satisfy linker dependency
+ */
+struct tevent_context *winbind_event_context(void);
+struct tevent_context *winbind_event_context(void)
+{
+        return NULL;
+}
 
 /****************************************************************************
@@ -8414 +10183 @@
         printf("\t-d debuglevel\n");
         printf("\t-U user%%pass\n");
-        printf("\t-k               use kerberos\n");
+        printf("\t-k                    use kerberos\n");
         printf("\t-N numprocs\n");
         printf("\t-n my_netbios_name\n");
@@ -8422 +10191 @@
         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-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");
 
@@ -8459 +10230 @@
         setup_logging("smbtorture", DEBUG_STDOUT);
 
-        load_case_tables();
+        smb_init_locale();
+        fault_setup();
 
         if (is_default_dyn_CONFIGFILE()) {
@@ -8466 +10238 @@
                 }
         }
-        lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
+        lp_load_global(get_dyn_CONFIGFILE());
         load_interfaces();
 
@@ -8504 +10276 @@
         fstrcpy(workgroup, lp_workgroup());
 
-        while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:")) != EOF) {
+        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':
@@ -8516 +10289 @@
                         break;
                 case 'm':
-                        max_protocol = interpret_protocol(optarg, max_protocol);
+                        lp_set_cmdline("client max protocol", optarg);
                         break;
                 case 'N':
-                        nprocs = atoi(optarg);
+                        torture_nprocs = atoi(optarg);
                         break;
                 case 'o':
@@ -8573 +10346 @@
                         torture_blocksize = atoi(optarg);
                         break;
+                case 'f':
+                        test_filename = SMB_STRDUP(optarg);
+                        break;
                 default:
                         printf("Unknown option %c (%d)\n", (char)opt, opt);
@@ -8586 +10362 @@
 
         while (!gotpass) {
-                p = getpass("Password:");
-                if (p) {
-                        fstrcpy(password, p);
+                char pwd[256] = {0};
+                int rc;
+
+                rc = samba_getpass("Password:", pwd, sizeof(pwd), false, false);
+                if (rc == 0) {
+                        fstrcpy(password, pwd);
                         gotpass = 1;
                 }

vendor/current/source3/torture/utable.c

@@ -33 +33 @@
         int c, len, fd;
         int chars_allowed=0, alt_allowed=0;
-        uint8 valid[0x10000];
+        uint8_t valid[0x10000];
 
         printf("starting utable\n");
@@ -47 +47 @@
 
         for (c=1; c < 0x10000; c++) {
+                size_t size = 0;
                 char *p;
 
@@ -52 +53 @@
                 fstrcpy(fname, "\\utable\\x");
                 p = fname+strlen(fname);
-                len = convert_string(CH_UTF16LE, CH_UNIX, 
+                if (!convert_string(CH_UTF16LE, CH_UNIX,
                                      &c2, 2, 
-                                     p, sizeof(fname)-strlen(fname), True);
+                                     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_open(cli, fname, O_RDWR | O_CREAT | O_TRUNC, 
+                if (!NT_STATUS_IS_OK(cli_openx(cli, fname, O_RDWR | O_CREAT | O_TRUNC, 
                                 DENY_NONE, &fnum))) {
                         continue;
@@ -108 +113 @@
         smb_ucs2_t c2;
         char *p;
-        int len;
+        size_t len = 0;
 
         fstrcpy(fname, "\\utable\\");
@@ -114 +119 @@
         SSVAL(&c2, 0, c);
 
-        len = convert_string(CH_UTF16LE, CH_UNIX, 
+        if (!convert_string(CH_UTF16LE, CH_UNIX,
                              &c2, 2, 
-                             p, sizeof(fname)-strlen(fname), True);
+                             p, sizeof(fname)-strlen(fname), &len)) {
+                d_printf("form_name: convert string %s failed\n",
+                        fname);
+                return NULL;
+        }
         p[len] = 0;
         return fname;
@@ -145 +154 @@
 
         for (c=1; c < 0x10000; c++) {
-                SMB_OFF_T size;
+                off_t size;
 
                 if (c == '.' || c == '\\') continue;
@@ -156 +165 @@
                                           FILE_ATTRIBUTE_NORMAL,
                                           FILE_SHARE_NONE,
-                                          FILE_OPEN_IF, 0, 0, &fnum))) {
+                                          FILE_OPEN_IF, 0, 0, &fnum, NULL))) {
                         printf("Failed to create file with char %04x\n", c);
                         continue;
@@ -180 +189 @@
                         }
 
-                        cli_read(cli, fnum, (char *)c2, 0, size);
+                        cli_read(cli, fnum, (char *)c2, 0, size, NULL);
                         printf("%04x: ", c);
                         equiv[c][0] = c;

vendor/current/source3/torture/vfstest.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    VFS module tester
@@ -14 +14 @@
    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 <http://www.gnu.org/licenses/>.
@@ -26 +26 @@
 #include "includes.h"
 #include "smbd/smbd.h"
+#include "smbd/globals.h"
 #include "popt_common.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"
 
 /* List to hold groups of commands */
@@ -36 +43 @@
 } *cmd_list;
 
+/* shall we do talloc_report after each command? */
+static int memreports = 0;
+
 /****************************************************************************
 handle completion of commands for readline
@@ -46 +56 @@
         struct cmd_list *commands = cmd_list;
 
-        if (start) 
+        if (start)
                 return NULL;
 
         /* make sure we have a list of valid commands */
-        if (!commands) 
+        if (!commands)
                 return NULL;
 
@@ -59 +69 @@
         if (!matches[0]) return NULL;
 
-        while (commands && count < MAX_COMPLETIONS-1) 
+        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) 
+                                commands->cmd_set[i].fn)
                         {
                                 matches[count] = SMB_STRDUP(commands->cmd_set[i].name);
-                                if (!matches[count]) 
+                                if (!matches[count])
                                         return NULL;
                                 count++;
                         }
                 }
-                
+
                 commands = commands->next;
-                
         }
 
@@ -100 +109 @@
                 *p = '\0';
         command = talloc_strdup(ctx, *cmdstr);
-        *cmdstr = p;
+
+        /* Pass back the remaining cmdstring 
+           (a trailing delimiter ";" does also work),
+           or NULL at last cmdstring.
+        */
+        *cmdstr = p ? p + 1 : p;
 
         return command;
@@ -114 +128 @@
         }
 
-        if (!lp_load(argv[1], False, True, False, True)) {
+        if (!lp_load_with_shares(argv[1])) {
                 printf("Error loading \"%s\"\n", argv[1]);
                 return NT_STATUS_OK;
@@ -122 +136 @@
         return NT_STATUS_OK;
 }
-        
+
 /* Display help on commands */
 static NTSTATUS cmd_help(struct vfs_state *vfs, TALLOC_CTX *mem_ctx,
@@ -140 +154 @@
         if (argc == 2) {
                 for (tmp = cmd_list; tmp; tmp = tmp->next) {
-                        
+
                         tmp_set = tmp->cmd_set;
 
@@ -263 +277 @@
 {
         const char *p = cmd;
-        char **argv = NULL;
+        const char **argv = NULL;
         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
         char *buf;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
-        int argc = 0, i;
+        int argc = 0;
 
         /* Count number of arguments first time through the loop then
@@ -275 +289 @@
         while(next_token_talloc(mem_ctx, &p, &buf, " ")) {
                 if (argv) {
-                        argv[argc] = SMB_STRDUP(buf);
+                        argv[argc] = talloc_strdup(argv, buf);
                 }
                 argc++;
@@ -283 +297 @@
                 /* Create argument list */
 
-                argv = SMB_MALLOC_ARRAY(char *, argc);
-                memset(argv, 0, sizeof(char *) * argc);
-
-                if (!argv) {
+                argv = talloc_zero_array(mem_ctx, const char *, argc);
+                if (argv == NULL) {
                         fprintf(stderr, "out of memory\n");
                         result = NT_STATUS_NO_MEMORY;
@@ -313 +325 @@
 
         if (argv) {
-                for (i = 0; i < argc; i++)
-                        SAFE_FREE(argv[i]);
-
-                SAFE_FREE(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;
@@ -402 +416 @@
 }
 
-void exit_server(const char *reason)
+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 : "")));
@@ -408 +423 @@
 }
 
-void exit_server_cleanly(const char *const reason)
-{
-        exit_server("normal exit");
-}
-
-int last_message = -1;
-
-struct event_context *smbd_event_context(void)
-{
-        static struct event_context *ctx;
-
-        if (!ctx && !(ctx = event_context_init(NULL))) {
-                smb_panic("Could not init smbd event context\n");
-        }
-        return ctx;
+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, char *argv[])
-{
-        static char             *cmdstr = NULL;
-        struct cmd_set          **cmd_set;
-        static struct vfs_state vfs;
+int main(int argc, const char *argv[])
+{
+        char *cmdstr = NULL;
+        struct cmd_set  **cmd_set;
+        struct vfs_state *vfs;
         int i;
-        static char             *filename = NULL;
+        char *filename = NULL;
+        char cwd[MAXPATHLEN];
         TALLOC_CTX *frame = talloc_stackframe();
+        struct tevent_context *ev;
+        struct auth_session_info *session_info = NULL;
+        NTSTATUS status = NT_STATUS_OK;
 
         /* make sure the vars that get altered (4th field) are in
@@ -443 +477 @@
                 {"file",        'f', POPT_ARG_STRING,   &filename, 0, },
                 {"command",     'c', POPT_ARG_STRING,   &cmdstr, 0, "Execute specified list of commands" },
+                {"memreport",   'm', POPT_ARG_INT,      &memreports, 0,
+                 "Report memory left on talloc stackframe after each command" },
                 POPT_COMMON_SAMBA
                 POPT_TABLEEND
         };
-
-        load_case_tables();
+        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);
 
-        pc = poptGetContext("vfstest", argc, (const char **) argv,
-                            long_options, 0);
-        
+        pc = poptGetContext("vfstest", argc, argv, long_options, 0);
+
         while(poptGetNextOpt(pc) != -1);
 
@@ -459 +499 @@
         poptFreeContext(pc);
 
+        /* we want total control over the permissions on created files,
+           so set our umask to 0 */
+        umask(0);
+
         lp_load_initial_only(get_dyn_CONFIGFILE());
 
         /* TODO: check output */
-        reload_services(smbd_messaging_context(), -1, False);
+        reload_services(NULL, NULL, false);
 
         /* the following functions are part of the Samba debugging
            facilities.  See lib/debug.c */
         setup_logging("vfstest", DEBUG_STDOUT);
-        
+
+        set_smbd_shim(&vfstest_shim_fns);
+
         /* Load command lists */
 
@@ -480 +526 @@
         /* some basic initialization stuff */
         sec_init();
-        vfs.conn = TALLOC_ZERO_P(NULL, connection_struct);
-        vfs.conn->params = TALLOC_P(vfs.conn, struct share_params);
+        init_guest_info();
+        locking_init();
+        serverid_parent_init(NULL);
+        vfs = talloc_zero(NULL, struct vfs_state);
+        if (vfs == NULL) {
+                return 1;
+        }
+        status = make_session_info_guest(vfs, &session_info);
+        if (!NT_STATUS_IS_OK(status)) {
+                return 1;
+        }
+
+        ev = server_event_context();
+
+        status = create_conn_struct(vfs,
+                                ev,
+                                server_messaging_context(),
+                                &vfs->conn,
+                                -1,
+                                getcwd(cwd, sizeof(cwd)),
+                                session_info);
+        if (!NT_STATUS_IS_OK(status)) {
+                return 1;
+        }
+
+        vfs->conn->share_access = FILE_GENERIC_ALL;
+        vfs->conn->read_only = false;
+
+        serverid_register(messaging_server_id(vfs->conn->sconn->msg_ctx), 0);
+        file_init(vfs->conn->sconn);
         for (i=0; i < 1024; i++)
-                vfs.files[i] = NULL;
-
-        /* some advanced initiliazation stuff */
-        smbd_vfs_init(vfs.conn);
+                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);
+                process_file(vfs, filename);
                 return 0;
         }
@@ -500 +575 @@
 
                 while((cmd=next_command(frame, &p)) != NULL) {
-                        process_cmd(&vfs, cmd);
+                        status = process_cmd(vfs, cmd);
                 }
 
                 TALLOC_FREE(cmd);
-                return 0;
+                return NT_STATUS_IS_OK(status) ? 0 : 1;
         }
 
@@ -519 +594 @@
 
                 if (line[0] != '\n') {
-                        process_cmd(&vfs, line);
+                        status = process_cmd(vfs, line);
                 }
                 SAFE_FREE(line);
         }
 
-        TALLOC_FREE(vfs.conn);
+        TALLOC_FREE(vfs);
         TALLOC_FREE(frame);
-        return 0;
-}
+        return NT_STATUS_IS_OK(status) ? 0 : 1;
+}

vendor/current/source3/torture/vfstest.h

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    VFS module tester
@@ -13 +13 @@
    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 <http://www.gnu.org/licenses/>.
@@ -30 +30 @@
 struct vfs_state {
         struct connection_struct *conn;
+        uint64_t mid;
         struct files_struct *files[1024];
         DIR *currentdir;
@@ -35 +36 @@
         size_t data_size;
 };
+
+struct smb_request *vfstest_get_smbreq(TALLOC_CTX *mem_ctx,
+                                       struct vfs_state *vfs);
 
 struct cmd_set {
@@ -43 +47 @@
         const char *usage;
 };
+
+NTSTATUS cmd_test_chain(struct vfs_state *vfs, TALLOC_CTX *mem_ctx,
+                        int argc, const char **argv);

vendor/current/source3/torture/wbc_async.c

@@ -289 +289 @@
         subreq = async_connect_send(mem_ctx, ev, wb_ctx->fd,
                                     (struct sockaddr *)(void *)&sunaddr,
-                                    sizeof(sunaddr));
+                                    sizeof(sunaddr), NULL, NULL, NULL);
         if (subreq == NULL) {
                 goto nomem;
@@ -326 +326 @@
 static const char *winbindd_socket_dir(void)
 {
-#ifdef SOCKET_WRAPPER
-        const char *env_dir;
-
-        env_dir = getenv(WINBINDD_SOCKET_DIR_ENVVAR);
-        if (env_dir) {
-                return env_dir;
-        }
-#endif
+        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;
@@ -552 +552 @@
         if (!tevent_queue_add(wb_ctx->queue, ev, req, wb_trans_trigger,
                               NULL)) {
-                tevent_req_nomem(NULL, req);
+                tevent_req_oom(req);
                 return tevent_req_post(req, ev);
         }