s3: Remove unused "retry" from cli_full_connection
[nivanova/samba-autobuild/.git] / source3 / torture / torture.c
index 25a912dec5ffe868e975ecc43b4650dafc1420f5..1b492ce736b6f5a9d6e5f28dbc3f5c3584809859 100644 (file)
@@ -2,6 +2,7 @@
    Unix SMB/CIFS implementation.
    SMB torture tester
    Copyright (C) Andrew Tridgell 1997-1998
+   Copyright (C) Jeremy Allison 2009
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
 #include "includes.h"
 #include "wbc_async.h"
+#include "torture/proto.h"
+#include "libcli/security/security.h"
+#include "tldap.h"
+#include "tldap_util.h"
+#include "../librpc/gen_ndr/svcctl.h"
+#include "memcache.h"
+#include "nsswitch/winbind_client.h"
+#include "dbwrap.h"
+#include "talloc_dict.h"
+#include "async_smb.h"
 
 extern char *optarg;
 extern int optind;
@@ -40,28 +51,14 @@ static bool use_kerberos;
 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;
 
 bool torture_showall = False;
 
 static double create_procs(bool (*fn)(int), bool *result);
 
 
-static struct timeval tp1,tp2;
-
-
-void start_timer(void)
-{
-       GetTimeOfDay(&tp1);
-}
-
-double end_timer(void)
-{
-       GetTimeOfDay(&tp2);
-       return((tp2.tv_sec - tp1.tv_sec) + 
-              (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
-}
-
-
 /* return a pointer to a anonymous shared memory segment of size "size"
    which will persist across fork() but will disappear when all processes
    exit 
@@ -76,6 +73,23 @@ 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");
@@ -94,6 +108,7 @@ void *shm_setup(int size)
           See Stevens "advanced programming in unix env" for details
           */
        shmctl(shmid, IPC_RMID, 0);
+#endif
 
        return ret;
 }
@@ -116,10 +131,12 @@ static bool force_cli_encryption(struct cli_state *c,
                        return false;
        }
 
-       if (!cli_unix_extensions_version(c, &major, &minor, &caplow, &caphigh)) {
+       status = cli_unix_extensions_version(c, &major, &minor, &caplow,
+                                            &caphigh);
+       if (!NT_STATUS_IS_OK(status)) {
                d_printf("Encryption required and "
                        "can't get UNIX CIFS extensions "
-                       "version from server.\n");
+                       "version from server: %s\n", nt_errstr(status));
                return false;
        }
 
@@ -162,7 +179,7 @@ static struct cli_state *open_nbt_connection(void)
 
         zero_sockaddr(&ss);
 
-       if (!(c = cli_initialise())) {
+       if (!(c = cli_initialise_ex(signing_state))) {
                printf("Failed initialize cli_struct to connect with %s\n", host);
                return NULL;
        }
@@ -205,6 +222,120 @@ static struct cli_state *open_nbt_connection(void)
        return c;
 }
 
+/****************************************************************************
+ Send a corrupt session request. See rfc1002.txt 4.3 and 4.3.2.
+****************************************************************************/
+
+static bool cli_bad_session_request(struct cli_state *cli,
+                         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);
+
+       /* 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
+         * Remove four bytes from the length count, since the length
+         * field in the NBT Session Service header counts the number
+         * of bytes which follow.  The cli_send_smb() function knows
+         * about this and accounts for those four bytes.
+         * CRH.
+         */
+        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;
+        }
+        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;
+}
+
+
 /* Insert a NULL at the first separator of the given path and return a pointer
  * to the remainder of the string.
  */
@@ -267,7 +398,6 @@ static bool torture_open_connection_share(struct cli_state **c,
                                   const char *hostname, 
                                   const char *sharename)
 {
-       bool retry;
        int flags = 0;
        NTSTATUS status;
 
@@ -282,7 +412,7 @@ static bool torture_open_connection_share(struct cli_state **c,
                                     hostname, NULL, port_to_use, 
                                     sharename, "?????", 
                                     username, workgroup, 
-                                    password, flags, Undefined, &retry);
+                                    password, flags, signing_state);
        if (!NT_STATUS_IS_OK(status)) {
                printf("failed to open share connection: //%s/%s port:%d - %s\n",
                        hostname, sharename, port_to_use, nt_errstr(status));
@@ -357,8 +487,11 @@ bool torture_cli_session_setup2(struct cli_state *cli, uint16 *new_vuid)
 bool torture_close_connection(struct cli_state *c)
 {
        bool ret = True;
-       if (!cli_tdis(c)) {
-               printf("tdis failed (%s)\n", cli_errstr(c));
+       NTSTATUS status;
+
+       status = cli_tdis(c);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("tdis failed (%s)\n", nt_errstr(status));
                ret = False;
        }
 
@@ -492,7 +625,7 @@ static bool rw_torture(struct cli_state *c)
                        correct = False;
                }
 
-               if (!cli_unlock(c, fnum2, n*sizeof(int), sizeof(int))) {
+               if (!NT_STATUS_IS_OK(cli_unlock(c, fnum2, n*sizeof(int), sizeof(int)))) {
                        printf("unlock failed (%s)\n", cli_errstr(c));
                        correct = False;
                }
@@ -705,7 +838,7 @@ static bool rw_torture2(struct cli_state *c1, struct cli_state *c2)
 
 static bool run_readwritetest(int dummy)
 {
-       static struct cli_state *cli1, *cli2;
+       struct cli_state *cli1, *cli2;
        bool test1, test2 = False;
 
        if (!torture_open_connection(&cli1, 0) || !torture_open_connection(&cli2, 1)) {
@@ -754,7 +887,7 @@ static bool run_readwritemulti(int dummy)
        return test;
 }
 
-static bool run_readwritelarge(int dummy)
+static bool run_readwritelarge_internal(int max_xmit_k)
 {
        static struct cli_state *cli1;
        uint16_t fnum1;
@@ -769,9 +902,17 @@ static bool run_readwritelarge(int dummy)
        cli_sockopt(cli1, sockops);
        memset(buf,'\0',sizeof(buf));
 
-       cli1->max_xmit = 128*1024;
+       cli1->max_xmit = max_xmit_k*1024;
 
-       printf("starting readwritelarge\n");
+       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, aSYSTEM | aHIDDEN);
 
@@ -782,16 +923,18 @@ static bool run_readwritelarge(int dummy)
 
        cli_write(cli1, fnum1, 0, buf, 0, sizeof(buf));
 
-       if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, 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));
                correct = False;
        }
 
        if (fsize == sizeof(buf))
-               printf("readwritelarge test 1 succeeded (size = %lx)\n", 
+               printf("readwritelarge_internal test 1 succeeded (size = %lx)\n",
                       (unsigned long)fsize);
        else {
-               printf("readwritelarge test 1 failed (size = %lx)\n", 
+               printf("readwritelarge_internal test 1 failed (size = %lx)\n",
                       (unsigned long)fsize);
                correct = False;
        }
@@ -815,16 +958,18 @@ static bool run_readwritelarge(int dummy)
 
        cli_smbwrite(cli1, fnum1, buf, 0, sizeof(buf));
 
-       if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, 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));
                correct = False;
        }
 
        if (fsize == sizeof(buf))
-               printf("readwritelarge test 2 succeeded (size = %lx)\n", 
+               printf("readwritelarge_internal test 2 succeeded (size = %lx)\n",
                       (unsigned long)fsize);
        else {
-               printf("readwritelarge test 2 failed (size = %lx)\n", 
+               printf("readwritelarge_internal test 2 failed (size = %lx)\n",
                       (unsigned long)fsize);
                correct = False;
        }
@@ -835,7 +980,8 @@ static bool run_readwritelarge(int dummy)
                printf("set allocation size to zero failed (%s)\n", cli_errstr(&cli1));
                return False;
        }
-       if (!cli_qfileinfo(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL, NULL, NULL)) {
+       if (!cli_qfileinfo_basic(cli1, fnum1, NULL, &fsize, NULL, NULL, NULL,
+                                NULL, NULL)) {
                printf("qfileinfo failed (%s)\n", cli_errstr(cli1));
                correct = False;
        }
@@ -854,6 +1000,20 @@ static bool run_readwritelarge(int dummy)
        return correct;
 }
 
+static bool run_readwritelarge(int dummy)
+{
+       return run_readwritelarge_internal(128);
+}
+
+static bool run_readwritelarge_signtest(int dummy)
+{
+       bool ret;
+       signing_state = Required;
+       ret = run_readwritelarge_internal(2);
+       signing_state = Undefined;
+       return ret;
+}
+
 int line_count = 0;
 int nbio_id;
 
@@ -1185,8 +1345,9 @@ static bool run_tcon_test(int dummy)
 
        cli->cnum = cnum2;
 
-       if (!cli_tdis(cli)) {
-               printf("secondary tdis failed (%s)\n", cli_errstr(cli));
+       status = cli_tdis(cli);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("secondary tdis failed (%s)\n", nt_errstr(status));
                return False;
        }
 
@@ -1292,7 +1453,6 @@ static bool tcon_devtest(struct cli_state *cli,
 static bool run_tcon_devtype_test(int dummy)
 {
        static struct cli_state *cli1 = NULL;
-       bool retry;
        int flags = 0;
        NTSTATUS status;
        bool ret = True;
@@ -1301,7 +1461,7 @@ static bool run_tcon_devtype_test(int dummy)
                                     host, NULL, port_to_use,
                                     NULL, NULL,
                                     username, workgroup,
-                                    password, flags, Undefined, &retry);
+                                    password, flags, signing_state);
 
        if (!NT_STATUS_IS_OK(status)) {
                printf("could not open connection\n");
@@ -1429,12 +1589,12 @@ static bool run_locktest2(int dummy)
                printf("lock at 100 failed (%s)\n", cli_errstr(cli));
        }
        cli_setpid(cli, 2);
-       if (cli_unlock(cli, fnum1, 100, 4)) {
+       if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 100, 4))) {
                printf("unlock at 100 succeeded! This is a locking bug\n");
                correct = False;
        }
 
-       if (cli_unlock(cli, fnum1, 0, 4)) {
+       if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 4))) {
                printf("unlock1 succeeded! This is a locking bug\n");
                correct = False;
        } else {
@@ -1443,7 +1603,7 @@ static bool run_locktest2(int dummy)
                                 NT_STATUS_RANGE_NOT_LOCKED)) return False;
        }
 
-       if (cli_unlock(cli, fnum1, 0, 8)) {
+       if (NT_STATUS_IS_OK(cli_unlock(cli, fnum1, 0, 8))) {
                printf("unlock2 succeeded! This is a locking bug\n");
                correct = False;
        } else {
@@ -1565,14 +1725,14 @@ static bool run_locktest3(int dummy)
        for (offset=i=0;i<torture_numops;i++) {
                NEXT_OFFSET;
 
-               if (!cli_unlock(cli1, fnum1, offset-1, 1)) {
+               if (!NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, offset-1, 1))) {
                        printf("unlock1 %d failed (%s)\n", 
                               i,
                               cli_errstr(cli1));
                        return False;
                }
 
-               if (!cli_unlock(cli2, fnum2, offset-2, 1)) {
+               if (!NT_STATUS_IS_OK(cli_unlock(cli2, fnum2, offset-2, 1))) {
                        printf("unlock2 %d failed (%s)\n", 
                               i,
                               cli_errstr(cli1));
@@ -1703,7 +1863,7 @@ static bool run_locktest4(int dummy)
 
        ret = cli_lock(cli1, fnum1, 110, 4, 0, READ_LOCK) &&
              cli_lock(cli1, fnum1, 112, 4, 0, READ_LOCK) &&
-             cli_unlock(cli1, fnum1, 110, 6);
+             NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 110, 6));
        EXPECTED(ret, False);
        printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
 
@@ -1721,30 +1881,30 @@ static bool run_locktest4(int dummy)
 
        ret = cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
              cli_lock(cli1, fnum1, 140, 4, 0, READ_LOCK) &&
-             cli_unlock(cli1, fnum1, 140, 4) &&
-             cli_unlock(cli1, fnum1, 140, 4);
+             NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4)) &&
+             NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 140, 4));
        EXPECTED(ret, True);
        printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
 
 
        ret = cli_lock(cli1, fnum1, 150, 4, 0, WRITE_LOCK) &&
              cli_lock(cli1, fnum1, 150, 4, 0, READ_LOCK) &&
-             cli_unlock(cli1, fnum1, 150, 4) &&
+             NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4)) &&
              (cli_read(cli2, fnum2, buf, 150, 4) == 4) &&
              !(cli_write(cli2, fnum2, 0, buf, 150, 4) == 4) &&
-             cli_unlock(cli1, fnum1, 150, 4);
+             NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 150, 4));
        EXPECTED(ret, True);
        printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
 
        ret = cli_lock(cli1, fnum1, 160, 4, 0, READ_LOCK) &&
-             cli_unlock(cli1, fnum1, 160, 4) &&
+             NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 160, 4)) &&
              (cli_write(cli2, fnum2, 0, buf, 160, 4) == 4) &&          
              (cli_read(cli2, fnum2, buf, 160, 4) == 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) &&
-             cli_unlock(cli1, fnum1, 170, 4) &&
+             NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 170, 4)) &&
              (cli_write(cli2, fnum2, 0, buf, 170, 4) == 4) &&          
              (cli_read(cli2, fnum2, buf, 170, 4) == 4);                
        EXPECTED(ret, True);
@@ -1752,7 +1912,7 @@ static bool run_locktest4(int dummy)
 
        ret = cli_lock(cli1, fnum1, 190, 4, 0, WRITE_LOCK) &&
              cli_lock(cli1, fnum1, 190, 4, 0, READ_LOCK) &&
-             cli_unlock(cli1, fnum1, 190, 4) &&
+             NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 190, 4)) &&
              !(cli_write(cli2, fnum2, 0, buf, 190, 4) == 4) &&         
              (cli_read(cli2, fnum2, buf, 190, 4) == 4);                
        EXPECTED(ret, True);
@@ -1861,7 +2021,7 @@ static bool run_locktest5(int dummy)
        /* Unlock the first process lock, then check this was the WRITE lock that was
                removed. */
 
-       ret = cli_unlock(cli1, fnum1, 0, 4) &&
+       ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
                        cli_lock(cli2, fnum2, 0, 4, 0, READ_LOCK);
 
        EXPECTED(ret, True);
@@ -1872,15 +2032,15 @@ static bool run_locktest5(int dummy)
 
        /* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
 
-       ret = cli_unlock(cli1, fnum1, 1, 1) &&
-                 cli_unlock(cli1, fnum1, 0, 4) &&
-                 cli_unlock(cli1, fnum1, 0, 4);
+       ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 1, 1)) &&
+                 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4)) &&
+                 NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
 
        EXPECTED(ret, True);
        printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot"); 
 
        /* Ensure the next unlock fails. */
-       ret = cli_unlock(cli1, fnum1, 0, 4);
+       ret = NT_STATUS_IS_OK(cli_unlock(cli1, fnum1, 0, 4));
        EXPECTED(ret, False);
        printf("the same process %s count the lock stack\n", !ret?"can":"cannot"); 
 
@@ -2157,6 +2317,209 @@ fail:
        return correct;
 }
 
+/*
+ * This test is designed to be run in conjunction with
+ * external NFS or POSIX locks taken in the filesystem.
+ * It checks that the smbd server will block until the
+ * lock is released and then acquire it. JRA.
+ */
+
+static bool got_alarm;
+static int alarm_fd;
+
+static void alarm_handler(int dummy)
+{
+        got_alarm = True;
+}
+
+static void alarm_handler_parent(int dummy)
+{
+       close(alarm_fd);
+}
+
+static void do_local_lock(int read_fd, int write_fd)
+{
+       int fd;
+       char c = '\0';
+       struct flock lock;
+       const char *local_pathname = NULL;
+       int ret;
+
+       local_pathname = talloc_asprintf(talloc_tos(),
+                       "%s/lockt9.lck", local_path);
+       if (!local_pathname) {
+               printf("child: alloc fail\n");
+               exit(1);
+       }
+
+       unlink(local_pathname);
+       fd = open(local_pathname, O_RDWR|O_CREAT, 0666);
+       if (fd == -1) {
+               printf("child: open of %s failed %s.\n",
+                       local_pathname, strerror(errno));
+               exit(1);
+       }
+
+       /* Now take a fcntl lock. */
+       lock.l_type = F_WRLCK;
+       lock.l_whence = SEEK_SET;
+       lock.l_start = 0;
+       lock.l_len = 4;
+       lock.l_pid = getpid();
+
+       ret = fcntl(fd,F_SETLK,&lock);
+       if (ret == -1) {
+               printf("child: failed to get lock 0:4 on file %s. Error %s\n",
+                       local_pathname, strerror(errno));
+               exit(1);
+       } else {
+               printf("child: got lock 0:4 on file %s.\n",
+                       local_pathname );
+               fflush(stdout);
+       }
+
+       CatchSignal(SIGALRM, alarm_handler);
+       alarm(5);
+       /* Signal the parent. */
+       if (write(write_fd, &c, 1) != 1) {
+               printf("child: start signal fail %s.\n",
+                       strerror(errno));
+               exit(1);
+       }
+       alarm(0);
+
+       alarm(10);
+       /* Wait for the parent to be ready. */
+       if (read(read_fd, &c, 1) != 1) {
+               printf("child: reply signal fail %s.\n",
+                       strerror(errno));
+               exit(1);
+       }
+       alarm(0);
+
+       sleep(5);
+       close(fd);
+       printf("child: released lock 0:4 on file %s.\n",
+               local_pathname );
+       fflush(stdout);
+       exit(0);
+}
+
+static bool run_locktest9(int dummy)
+{
+       struct cli_state *cli1;
+       const char *fname = "\\lockt9.lck";
+       uint16_t fnum;
+       bool correct = False;
+       int pipe_in[2], pipe_out[2];
+       pid_t child_pid;
+       char c = '\0';
+       int ret;
+       struct timeval start;
+       double seconds;
+       NTSTATUS status;
+
+       printf("starting locktest9\n");
+
+       if (local_path == NULL) {
+               d_fprintf(stderr, "locktest9 must be given a local path via -l <localpath>\n");
+               return false;
+       }
+
+       if (pipe(pipe_in) == -1 || pipe(pipe_out) == -1) {
+               return false;
+       }
+
+       child_pid = fork();
+       if (child_pid == -1) {
+               return false;
+       }
+
+       if (child_pid == 0) {
+               /* Child. */
+               do_local_lock(pipe_out[0], pipe_in[1]);
+               exit(0);
+       }
+
+       close(pipe_out[0]);
+       close(pipe_in[1]);
+       pipe_out[0] = -1;
+       pipe_in[1] = -1;
+
+       /* Parent. */
+       ret = read(pipe_in[0], &c, 1);
+       if (ret != 1) {
+               d_fprintf(stderr, "failed to read start signal from child. %s\n",
+                       strerror(errno));
+               return false;
+       }
+
+       if (!torture_open_connection(&cli1, 0)) {
+               return false;
+       }
+
+       cli_sockopt(cli1, sockops);
+
+       status = cli_open(cli1, fname, O_RDWR, DENY_NONE,
+                         &fnum);
+       if (!NT_STATUS_IS_OK(status)) {
+               d_fprintf(stderr, "cli_open returned %s\n", cli_errstr(cli1));
+               return false;
+       }
+
+       /* Ensure the child has the lock. */
+       if (cli_lock(cli1, fnum, 0, 4, 0, WRITE_LOCK)) {
+               d_fprintf(stderr, "Got the lock on range 0:4 - this should not happen !\n");
+               goto fail;
+       } else {
+               d_printf("Child has the lock.\n");
+       }
+
+       /* Tell the child to wait 5 seconds then exit. */
+       ret = write(pipe_out[1], &c, 1);
+       if (ret != 1) {
+               d_fprintf(stderr, "failed to send exit signal to child. %s\n",
+                       strerror(errno));
+               goto fail;
+       }
+
+       /* Wait 20 seconds for the lock. */
+       alarm_fd = cli1->fd;
+       CatchSignal(SIGALRM, alarm_handler_parent);
+       alarm(20);
+
+       start = timeval_current();
+
+       if (!cli_lock(cli1, fnum, 0, 4, -1, WRITE_LOCK)) {
+               d_fprintf(stderr, "Unable to apply write lock on range 0:4, error was "
+                      "%s\n", cli_errstr(cli1));
+               goto fail_nofd;
+       }
+       alarm(0);
+
+       seconds = timeval_elapsed(&start);
+
+       printf("Parent got the lock after %.2f seconds.\n",
+               seconds);
+
+       status = cli_close(cli1, fnum);
+       if (!NT_STATUS_IS_OK(status)) {
+               d_fprintf(stderr, "cli_close(fnum1) %s\n", cli_errstr(cli1));
+               goto fail;
+       }
+
+       correct = true;
+
+fail:
+       cli_close(cli1, fnum);
+       torture_close_connection(cli1);
+
+fail_nofd:
+
+       printf("finished locktest9\n");
+       return correct;
+}
+
 /*
 test whether fnums and tids open on one VC are available on another (a major
 security hole)
@@ -2431,6 +2794,21 @@ static bool run_negprot_nowait(int dummy)
        return correct;
 }
 
+/* send smb negprot commands, not reading the response */
+static bool run_bad_nbt_session(int dummy)
+{
+       static struct cli_state *cli;
+
+       printf("starting bad nbt session test\n");
+
+       if (!(cli = open_bad_nbt_connection())) {
+               return False;
+       }
+
+       cli_shutdown(cli);
+       printf("finished bad nbt session test\n");
+       return true;
+}
 
 /* send random IPC commands */
 static bool run_randomipc(int dummy)
@@ -2603,6 +2981,8 @@ static bool run_trans2test(int dummy)
        const char *fname2 = "\\trans2\\trans2.tst";
        char pname[1024];
        bool correct = True;
+       NTSTATUS status;
+       uint32_t fs_attr;
 
        printf("starting trans2 test\n");
 
@@ -2610,16 +2990,25 @@ static bool run_trans2test(int dummy)
                return False;
        }
 
+       status = cli_get_fs_attr_info(cli, &fs_attr);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("ERROR: cli_get_fs_attr_info returned %s\n",
+                      nt_errstr(status));
+               correct = false;
+       }
+
        cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
        cli_open(cli, fname, 
                        O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
-       if (!cli_qfileinfo(cli, fnum, NULL, &size, &c_time_ts, &a_time_ts, &w_time_ts,
-                          &m_time_ts, NULL)) {
+       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));
                correct = False;
        }
 
-       if (!cli_qfilename(cli, fnum, pname, sizeof(pname))) {
+       if (!NT_STATUS_IS_OK(cli_qfilename(cli, fnum, pname, sizeof(pname)))) {
                printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli));
                correct = False;
        }
@@ -2642,8 +3031,10 @@ static bool run_trans2test(int dummy)
        }
        cli_close(cli, fnum);
 
-       if (!cli_qpathinfo(cli, fname, &c_time, &a_time, &m_time, &size, NULL)) {
-               printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli));
+       status = cli_qpathinfo1(cli, fname, &c_time, &a_time, &m_time, &size,
+                               NULL);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("ERROR: qpathinfo failed (%s)\n", nt_errstr(status));
                correct = False;
        } else {
                if (c_time != m_time) {
@@ -2668,9 +3059,10 @@ static bool run_trans2test(int dummy)
        cli_open(cli, fname, 
                        O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
        cli_close(cli, fnum);
-       if (!cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts, 
-                           &m_time_ts, &size, NULL, NULL)) {
-               printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
+       status = cli_qpathinfo2(cli, fname, &c_time_ts, &a_time_ts, &w_time_ts,
+                               &m_time_ts, &size, NULL, NULL);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
                correct = False;
        } else {
                if (w_time_ts.tv_sec < 60*60*24*2) {
@@ -2690,9 +3082,10 @@ static bool run_trans2test(int dummy)
                correct = False;
        }
        sleep(3);
-       if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts, 
-                           &m_time_ts, &size, NULL, NULL)) {
-               printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
+       status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
+                               &w_time_ts, &m_time_ts, &size, NULL, NULL);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
                correct = False;
        }
 
@@ -2700,9 +3093,10 @@ static bool run_trans2test(int dummy)
                        O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum);
        cli_write(cli, fnum,  0, (char *)&fnum, 0, sizeof(fnum));
        cli_close(cli, fnum);
-       if (!cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts, &w_time_ts, 
-                           &m_time2_ts, &size, NULL, NULL)) {
-               printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli));
+       status = cli_qpathinfo2(cli, "\\trans2\\", &c_time_ts, &a_time_ts,
+                               &w_time_ts, &m_time2_ts, &size, NULL, NULL);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("ERROR: qpathinfo2 failed (%s)\n", nt_errstr(status));
                correct = False;
        } else {
                if (memcmp(&m_time_ts, &m_time2_ts, sizeof(struct timespec))
@@ -2727,22 +3121,24 @@ static bool run_trans2test(int dummy)
   This checks new W2K calls.
 */
 
-static bool new_trans(struct cli_state *pcli, int fnum, int level)
+static NTSTATUS new_trans(struct cli_state *pcli, int fnum, int level)
 {
-       char *buf = NULL;
+       uint8_t *buf = NULL;
        uint32 len;
-       bool correct = True;
+       NTSTATUS status;
 
-       if (!cli_qfileinfo_test(pcli, fnum, level, &buf, &len)) {
-               printf("ERROR: qfileinfo (%d) failed (%s)\n", level, cli_errstr(pcli));
-               correct = False;
+       status = cli_qfileinfo(talloc_tos(), pcli, fnum, level, 0,
+                              pcli->max_xmit, &buf, &len);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("ERROR: qfileinfo (%d) failed (%s)\n", level,
+                      nt_errstr(status));
        } else {
                printf("qfileinfo: level %d, len = %u\n", level, len);
                dump_data(0, (uint8 *)buf, len);
                printf("\n");
        }
-       SAFE_FREE(buf);
-       return correct;
+       TALLOC_FREE(buf);
+       return status;
 }
 
 static bool run_w2ktest(int dummy)
@@ -3054,17 +3450,6 @@ static bool run_deletetest(int dummy)
                goto fail;
        }
 
-#if 0 /* JRATEST */
-        {
-                uint32 *accinfo = NULL;
-                uint32 len;
-                cli_qfileinfo_test(cli1, fnum1, SMB_FILE_ACCESS_INFORMATION, (char **)&accinfo, &len);
-               if (accinfo)
-                       printf("access mode = 0x%lx\n", *accinfo);
-                SAFE_FREE(accinfo);
-        }
-#endif
-
        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
                printf("[1] close failed (%s)\n", cli_errstr(cli1));
                correct = False;
@@ -3092,7 +3477,7 @@ static bool run_deletetest(int dummy)
                goto fail;
        }
 
-       if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+       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;
                goto fail;
@@ -3145,7 +3530,7 @@ static bool run_deletetest(int dummy)
                goto fail;
        }
 
-       if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+       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;
                goto fail;
@@ -3201,7 +3586,7 @@ static bool run_deletetest(int dummy)
                goto fail;
        }
 
-       if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+       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;
                goto fail;
@@ -3235,7 +3620,7 @@ static bool run_deletetest(int dummy)
 
        /* This should fail - only allowed on NT opens with DELETE access. */
 
-       if (cli_nt_delete_on_close(cli1, fnum1, True)) {
+       if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
                printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
                correct = False;
                goto fail;
@@ -3263,7 +3648,7 @@ static bool run_deletetest(int dummy)
 
        /* This should fail - only allowed on NT opens with DELETE access. */
 
-       if (cli_nt_delete_on_close(cli1, fnum1, True)) {
+       if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
                printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
                correct = False;
                goto fail;
@@ -3288,13 +3673,13 @@ static bool run_deletetest(int dummy)
                goto fail;
        }
 
-       if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+       if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
                printf("[7] setting delete_on_close on file failed !\n");
                correct = False;
                goto fail;
        }
 
-       if (!cli_nt_delete_on_close(cli1, fnum1, False)) {
+       if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, false))) {
                printf("[7] unsetting delete_on_close on file failed !\n");
                correct = False;
                goto fail;
@@ -3350,7 +3735,7 @@ static bool run_deletetest(int dummy)
                goto fail;
        }
 
-       if (!cli_nt_delete_on_close(cli1, fnum1, True)) {
+       if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum1, true))) {
                printf("[8] setting delete_on_close on file failed !\n");
                correct = False;
                goto fail;
@@ -3566,6 +3951,7 @@ static bool run_rename(int dummy)
        const char *fname1 = "\\test1.txt";
        bool correct = True;
        uint16_t fnum1;
+       uint16_t attr;
        NTSTATUS status;
 
        printf("starting rename test\n");
@@ -3639,7 +4025,7 @@ static bool run_rename(int dummy)
                printf("Fourth open failed - %s\n", cli_errstr(cli1));
                return False;
        }
-       if (!cli_nt_delete_on_close(cli1, fnum2, True)) {
+       if (!NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1, fnum2, true))) {
                printf("[8] setting delete_on_close on file failed !\n");
                return False;
        }
@@ -3720,13 +4106,30 @@ static bool run_rename(int dummy)
           } */
 
         /*--*/
-
-
        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
                printf("close - 5 failed (%s)\n", cli_errstr(cli1));
                return False;
        }
 
+       /* Check that the renamed file has FILE_ATTRIBUTE_ARCHIVE. */
+       if (!NT_STATUS_IS_OK(cli_getatr(cli1, fname1, &attr, NULL, NULL))) {
+               printf("getatr on file %s failed - %s ! \n",
+                       fname1,
+                       cli_errstr(cli1));
+               correct = False;
+       } else {
+               if (attr != FILE_ATTRIBUTE_ARCHIVE) {
+                       printf("Renamed file %s has wrong attr 0x%x "
+                               "(should be 0x%x)\n",
+                               fname1,
+                               attr,
+                               (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
+                       correct = False;
+               } else {
+                       printf("Renamed file %s has archive bit set\n", fname1);
+               }
+       }
+
        cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
        cli_unlink(cli1, fname1, aSYSTEM | aHIDDEN);
 
@@ -3906,10 +4309,8 @@ static bool run_opentest(int dummy)
 
        cli_unlink(cli1, fname, aSYSTEM | aHIDDEN);
 
-
-       printf("testing ctemp\n");
-       fnum1 = cli_ctemp(cli1, "\\", &tmp_path);
-       if (fnum1 == (uint16_t)-1) {
+       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;
        }
@@ -3936,22 +4337,22 @@ static bool run_opentest(int dummy)
 
        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));
+               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));
+               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));
+               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));
+               printf("TEST #1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
                return False;
        }
 
@@ -3963,22 +4364,22 @@ static bool run_opentest(int dummy)
 
        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));
+               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));
+               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 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
+               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 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
+               printf("TEST #2 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1));
                return False;
        }
 
@@ -3990,22 +4391,22 @@ static bool run_opentest(int dummy)
 
        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));
+               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));
+               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));
+               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));
+               printf("TEST #3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
                return False;
        }
 
@@ -4017,20 +4418,20 @@ static bool run_opentest(int dummy)
 
        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));
+               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));
+               printf("TEST #4 open 2 of %s SUCCEEDED - should have failed (%s)\n", fname, cli_errstr(cli2));
                return False;
        }
 
-       printf("test 3 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2), "sharing violation");
+       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));
+               printf("TEST #4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
                return False;
        }
 
@@ -4042,23 +4443,23 @@ static bool run_opentest(int dummy)
 
        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));
+               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));
+               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));
+               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));
+               printf("TEST #5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
                return False;
        }
 
@@ -4070,23 +4471,23 @@ static bool run_opentest(int dummy)
 
        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));
+               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));
+               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));
+               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));
+               printf("TEST #6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2));
                return False;
        }
 
@@ -4098,20 +4499,20 @@ static bool run_opentest(int dummy)
 
        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));
+               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));
+               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");
+       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));
+               printf("TEST #7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1));
                return False;
        }
 
@@ -4129,18 +4530,52 @@ static bool run_opentest(int dummy)
        return correct;
 }
 
+NTSTATUS torture_setup_unix_extensions(struct cli_state *cli)
+{
+       uint16 major, minor;
+       uint32 caplow, caphigh;
+       NTSTATUS status;
+
+       if (!SERVER_HAS_UNIX_CIFS(cli)) {
+               printf("Server doesn't support UNIX CIFS extensions.\n");
+               return NT_STATUS_NOT_SUPPORTED;
+       }
+
+       status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
+                                            &caphigh);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("Server didn't return UNIX CIFS extensions: %s\n",
+                      nt_errstr(status));
+               return status;
+       }
+
+       status = cli_set_unix_extensions_capabilities(cli, major, minor,
+                                                     caplow, caphigh);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("Server doesn't support setting UNIX CIFS extensions: "
+                      "%s.\n", nt_errstr(status));
+               return status;
+        }
+
+       return NT_STATUS_OK;
+}
+
 /*
   Test POSIX open /mkdir calls.
  */
 static bool run_simple_posix_open_test(int dummy)
 {
        static struct cli_state *cli1;
-       const char *fname = "\\posix:file";
-       const char *dname = "\\posix:dir";
-       uint16 major, minor;
-       uint32 caplow, caphigh;
+       const char *fname = "posix:file";
+       const char *hname = "posix:hlink";
+       const char *sname = "posix:symlink";
+       const char *dname = "posix:dir";
+       char buf[10];
+       char namebuf[11];
        uint16_t fnum1 = (uint16_t)-1;
+       SMB_STRUCT_STAT sbuf;
        bool correct = false;
+       NTSTATUS status;
 
        printf("Starting simple POSIX open test\n");
 
@@ -4150,27 +4585,19 @@ static bool run_simple_posix_open_test(int dummy)
 
        cli_sockopt(cli1, sockops);
 
-       if (!SERVER_HAS_UNIX_CIFS(cli1)) {
-               printf("Server doesn't support UNIX CIFS extensions.\n");
-               return false;
-       }
-
-       if (!cli_unix_extensions_version(cli1, &major,
-                       &minor, &caplow, &caphigh)) {
-               printf("Server didn't return UNIX CIFS extensions.\n");
+       status = torture_setup_unix_extensions(cli1);
+       if (!NT_STATUS_IS_OK(status)) {
                return false;
        }
 
-       if (!cli_set_unix_extensions_capabilities(cli1,
-                       major, minor, caplow, caphigh)) {
-               printf("Server doesn't support setting UNIX CIFS extensions.\n");
-               return false;
-        }
-
        cli_setatr(cli1, fname, 0, 0);
        cli_posix_unlink(cli1, fname);
        cli_setatr(cli1, dname, 0, 0);
        cli_posix_rmdir(cli1, dname);
+       cli_setatr(cli1, hname, 0, 0);
+       cli_posix_unlink(cli1, hname);
+       cli_setatr(cli1, sname, 0, 0);
+       cli_posix_unlink(cli1, sname);
 
        /* Create a directory. */
        if (!NT_STATUS_IS_OK(cli_posix_mkdir(cli1, dname, 0777))) {
@@ -4183,6 +4610,29 @@ static bool run_simple_posix_open_test(int dummy)
                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));
+               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));
+               goto out;
+       }
+
+       if (sbuf.st_ex_size != 1000) {
+               printf("ftruncate - stat size (%u) != 1000\n", (unsigned int)sbuf.st_ex_size);
+               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));
+               goto out;
+       }
+
        if (!NT_STATUS_IS_OK(cli_close(cli1, fnum1))) {
                printf("close failed (%s)\n", cli_errstr(cli1));
                goto out;
@@ -4211,6 +4661,100 @@ static bool run_simple_posix_open_test(int dummy)
                goto out;
        }
 
+       /* What happens when we try and POSIX open a directory ? */
+       if (NT_STATUS_IS_OK(cli_posix_open(cli1, dname, O_RDONLY, 0, &fnum1))) {
+               printf("POSIX open of directory %s succeeded, should have failed.\n", fname);
+               goto out;
+       } else {
+               if (!check_error(__LINE__, cli1, ERRDOS, EISDIR,
+                               NT_STATUS_FILE_IS_A_DIRECTORY)) {
+                       goto out;
+               }
+       }
+
+       /* 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));
+               goto out;
+       }
+
+       /* Write some data into it. */
+       if (cli_write(cli1, fnum1, 0, "TEST DATA\n", 0, 10) != 10) {
+               printf("cli_write failed: %s\n", cli_errstr(cli1));
+               goto out;
+       }
+
+       cli_close(cli1, fnum1);
+
+       /* 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));
+               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));
+               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));
+               goto out;
+       }
+
+       if (cli_read(cli1, fnum1, buf, 0, 10) != 10) {
+               printf("POSIX read of %s failed (%s)\n", hname, cli_errstr(cli1));
+               goto out;
+       }
+
+       if (memcmp(buf, "TEST DATA\n", 10)) {
+               printf("invalid data read from hardlink\n");
+               goto out;
+       }
+
+       /* 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));
+               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));
+               goto out;
+       }
+
+       cli_close(cli1, fnum1);
+
+       /* Open the symlink for read - this should fail. A POSIX
+          client should not be doing opens on a symlink. */
+       if (NT_STATUS_IS_OK(cli_posix_open(cli1, sname, O_RDONLY, 0, &fnum1))) {
+               printf("POSIX open of %s succeeded (should have failed)\n", sname);
+               goto out;
+       } else {
+               if (!check_error(__LINE__, cli1, 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));
+                       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));
+               goto out;
+       }
+
+       if (strcmp(namebuf, fname) != 0) {
+               printf("POSIX readlink on %s failed to match name %s (read %s)\n",
+                       sname, fname, namebuf);
+               goto out;
+       }
+
        if (!NT_STATUS_IS_OK(cli_posix_rmdir(cli1, dname))) {
                printf("POSIX rmdir failed (%s)\n", cli_errstr(cli1));
                goto out;
@@ -4221,11 +4765,15 @@ static bool run_simple_posix_open_test(int dummy)
 
   out:
 
-       if (fnum1 != -1) {
+       if (fnum1 != (uint16_t)-1) {
                cli_close(cli1, fnum1);
-               fnum1 = -1;
+               fnum1 = (uint16_t)-1;
        }
 
+       cli_setatr(cli1, sname, 0, 0);
+       cli_posix_unlink(cli1, sname);
+       cli_setatr(cli1, hname, 0, 0);
+       cli_posix_unlink(cli1, hname);
        cli_setatr(cli1, fname, 0, 0);
        cli_posix_unlink(cli1, fname);
        cli_setatr(cli1, dname, 0, 0);
@@ -4396,9 +4944,14 @@ static bool run_openattrtest(int dummy)
        return correct;
 }
 
-static void list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
+static NTSTATUS list_fn(const char *mnt, struct file_info *finfo,
+                   const char *name, void *state)
 {
-
+       int *matched = (int *)state;
+       if (matched != NULL) {
+               *matched += 1;
+       }
+       return NT_STATUS_OK;
 }
 
 /*
@@ -4409,8 +4962,9 @@ static bool run_dirtest(int dummy)
        int i;
        static struct cli_state *cli;
        uint16_t fnum;
-       double t1;
+       struct timeval core_start;
        bool correct = True;
+       int matched;
 
        printf("starting directory test\n");
 
@@ -4431,13 +4985,21 @@ static bool run_dirtest(int dummy)
                cli_close(cli, fnum);
        }
 
-       t1 = end_timer();
+       core_start = timeval_current();
 
-       printf("Matched %d\n", cli_list(cli, "a*.*", 0, list_fn, NULL));
-       printf("Matched %d\n", cli_list(cli, "b*.*", 0, list_fn, NULL));
-       printf("Matched %d\n", cli_list(cli, "xyzabc", 0, list_fn, NULL));
+       matched = 0;
+       cli_list(cli, "a*.*", 0, list_fn, &matched);
+       printf("Matched %d\n", matched);
+
+       matched = 0;
+       cli_list(cli, "b*.*", 0, list_fn, &matched);
+       printf("Matched %d\n", matched);
+
+       matched = 0;
+       cli_list(cli, "xyzabc", 0, list_fn, &matched);
+       printf("Matched %d\n", matched);
 
-       printf("dirtest core %g seconds\n", end_timer() - t1);
+       printf("dirtest core %g seconds\n", timeval_elapsed(&core_start));
 
        srandom(0);
        for (i=0;i<torture_numops;i++) {
@@ -4455,14 +5017,15 @@ static bool run_dirtest(int dummy)
        return correct;
 }
 
-static void del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
+static NTSTATUS del_fn(const char *mnt, struct file_info *finfo, const char *mask,
+                  void *state)
 {
        struct cli_state *pcli = (struct cli_state *)state;
        fstring fname;
        slprintf(fname, sizeof(fname), "\\LISTDIR\\%s", finfo->name);
 
        if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
-               return;
+               return NT_STATUS_OK;
 
        if (finfo->mode & aDIR) {
                if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
@@ -4471,6 +5034,7 @@ static void del_fn(const char *mnt, file_info *finfo, const char *mask, void *st
                if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, aSYSTEM | aHIDDEN)))
                        printf("del_fn: failed to unlink %s\n,", fname );
        }
+       return NT_STATUS_OK;
 }
 
 
@@ -4500,13 +5064,13 @@ bool torture_ioctl_test(int dummy)
        }
 
        status = cli_raw_ioctl(cli, fnum, 0x2d0000 | (0x0420<<2), &blob);
-       printf("ioctl device info: %s\n", cli_errstr(cli));
+       printf("ioctl device info: %s\n", nt_errstr(status));
 
        status = cli_raw_ioctl(cli, fnum, IOCTL_QUERY_JOB_INFO, &blob);
-       printf("ioctl job info: %s\n", cli_errstr(cli));
+       printf("ioctl job info: %s\n", nt_errstr(status));
 
        for (device=0;device<0x100;device++) {
-               printf("testing device=0x%x\n", device);
+               printf("ioctl test with device = 0x%x\n", device);
                for (function=0;function<0x100;function++) {
                        uint32 code = (device<<16) | function;
 
@@ -4619,6 +5183,7 @@ static bool run_eatest(int dummy)
        size_t num_eas;
        struct ea_struct *ea_list = NULL;
        TALLOC_CTX *mem_ctx = talloc_init("eatest");
+       NTSTATUS status;
 
        printf("starting eatest\n");
 
@@ -4642,8 +5207,10 @@ static bool run_eatest(int dummy)
 
                slprintf(ea_name, sizeof(ea_name), "EA_%d", i);
                memset(ea_val, (char)i+1, i+1);
-               if (!cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1)) {
-                       printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
+               status = cli_set_ea_fnum(cli, fnum, ea_name, ea_val, i+1);
+               if (!NT_STATUS_IS_OK(status)) {
+                       printf("ea_set of name %s failed - %s\n", ea_name,
+                              nt_errstr(status));
                        talloc_destroy(mem_ctx);
                        return False;
                }
@@ -4655,15 +5222,18 @@ static bool run_eatest(int dummy)
 
                slprintf(ea_name, sizeof(ea_name), "EA_%d", i+10);
                memset(ea_val, (char)i+1, i+1);
-               if (!cli_set_ea_path(cli, fname, ea_name, ea_val, i+1)) {
-                       printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
+               status = cli_set_ea_path(cli, fname, ea_name, ea_val, i+1);
+               if (!NT_STATUS_IS_OK(status)) {
+                       printf("ea_set of name %s failed - %s\n", ea_name,
+                              nt_errstr(status));
                        talloc_destroy(mem_ctx);
                        return False;
                }
        }
 
-       if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
-               printf("ea_get list failed - %s\n", cli_errstr(cli));
+       status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("ea_get list failed - %s\n", nt_errstr(status));
                correct = False;
        }
 
@@ -4689,16 +5259,19 @@ static bool run_eatest(int dummy)
        for (i = 0; i < 20; i++) {
                fstring ea_name;
                slprintf(ea_name, sizeof(ea_name), "ea_%d", i);
-               if (!cli_set_ea_path(cli, fname, ea_name, "", 0)) {
-                       printf("ea_set of name %s failed - %s\n", ea_name, cli_errstr(cli));
+               status = cli_set_ea_path(cli, fname, ea_name, "", 0);
+               if (!NT_STATUS_IS_OK(status)) {
+                       printf("ea_set of name %s failed - %s\n", ea_name,
+                              nt_errstr(status));
                        talloc_destroy(mem_ctx);
                        return False;
                }
        }
 #endif
 
-       if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list)) {
-               printf("ea_get list failed - %s\n", cli_errstr(cli));
+       status = cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("ea_get list failed - %s\n", nt_errstr(status));
                correct = False;
        }
 
@@ -4715,8 +5288,10 @@ static bool run_eatest(int dummy)
        }
 
        /* Try and delete a non existant EA. */
-       if (!cli_set_ea_path(cli, fname, "foo", "", 0)) {
-               printf("deleting non-existant EA 'foo' should succeed. %s\n", cli_errstr(cli));
+       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",
+                      nt_errstr(status));
                correct = False;
        }
 
@@ -4770,7 +5345,8 @@ static bool run_dirtest1(int dummy)
        }
 
        /* Now ensure that doing an old list sees both files and directories. */
-       num_seen = cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, NULL);
+       num_seen = 0;
+       cli_list_old(cli, "\\LISTDIR\\*", aDIR, list_fn, &num_seen);
        printf("num_seen = %d\n", num_seen );
        /* We should see 100 files + 1000 directories + . and .. */
        if (num_seen != 2002)
@@ -4779,12 +5355,14 @@ static bool run_dirtest1(int dummy)
        /* Ensure if we have the "must have" bits we only see the
         * relevent entries.
         */
-       num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, NULL);
+       num_seen = 0;
+       cli_list_old(cli, "\\LISTDIR\\*", (aDIR<<8)|aDIR, list_fn, &num_seen);
        printf("num_seen = %d\n", num_seen );
        if (num_seen != 1002)
                correct = False;
 
-       num_seen = cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, NULL);
+       num_seen = 0;
+       cli_list_old(cli, "\\LISTDIR\\*", (aARCH<<8)|aDIR, list_fn, &num_seen);
        printf("num_seen = %d\n", num_seen );
        if (num_seen != 1000)
                correct = False;
@@ -4956,9 +5534,10 @@ static bool run_sesssetup_bench(int dummy)
 
                d_printf("\r%d   ", (int)c->vuid);
 
-               if (!cli_ulogoff(c)) {
+               status = cli_ulogoff(c);
+               if (!NT_STATUS_IS_OK(status)) {
                        d_printf("(%s) cli_ulogoff failed: %s\n",
-                                __location__, cli_errstr(c));
+                                __location__, nt_errstr(status));
                        return false;
                }
                c->vuid = 0;
@@ -5093,7 +5672,9 @@ static bool run_chain2(int dummy)
        NTSTATUS status;
 
        printf("starting chain2 test\n");
-       if (!torture_open_connection(&cli1, 0)) {
+       status = cli_start_connection(&cli1, global_myname(), host, NULL,
+                                     port_to_use, Undefined, 0, NULL);
+       if (!NT_STATUS_IS_OK(status)) {
                return False;
        }
 
@@ -5122,6 +5703,409 @@ static bool run_chain2(int dummy)
        return True;
 }
 
+
+struct torture_createdel_state {
+       struct tevent_context *ev;
+       struct cli_state *cli;
+};
+
+static void torture_createdel_created(struct tevent_req *subreq);
+static void torture_createdel_closed(struct tevent_req *subreq);
+
+static struct tevent_req *torture_createdel_send(TALLOC_CTX *mem_ctx,
+                                                struct tevent_context *ev,
+                                                struct cli_state *cli,
+                                                const char *name)
+{
+       struct tevent_req *req, *subreq;
+       struct torture_createdel_state *state;
+
+       req = tevent_req_create(mem_ctx, &state,
+                               struct torture_createdel_state);
+       if (req == NULL) {
+               return NULL;
+       }
+       state->ev = ev;
+       state->cli = cli;
+
+       subreq = cli_ntcreate_send(
+               state, ev, cli, name, 0,
+               FILE_READ_DATA|FILE_WRITE_DATA|DELETE_ACCESS,
+               FILE_ATTRIBUTE_NORMAL,
+               FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+               FILE_OPEN_IF, FILE_DELETE_ON_CLOSE, 0);
+
+       if (tevent_req_nomem(subreq, req)) {
+               return tevent_req_post(req, ev);
+       }
+       tevent_req_set_callback(subreq, torture_createdel_created, req);
+       return req;
+}
+
+static void torture_createdel_created(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct torture_createdel_state *state = tevent_req_data(
+               req, struct torture_createdel_state);
+       NTSTATUS status;
+       uint16_t fnum;
+
+       status = cli_ntcreate_recv(subreq, &fnum);
+       TALLOC_FREE(subreq);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(10, ("cli_ntcreate_recv returned %s\n",
+                          nt_errstr(status)));
+               tevent_req_nterror(req, status);
+               return;
+       }
+
+       subreq = cli_close_send(state, state->ev, state->cli, fnum);
+       if (tevent_req_nomem(subreq, req)) {
+               return;
+       }
+       tevent_req_set_callback(subreq, torture_createdel_closed, req);
+}
+
+static void torture_createdel_closed(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       NTSTATUS status;
+
+       status = cli_close_recv(subreq);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(10, ("cli_close_recv returned %s\n", nt_errstr(status)));
+               tevent_req_nterror(req, status);
+               return;
+       }
+       tevent_req_done(req);
+}
+
+static NTSTATUS torture_createdel_recv(struct tevent_req *req)
+{
+       return tevent_req_simple_recv_ntstatus(req);
+}
+
+struct torture_createdels_state {
+       struct tevent_context *ev;
+       struct cli_state *cli;
+       const char *base_name;
+       int sent;
+       int received;
+       int num_files;
+       struct tevent_req **reqs;
+};
+
+static void torture_createdels_done(struct tevent_req *subreq);
+
+static struct tevent_req *torture_createdels_send(TALLOC_CTX *mem_ctx,
+                                                 struct tevent_context *ev,
+                                                 struct cli_state *cli,
+                                                 const char *base_name,
+                                                 int num_parallel,
+                                                 int num_files)
+{
+       struct tevent_req *req;
+       struct torture_createdels_state *state;
+       int i;
+
+       req = tevent_req_create(mem_ctx, &state,
+                               struct torture_createdels_state);
+       if (req == NULL) {
+               return NULL;
+       }
+       state->ev = ev;
+       state->cli = cli;
+       state->base_name = talloc_strdup(state, base_name);
+       if (tevent_req_nomem(state->base_name, req)) {
+               return tevent_req_post(req, ev);
+       }
+       state->num_files = MAX(num_parallel, num_files);
+       state->sent = 0;
+       state->received = 0;
+
+       state->reqs = talloc_array(state, struct tevent_req *, num_parallel);
+       if (tevent_req_nomem(state->reqs, req)) {
+               return tevent_req_post(req, ev);
+       }
+
+       for (i=0; i<num_parallel; i++) {
+               char *name;
+
+               name = talloc_asprintf(state, "%s%8.8d", state->base_name,
+                                      state->sent);
+               if (tevent_req_nomem(name, req)) {
+                       return tevent_req_post(req, ev);
+               }
+               state->reqs[i] = torture_createdel_send(
+                       state->reqs, state->ev, state->cli, name);
+               if (tevent_req_nomem(state->reqs[i], req)) {
+                       return tevent_req_post(req, ev);
+               }
+               name = talloc_move(state->reqs[i], &name);
+               tevent_req_set_callback(state->reqs[i],
+                                       torture_createdels_done, req);
+               state->sent += 1;
+       }
+       return req;
+}
+
+static void torture_createdels_done(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct torture_createdels_state *state = tevent_req_data(
+               req, struct torture_createdels_state);
+       size_t num_parallel = talloc_array_length(state->reqs);
+       NTSTATUS status;
+       char *name;
+       int i;
+
+       status = torture_createdel_recv(subreq);
+       if (!NT_STATUS_IS_OK(status)){
+               DEBUG(10, ("torture_createdel_recv returned %s\n",
+                          nt_errstr(status)));
+               TALLOC_FREE(subreq);
+               tevent_req_nterror(req, status);
+               return;
+       }
+
+       for (i=0; i<num_parallel; i++) {
+               if (subreq == state->reqs[i]) {
+                       break;
+               }
+       }
+       if (i == num_parallel) {
+               DEBUG(10, ("received something we did not send\n"));
+               tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+               return;
+       }
+       TALLOC_FREE(state->reqs[i]);
+
+       if (state->sent >= state->num_files) {
+               tevent_req_done(req);
+               return;
+       }
+
+       name = talloc_asprintf(state, "%s%8.8d", state->base_name,
+                              state->sent);
+       if (tevent_req_nomem(name, req)) {
+               return;
+       }
+       state->reqs[i] = torture_createdel_send(state->reqs, state->ev,
+                                               state->cli, name);
+       if (tevent_req_nomem(state->reqs[i], req)) {
+               return;
+       }
+       name = talloc_move(state->reqs[i], &name);
+       tevent_req_set_callback(state->reqs[i], torture_createdels_done, req);
+       state->sent += 1;
+}
+
+static NTSTATUS torture_createdels_recv(struct tevent_req *req)
+{
+       return tevent_req_simple_recv_ntstatus(req);
+}
+
+struct swallow_notify_state {
+       struct tevent_context *ev;
+       struct cli_state *cli;
+       uint16_t fnum;
+       uint32_t completion_filter;
+       bool recursive;
+       bool (*fn)(uint32_t action, const char *name, void *priv);
+       void *priv;
+};
+
+static void swallow_notify_done(struct tevent_req *subreq);
+
+static struct tevent_req *swallow_notify_send(TALLOC_CTX *mem_ctx,
+                                             struct tevent_context *ev,
+                                             struct cli_state *cli,
+                                             uint16_t fnum,
+                                             uint32_t completion_filter,
+                                             bool recursive,
+                                             bool (*fn)(uint32_t action,
+                                                        const char *name,
+                                                        void *priv),
+                                             void *priv)
+{
+       struct tevent_req *req, *subreq;
+       struct swallow_notify_state *state;
+
+       req = tevent_req_create(mem_ctx, &state,
+                               struct swallow_notify_state);
+       if (req == NULL) {
+               return NULL;
+       }
+       state->ev = ev;
+       state->cli = cli;
+       state->fnum = fnum;
+       state->completion_filter = completion_filter;
+       state->recursive = recursive;
+       state->fn = fn;
+       state->priv = priv;
+
+       subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
+                                0xffff, state->completion_filter,
+                                state->recursive);
+       if (tevent_req_nomem(subreq, req)) {
+               return tevent_req_post(req, ev);
+       }
+       tevent_req_set_callback(subreq, swallow_notify_done, req);
+       return req;
+}
+
+static void swallow_notify_done(struct tevent_req *subreq)
+{
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct swallow_notify_state *state = tevent_req_data(
+               req, struct swallow_notify_state);
+       NTSTATUS status;
+       uint32_t i, num_changes;
+       struct notify_change *changes;
+
+       status = cli_notify_recv(subreq, state, &num_changes, &changes);
+       TALLOC_FREE(subreq);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(10, ("cli_notify_recv returned %s\n",
+                          nt_errstr(status)));
+               tevent_req_nterror(req, status);
+               return;
+       }
+
+       for (i=0; i<num_changes; i++) {
+               state->fn(changes[i].action, changes[i].name, state->priv);
+       }
+       TALLOC_FREE(changes);
+
+       subreq = cli_notify_send(state, state->ev, state->cli, state->fnum,
+                                0xffff, state->completion_filter,
+                                state->recursive);
+       if (tevent_req_nomem(subreq, req)) {
+               return;
+       }
+       tevent_req_set_callback(subreq, swallow_notify_done, req);
+}
+
+static bool print_notifies(uint32_t action, const char *name, void *priv)
+{
+       if (DEBUGLEVEL > 5) {
+               d_printf("%d %s\n", (int)action, name);
+       }
+       return true;
+}
+
+static void notify_bench_done(struct tevent_req *req)
+{
+       int *num_finished = (int *)tevent_req_callback_data_void(req);
+       *num_finished += 1;
+}
+
+static bool run_notify_bench(int dummy)
+{
+       const char *dname = "\\notify-bench";
+       struct tevent_context *ev;
+       NTSTATUS status;
+       uint16_t dnum;
+       struct tevent_req *req1;
+       struct tevent_req *req2 = NULL;
+       int i, num_unc_names;
+       int num_finished = 0;
+
+       printf("starting notify-bench test\n");
+
+       if (use_multishare_conn) {
+               char **unc_list;
+               unc_list = file_lines_load(multishare_conn_fname,
+                                          &num_unc_names, 0, NULL);
+               if (!unc_list || num_unc_names <= 0) {
+                       d_printf("Failed to load unc names list from '%s'\n",
+                                multishare_conn_fname);
+                       return false;
+               }
+               TALLOC_FREE(unc_list);
+       } else {
+               num_unc_names = 1;
+       }
+
+       ev = tevent_context_init(talloc_tos());
+       if (ev == NULL) {
+               d_printf("tevent_context_init failed\n");
+               return false;
+       }
+
+       for (i=0; i<num_unc_names; i++) {
+               struct cli_state *cli;
+               char *base_fname;
+
+               base_fname = talloc_asprintf(talloc_tos(), "%s\\file%3.3d.",
+                                            dname, i);
+               if (base_fname == NULL) {
+                       return false;
+               }
+
+               if (!torture_open_connection(&cli, i)) {
+                       return false;
+               }
+
+               status = cli_ntcreate(cli, dname, 0,
+                                     MAXIMUM_ALLOWED_ACCESS,
+                                     0, FILE_SHARE_READ|FILE_SHARE_WRITE|
+                                     FILE_SHARE_DELETE,
+                                     FILE_OPEN_IF, FILE_DIRECTORY_FILE, 0,
+                                     &dnum);
+
+               if (!NT_STATUS_IS_OK(status)) {
+                       d_printf("Could not create %s: %s\n", dname,
+                                nt_errstr(status));
+                       return false;
+               }
+
+               req1 = swallow_notify_send(talloc_tos(), ev, cli, dnum,
+                                          FILE_NOTIFY_CHANGE_FILE_NAME |
+                                          FILE_NOTIFY_CHANGE_DIR_NAME |
+                                          FILE_NOTIFY_CHANGE_ATTRIBUTES |
+                                          FILE_NOTIFY_CHANGE_LAST_WRITE,
+                                          false, print_notifies, NULL);
+               if (req1 == NULL) {
+                       d_printf("Could not create notify request\n");
+                       return false;
+               }
+
+               req2 = torture_createdels_send(talloc_tos(), ev, cli,
+                                              base_fname, 10, torture_numops);
+               if (req2 == NULL) {
+                       d_printf("Could not create createdels request\n");
+                       return false;
+               }
+               TALLOC_FREE(base_fname);
+
+               tevent_req_set_callback(req2, notify_bench_done,
+                                       &num_finished);
+       }
+
+       while (num_finished < num_unc_names) {
+               int ret;
+               ret = tevent_loop_once(ev);
+               if (ret != 0) {
+                       d_printf("tevent_loop_once failed\n");
+                       return false;
+               }
+       }
+
+       if (!tevent_req_poll(req2, ev)) {
+               d_printf("tevent_req_poll failed\n");
+       }
+
+       status = torture_createdels_recv(req2);
+       d_printf("torture_createdels_recv returned %s\n", nt_errstr(status));
+
+       return true;
+}
+
 static bool run_mangle1(int dummy)
 {
        struct cli_state *cli;
@@ -5163,10 +6147,11 @@ static bool run_mangle1(int dummy)
        }
        cli_close(cli, fnum);
 
-       if (!cli_qpathinfo(cli, alt_name, &change_time, &access_time,
-                          &write_time, &size, &mode)) {
-               d_printf("cli_qpathinfo(%s) failed: %s\n", alt_name,
-                        cli_errstr(cli));
+       status = cli_qpathinfo1(cli, alt_name, &change_time, &access_time,
+                               &write_time, &size, &mode);
+       if (!NT_STATUS_IS_OK(status)) {
+               d_printf("cli_qpathinfo1(%s) failed: %s\n", alt_name,
+                        nt_errstr(status));
                return false;
        }
 
@@ -5195,6 +6180,7 @@ static bool run_windows_write(int dummy)
        int i;
        bool ret = false;
        const char *fname = "\\writetest.txt";
+       struct timeval start_time;
        double seconds;
        double kbytes;
 
@@ -5210,7 +6196,7 @@ static bool run_windows_write(int dummy)
 
        cli_sockopt(cli1, sockops);
 
-       start_timer();
+       start_time = timeval_current();
 
        for (i=0; i<torture_numops; i++) {
                char c = 0;
@@ -5232,7 +6218,7 @@ static bool run_windows_write(int dummy)
                }
        }
 
-       seconds = end_timer();
+       seconds = timeval_elapsed(&start_time);
        kbytes = (double)torture_blocksize * torture_numops;
        kbytes /= 1024;
 
@@ -5272,6 +6258,7 @@ static bool run_uid_regression_test(int dummy)
        int16_t old_vuid;
        int16_t old_cnum;
        bool correct = True;
+       NTSTATUS status;
 
        printf("starting uid regression test\n");
 
@@ -5284,9 +6271,10 @@ static bool run_uid_regression_test(int dummy)
        /* Ok - now save then logoff our current user. */
        old_vuid = cli->vuid;
 
-       if (!cli_ulogoff(cli)) {
+       status = cli_ulogoff(cli);
+       if (!NT_STATUS_IS_OK(status)) {
                d_printf("(%s) cli_ulogoff failed: %s\n",
-                       __location__, cli_errstr(cli));
+                        __location__, nt_errstr(status));
                correct = false;
                goto out;
        }
@@ -5294,11 +6282,18 @@ static bool run_uid_regression_test(int dummy)
        cli->vuid = old_vuid;
 
        /* Try an operation. */
-       if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\uid_reg_test"))) {
-               /* We expect bad uid. */
+       status = cli_mkdir(cli, "\\uid_reg_test");
+       if (NT_STATUS_IS_OK(status)) {
+               d_printf("(%s) cli_mkdir succeeded\n",
+                        __location__);
+               correct = false;
+               goto out;
+       } else {
+               /* Should be bad uid. */
                if (!check_error(__LINE__, cli, ERRSRV, ERRbaduid,
-                               NT_STATUS_NO_SUCH_USER)) {
-                       return False;
+                               NT_STATUS_USER_SESSION_DELETED)) {
+                       correct = false;
+                       goto out;
                }
        }
 
@@ -5308,23 +6303,31 @@ static bool run_uid_regression_test(int dummy)
        cli->vuid = 0;
 
        /* This should succeed. */
-       if (cli_tdis(cli)) {
-               printf("First tdis with invalid vuid should succeed.\n");
+       status = cli_tdis(cli);
+
+       if (NT_STATUS_IS_OK(status)) {
+               d_printf("First tdis with invalid vuid should succeed.\n");
        } else {
-               printf("First tdis failed (%s)\n", cli_errstr(cli));
+               d_printf("First tdis failed (%s)\n", nt_errstr(status));
+               correct = false;
+               goto out;
        }
 
        cli->vuid = old_vuid;
        cli->cnum = old_cnum;
 
        /* This should fail. */
-       if (cli_tdis(cli)) {
-               printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
+       status = cli_tdis(cli);
+       if (NT_STATUS_IS_OK(status)) {
+               d_printf("Second tdis with invalid vuid should fail - succeeded instead !.\n");
+               correct = false;
+               goto out;
        } else {
                /* Should be bad tid. */
                if (!check_error(__LINE__, cli, ERRSRV, ERRinvnid,
                                NT_STATUS_NETWORK_NAME_DELETED)) {
-                       return False;
+                       correct = false;
+                       goto out;
                }
        }
 
@@ -5340,30 +6343,40 @@ static bool run_uid_regression_test(int dummy)
 static const char *illegal_chars = "*\\/?<>|\":";
 static char force_shortname_chars[] = " +,.[];=\177";
 
-static void shortname_del_fn(const char *mnt, file_info *finfo, const char *mask, void *state)
+static NTSTATUS shortname_del_fn(const char *mnt, struct file_info *finfo,
+                            const char *mask, void *state)
 {
        struct cli_state *pcli = (struct cli_state *)state;
        fstring fname;
+       NTSTATUS status = NT_STATUS_OK;
+
        slprintf(fname, sizeof(fname), "\\shortname\\%s", finfo->name);
 
        if (strcmp(finfo->name, ".") == 0 || strcmp(finfo->name, "..") == 0)
-               return;
+               return NT_STATUS_OK;
 
        if (finfo->mode & aDIR) {
-               if (!NT_STATUS_IS_OK(cli_rmdir(pcli, fname)))
+               status = cli_rmdir(pcli, fname);
+               if (!NT_STATUS_IS_OK(status)) {
                        printf("del_fn: failed to rmdir %s\n,", fname );
+               }
        } else {
-               if (!NT_STATUS_IS_OK(cli_unlink(pcli, fname, aSYSTEM | aHIDDEN)))
+               status = cli_unlink(pcli, fname, aSYSTEM | aHIDDEN);
+               if (!NT_STATUS_IS_OK(status)) {
                        printf("del_fn: failed to unlink %s\n,", fname );
+               }
        }
+       return status;
 }
 
 struct sn_state {
+       int matched;
        int i;
        bool val;
 };
 
-static void shortname_list_fn(const char *mnt, file_info *finfo, const char *name, void *state)
+static NTSTATUS shortname_list_fn(const char *mnt, struct file_info *finfo,
+                             const char *name, void *state)
 {
        struct sn_state *s = (struct sn_state  *)state;
        int i = s->i;
@@ -5386,6 +6399,8 @@ static void shortname_list_fn(const char *mnt, file_info *finfo, const char *nam
                        __location__, finfo->short_name, finfo->name);
                s->val = true;
        }
+       s->matched += 1;
+       return NT_STATUS_OK;
 }
 
 static bool run_shortname_test(int dummy)
@@ -5440,7 +6455,11 @@ static bool run_shortname_test(int dummy)
                        goto out;
                }
                cli_close(cli, fnum);
-               if (cli_list(cli, "\\shortname\\test*.*", 0, shortname_list_fn, &s) != 1) {
+
+               s.matched = 0;
+               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));
                        correct = false;
@@ -5468,6 +6487,236 @@ static bool run_shortname_test(int dummy)
        return correct;
 }
 
+static void pagedsearch_cb(struct tevent_req *req)
+{
+       int rc;
+       struct tldap_message *msg;
+       char *dn;
+
+       rc = tldap_search_paged_recv(req, talloc_tos(), &msg);
+       if (rc != TLDAP_SUCCESS) {
+               d_printf("tldap_search_paged_recv failed: %s\n",
+                        tldap_err2string(rc));
+               return;
+       }
+       if (tldap_msg_type(msg) != TLDAP_RES_SEARCH_ENTRY) {
+               TALLOC_FREE(msg);
+               return;
+       }
+       if (!tldap_entry_dn(msg, &dn)) {
+               d_printf("tldap_entry_dn failed\n");
+               return;
+       }
+       d_printf("%s\n", dn);
+       TALLOC_FREE(msg);
+}
+
+static bool run_tldap(int dummy)
+{
+       struct tldap_context *ld;
+       int fd, rc;
+       NTSTATUS status;
+       struct sockaddr_storage addr;
+       struct tevent_context *ev;
+       struct tevent_req *req;
+       char *basedn;
+       const char *filter;
+
+       if (!resolve_name(host, &addr, 0, false)) {
+               d_printf("could not find host %s\n", host);
+               return false;
+       }
+       status = open_socket_out(&addr, 389, 9999, &fd);
+       if (!NT_STATUS_IS_OK(status)) {
+               d_printf("open_socket_out failed: %s\n", nt_errstr(status));
+               return false;
+       }
+
+       ld = tldap_context_create(talloc_tos(), fd);
+       if (ld == NULL) {
+               close(fd);
+               d_printf("tldap_context_create failed\n");
+               return false;
+       }
+
+       rc = tldap_fetch_rootdse(ld);
+       if (rc != TLDAP_SUCCESS) {
+               d_printf("tldap_fetch_rootdse failed: %s\n",
+                        tldap_errstr(talloc_tos(), ld, rc));
+               return false;
+       }
+
+       basedn = tldap_talloc_single_attribute(
+               tldap_rootdse(ld), "defaultNamingContext", talloc_tos());
+       if (basedn == NULL) {
+               d_printf("no defaultNamingContext\n");
+               return false;
+       }
+       d_printf("defaultNamingContext: %s\n", basedn);
+
+       ev = tevent_context_init(talloc_tos());
+       if (ev == NULL) {
+               d_printf("tevent_context_init failed\n");
+               return false;
+       }
+
+       req = tldap_search_paged_send(talloc_tos(), ev, ld, basedn,
+                                     TLDAP_SCOPE_SUB, "(objectclass=*)",
+                                     NULL, 0, 0,
+                                     NULL, 0, NULL, 0, 0, 0, 0, 5);
+       if (req == NULL) {
+               d_printf("tldap_search_paged_send failed\n");
+               return false;
+       }
+       tevent_req_set_callback(req, pagedsearch_cb, NULL);
+
+       tevent_req_poll(req, ev);
+
+       TALLOC_FREE(req);
+
+       /* test search filters against rootDSE */
+       filter = "(&(|(name=samba)(nextRid<=10000000)(usnChanged>=10)(samba~=ambas)(!(name=s*m*a)))"
+                  "(|(name:=samba)(name:dn:2.5.13.5:=samba)(:dn:2.5.13.5:=samba)(!(name=*samba))))";
+
+       rc = tldap_search(ld, "", TLDAP_SCOPE_BASE, filter,
+                         NULL, 0, 0, NULL, 0, NULL, 0, 0, 0, 0,
+                         talloc_tos(), NULL, NULL);
+       if (rc != TLDAP_SUCCESS) {
+               d_printf("tldap_search with complex filter failed: %s\n",
+                        tldap_errstr(talloc_tos(), ld, rc));
+               return false;
+       }
+
+       TALLOC_FREE(ld);
+       return true;
+}
+
+/* Torture test to ensure no regression of :
+https://bugzilla.samba.org/show_bug.cgi?id=7084
+*/
+
+static bool run_dir_createtime(int dummy)
+{
+       struct cli_state *cli;
+       const char *dname = "\\testdir";
+       const char *fname = "\\testdir\\testfile";
+       NTSTATUS status;
+       struct timespec create_time;
+       struct timespec create_time1;
+       uint16_t fnum;
+       bool ret = false;
+
+       if (!torture_open_connection(&cli, 0)) {
+               return false;
+       }
+
+       cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
+       cli_rmdir(cli, dname);
+
+       status = cli_mkdir(cli, dname);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("mkdir failed: %s\n", nt_errstr(status));
+               goto out;
+       }
+
+       status = cli_qpathinfo2(cli, dname, &create_time, NULL, NULL, NULL,
+                               NULL, NULL, NULL);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("cli_qpathinfo2 returned %s\n",
+                      nt_errstr(status));
+               goto out;
+       }
+
+       /* Sleep 3 seconds, then create a file. */
+       sleep(3);
+
+       status = cli_open(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));
+               goto out;
+       }
+
+       status = cli_qpathinfo2(cli, dname, &create_time1, NULL, NULL, NULL,
+                               NULL, NULL, NULL);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("cli_qpathinfo2 (2) returned %s\n",
+                      nt_errstr(status));
+               goto out;
+       }
+
+       if (timespec_compare(&create_time1, &create_time)) {
+               printf("run_dir_createtime: create time was updated (error)\n");
+       } else {
+               printf("run_dir_createtime: create time was not updated (correct)\n");
+               ret = true;
+       }
+
+  out:
+
+       cli_unlink(cli, fname, aSYSTEM | aHIDDEN);
+       cli_rmdir(cli, dname);
+       if (!torture_close_connection(cli)) {
+               ret = false;
+       }
+       return ret;
+}
+
+
+static bool run_streamerror(int dummy)
+{
+       struct cli_state *cli;
+       const char *dname = "\\testdir";
+       const char *streamname =
+               "testdir:{4c8cc155-6c1e-11d1-8e41-00c04fb9386d}:$DATA";
+       NTSTATUS status;
+       time_t change_time, access_time, write_time;
+       SMB_OFF_T size;
+       uint16_t mode, fnum;
+       bool ret = true;
+
+       if (!torture_open_connection(&cli, 0)) {
+               return false;
+       }
+
+       cli_unlink(cli, "\\testdir\\*", aSYSTEM | aHIDDEN);
+       cli_rmdir(cli, dname);
+
+       status = cli_mkdir(cli, dname);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf("mkdir failed: %s\n", nt_errstr(status));
+               return false;
+       }
+
+       cli_qpathinfo1(cli, streamname, &change_time, &access_time, &write_time,
+                     &size, &mode);
+       status = cli_nt_error(cli);
+
+       if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+               printf("pathinfo returned %s, expected "
+                      "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
+                      nt_errstr(status));
+               ret = false;
+       }
+
+       status = cli_ntcreate(cli, streamname, 0x16,
+                             FILE_READ_DATA|FILE_READ_EA|
+                             FILE_READ_ATTRIBUTES|READ_CONTROL_ACCESS,
+                             FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
+                             FILE_OPEN, 0, 0, &fnum);
+
+       if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+               printf("ntcreate returned %s, expected "
+                      "NT_STATUS_OBJECT_NAME_NOT_FOUND\n",
+                      nt_errstr(status));
+               ret = false;
+       }
+
+
+       cli_rmdir(cli, dname);
+       return ret;
+}
+
 static bool run_local_substitute(int dummy)
 {
        bool ok = true;
@@ -5489,19 +6738,52 @@ static bool run_local_substitute(int dummy)
        return ok;
 }
 
+static bool run_local_base64(int dummy)
+{
+       int i;
+       bool ret = true;
+
+       for (i=1; i<2000; i++) {
+               DATA_BLOB blob1, blob2;
+               char *b64;
+
+               blob1.data = talloc_array(talloc_tos(), uint8_t, i);
+               blob1.length = i;
+               generate_random_buffer(blob1.data, blob1.length);
+
+               b64 = base64_encode_data_blob(talloc_tos(), blob1);
+               if (b64 == NULL) {
+                       d_fprintf(stderr, "base64_encode_data_blob failed "
+                                 "for %d bytes\n", i);
+                       ret = false;
+               }
+               blob2 = base64_decode_data_blob(b64);
+               TALLOC_FREE(b64);
+
+               if (data_blob_cmp(&blob1, &blob2)) {
+                       d_fprintf(stderr, "data_blob_cmp failed for %d "
+                                 "bytes\n", i);
+                       ret = false;
+               }
+               TALLOC_FREE(blob1.data);
+               data_blob_free(&blob2);
+       }
+       return ret;
+}
+
 static bool run_local_gencache(int dummy)
 {
        char *val;
        time_t tm;
        DATA_BLOB blob;
 
-       if (!gencache_init()) {
-               d_printf("%s: gencache_init() failed\n", __location__);
+       if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
+               d_printf("%s: gencache_set() failed\n", __location__);
                return False;
        }
 
-       if (!gencache_set("foo", "bar", time(NULL) + 1000)) {
-               d_printf("%s: gencache_set() failed\n", __location__);
+       if (!gencache_get("foo", NULL, NULL)) {
+               d_printf("%s: gencache_get() failed\n", __location__);
                return False;
        }
 
@@ -5536,16 +6818,14 @@ static bool run_local_gencache(int dummy)
        }
 
        blob = data_blob_string_const_null("bar");
-       tm = time(NULL);
+       tm = time(NULL) + 60;
 
        if (!gencache_set_data_blob("foo", &blob, tm)) {
                d_printf("%s: gencache_set_data_blob() failed\n", __location__);
                return False;
        }
 
-       data_blob_free(&blob);
-
-       if (!gencache_get_data_blob("foo", &blob, NULL)) {
+       if (!gencache_get_data_blob("foo", &blob, NULL, NULL)) {
                d_printf("%s: gencache_get_data_blob() failed\n", __location__);
                return False;
        }
@@ -5569,23 +6849,12 @@ static bool run_local_gencache(int dummy)
                return False;
        }
 
-       if (gencache_get_data_blob("foo", &blob, NULL)) {
+       if (gencache_get_data_blob("foo", &blob, NULL, NULL)) {
                d_printf("%s: gencache_get_data_blob() on deleted entry "
                         "succeeded\n", __location__);
                return False;
        }
 
-       if (!gencache_shutdown()) {
-               d_printf("%s: gencache_shutdown() failed\n", __location__);
-               return False;
-       }
-
-       if (gencache_shutdown()) {
-               d_printf("%s: second gencache_shutdown() succeeded\n",
-                        __location__);
-               return False;
-       }
-
        return True;
 }
 
@@ -5679,6 +6948,271 @@ static bool run_local_rbtree(int dummy)
        return ret;
 }
 
+struct talloc_dict_test {
+       int content;
+};
+
+static int talloc_dict_traverse_fn(DATA_BLOB key, void *data, void *priv)
+{
+       int *count = (int *)priv;
+       *count += 1;
+       return 0;
+}
+
+static bool run_local_talloc_dict(int dummy)
+{
+       struct talloc_dict *dict;
+       struct talloc_dict_test *t;
+       int key, count;
+
+       dict = talloc_dict_init(talloc_tos());
+       if (dict == NULL) {
+               return false;
+       }
+
+       t = talloc(talloc_tos(), struct talloc_dict_test);
+       if (t == NULL) {
+               return false;
+       }
+
+       key = 1;
+       t->content = 1;
+       if (!talloc_dict_set(dict, data_blob_const(&key, sizeof(key)), t)) {
+               return false;
+       }
+
+       count = 0;
+       if (talloc_dict_traverse(dict, talloc_dict_traverse_fn, &count) != 0) {
+               return false;
+       }
+
+       if (count != 1) {
+               return false;
+       }
+
+       TALLOC_FREE(dict);
+
+       return true;
+}
+
+static bool run_local_string_to_sid(int dummy) {
+       struct dom_sid sid;
+
+       if (string_to_sid(&sid, "S--1-5-32-545")) {
+               printf("allowing S--1-5-32-545\n");
+               return false;
+       }
+       if (string_to_sid(&sid, "S-1-5-32-+545")) {
+               printf("allowing S-1-5-32-+545\n");
+               return false;
+       }
+       if (string_to_sid(&sid, "S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0")) {
+               printf("allowing S-1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-7-8-9-0\n");
+               return false;
+       }
+       if (string_to_sid(&sid, "S-1-5-32-545-abc")) {
+               printf("allowing S-1-5-32-545-abc\n");
+               return false;
+       }
+       if (!string_to_sid(&sid, "S-1-5-32-545")) {
+               printf("could not parse S-1-5-32-545\n");
+               return false;
+       }
+       if (!dom_sid_equal(&sid, &global_sid_Builtin_Users)) {
+               printf("mis-parsed S-1-5-32-545 as %s\n",
+                      sid_string_tos(&sid));
+               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[] = {
+               0x1, /* revision number */
+               15, /* num auths */
+               0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
+               0x1, 0x1, 0x1, 0x1, /* auth[0] */
+               0x1, 0x1, 0x1, 0x1, /* auth[1] */
+               0x1, 0x1, 0x1, 0x1, /* auth[2] */
+               0x1, 0x1, 0x1, 0x1, /* auth[3] */
+               0x1, 0x1, 0x1, 0x1, /* auth[4] */
+               0x1, 0x1, 0x1, 0x1, /* auth[5] */
+               0x1, 0x1, 0x1, 0x1, /* auth[6] */
+               0x1, 0x1, 0x1, 0x1, /* auth[7] */
+               0x1, 0x1, 0x1, 0x1, /* auth[8] */
+               0x1, 0x1, 0x1, 0x1, /* auth[9] */
+               0x1, 0x1, 0x1, 0x1, /* auth[10] */
+               0x1, 0x1, 0x1, 0x1, /* auth[11] */
+               0x1, 0x1, 0x1, 0x1, /* auth[12] */
+               0x1, 0x1, 0x1, 0x1, /* auth[13] */
+               0x1, 0x1, 0x1, 0x1, /* auth[14] */
+       };
+
+       static const char long_binary_sid[] = {
+               0x1, /* revision number */
+               15, /* num auths */
+               0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
+               0x1, 0x1, 0x1, 0x1, /* auth[0] */
+               0x1, 0x1, 0x1, 0x1, /* auth[1] */
+               0x1, 0x1, 0x1, 0x1, /* auth[2] */
+               0x1, 0x1, 0x1, 0x1, /* auth[3] */
+               0x1, 0x1, 0x1, 0x1, /* auth[4] */
+               0x1, 0x1, 0x1, 0x1, /* auth[5] */
+               0x1, 0x1, 0x1, 0x1, /* auth[6] */
+               0x1, 0x1, 0x1, 0x1, /* auth[7] */
+               0x1, 0x1, 0x1, 0x1, /* auth[8] */
+               0x1, 0x1, 0x1, 0x1, /* auth[9] */
+               0x1, 0x1, 0x1, 0x1, /* auth[10] */
+               0x1, 0x1, 0x1, 0x1, /* auth[11] */
+               0x1, 0x1, 0x1, 0x1, /* auth[12] */
+               0x1, 0x1, 0x1, 0x1, /* auth[13] */
+               0x1, 0x1, 0x1, 0x1, /* auth[14] */
+               0x1, 0x1, 0x1, 0x1, /* auth[15] */
+               0x1, 0x1, 0x1, 0x1, /* auth[16] */
+               0x1, 0x1, 0x1, 0x1, /* auth[17] */
+       };
+
+       static const char long_binary_sid2[] = {
+               0x1, /* revision number */
+               32, /* num auths */
+               0x1, 0x1, 0x1, 0x1, 0x1, 0x1, /* id_auth */
+               0x1, 0x1, 0x1, 0x1, /* auth[0] */
+               0x1, 0x1, 0x1, 0x1, /* auth[1] */
+               0x1, 0x1, 0x1, 0x1, /* auth[2] */
+               0x1, 0x1, 0x1, 0x1, /* auth[3] */
+               0x1, 0x1, 0x1, 0x1, /* auth[4] */
+               0x1, 0x1, 0x1, 0x1, /* auth[5] */
+               0x1, 0x1, 0x1, 0x1, /* auth[6] */
+               0x1, 0x1, 0x1, 0x1, /* auth[7] */
+               0x1, 0x1, 0x1, 0x1, /* auth[8] */
+               0x1, 0x1, 0x1, 0x1, /* auth[9] */
+               0x1, 0x1, 0x1, 0x1, /* auth[10] */
+               0x1, 0x1, 0x1, 0x1, /* auth[11] */
+               0x1, 0x1, 0x1, 0x1, /* auth[12] */
+               0x1, 0x1, 0x1, 0x1, /* auth[13] */
+               0x1, 0x1, 0x1, 0x1, /* auth[14] */
+               0x1, 0x1, 0x1, 0x1, /* auth[15] */
+               0x1, 0x1, 0x1, 0x1, /* auth[16] */
+               0x1, 0x1, 0x1, 0x1, /* auth[17] */
+               0x1, 0x1, 0x1, 0x1, /* auth[18] */
+               0x1, 0x1, 0x1, 0x1, /* auth[19] */
+               0x1, 0x1, 0x1, 0x1, /* auth[20] */
+               0x1, 0x1, 0x1, 0x1, /* auth[21] */
+               0x1, 0x1, 0x1, 0x1, /* auth[22] */
+               0x1, 0x1, 0x1, 0x1, /* auth[23] */
+               0x1, 0x1, 0x1, 0x1, /* auth[24] */
+               0x1, 0x1, 0x1, 0x1, /* auth[25] */
+               0x1, 0x1, 0x1, 0x1, /* auth[26] */
+               0x1, 0x1, 0x1, 0x1, /* auth[27] */
+               0x1, 0x1, 0x1, 0x1, /* auth[28] */
+               0x1, 0x1, 0x1, 0x1, /* auth[29] */
+               0x1, 0x1, 0x1, 0x1, /* auth[30] */
+               0x1, 0x1, 0x1, 0x1, /* auth[31] */
+       };
+
+       if (!sid_parse(good_binary_sid, sizeof(good_binary_sid), sid)) {
+               return false;
+       }
+       if (sid_parse(long_binary_sid2, sizeof(long_binary_sid2), sid)) {
+               return false;
+       }
+       if (sid_parse(long_binary_sid, sizeof(long_binary_sid), sid)) {
+               return false;
+       }
+       return true;
+}
+
+/* Split a path name into filename and stream name components. Canonicalise
+ * such that an implicit $DATA token is always explicit.
+ *
+ * The "specification" of this function can be found in the
+ * run_local_stream_name() function in torture.c, I've tried those
+ * combinations against a W2k3 server.
+ */
+
+static NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
+                                      char **pbase, char **pstream)
+{
+       char *base = NULL;
+       char *stream = NULL;
+       char *sname; /* stream name */
+       const char *stype; /* stream type */
+
+       DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
+
+       sname = strchr_m(fname, ':');
+
+       if (lp_posix_pathnames() || (sname == NULL)) {
+               if (pbase != NULL) {
+                       base = talloc_strdup(mem_ctx, fname);
+                       NT_STATUS_HAVE_NO_MEMORY(base);
+               }
+               goto done;
+       }
+
+       if (pbase != NULL) {
+               base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
+               NT_STATUS_HAVE_NO_MEMORY(base);
+       }
+
+       sname += 1;
+
+       stype = strchr_m(sname, ':');
+
+       if (stype == NULL) {
+               sname = talloc_strdup(mem_ctx, sname);
+               stype = "$DATA";
+       }
+       else {
+               if (StrCaseCmp(stype, ":$DATA") != 0) {
+                       /*
+                        * If there is an explicit stream type, so far we only
+                        * allow $DATA. Is there anything else allowed? -- vl
+                        */
+                       DEBUG(10, ("[%s] is an invalid stream type\n", stype));
+                       TALLOC_FREE(base);
+                       return NT_STATUS_OBJECT_NAME_INVALID;
+               }
+               sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
+               stype += 1;
+       }
+
+       if (sname == NULL) {
+               TALLOC_FREE(base);
+               return NT_STATUS_NO_MEMORY;
+       }
+
+       if (sname[0] == '\0') {
+               /*
+                * no stream name, so no stream
+                */
+               goto done;
+       }
+
+       if (pstream != NULL) {
+               stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
+               if (stream == NULL) {
+                       TALLOC_FREE(sname);
+                       TALLOC_FREE(base);
+                       return NT_STATUS_NO_MEMORY;
+               }
+               /*
+                * upper-case the type field
+                */
+               strupper_m(strchr_m(stream, ':')+1);
+       }
+
+ done:
+       if (pbase != NULL) {
+               *pbase = base;
+       }
+       if (pstream != NULL) {
+               *pstream = stream;
+       }
+       return NT_STATUS_OK;
+}
+
 static bool test_stream_name(const char *fname, const char *expected_base,
                             const char *expected_stream,
                             NTSTATUS expected_status)
@@ -5711,7 +7245,7 @@ static bool test_stream_name(const char *fname, const char *expected_base,
        return true;
 
  error:
-       d_fprintf(stderr, "test_stream(%s, %s, %s, %s)\n",
+       d_fprintf(stderr, "Do test_stream(%s, %s, %s, %s)\n",
                  fname, expected_base ? expected_base : "<NULL>",
                  expected_stream ? expected_stream : "<NULL>",
                  nt_errstr(expected_status));
@@ -5875,7 +7409,7 @@ static bool run_local_wbclient(int dummy)
 
        BlockSignals(True, SIGPIPE);
 
-       ev = event_context_init(talloc_tos());
+       ev = tevent_context_init_byname(talloc_tos(), "epoll");
        if (ev == NULL) {
                goto fail;
        }
@@ -5891,7 +7425,7 @@ static bool run_local_wbclient(int dummy)
        d_printf("nprocs=%d, numops=%d\n", (int)nprocs, (int)torture_numops);
 
        for (i=0; i<nprocs; i++) {
-               wb_ctx[i] = wb_context_init(ev);
+               wb_ctx[i] = wb_context_init(ev, NULL);
                if (wb_ctx[i] == NULL) {
                        goto fail;
                }
@@ -5971,6 +7505,177 @@ fail:
        return result;
 }
 
+static bool dbtrans_inc(struct db_context *db)
+{
+       struct db_record *rec;
+       uint32_t *val;
+       bool ret = false;
+       NTSTATUS status;
+
+       rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
+       if (rec == NULL) {
+               printf(__location__ "fetch_lock failed\n");
+               return false;
+       }
+
+       if (rec->value.dsize != sizeof(uint32_t)) {
+               printf(__location__ "value.dsize = %d\n",
+                      (int)rec->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);
+       if (!NT_STATUS_IS_OK(status)) {
+               printf(__location__ "store failed: %s\n",
+                      nt_errstr(status));
+               goto fail;
+       }
+
+       ret = true;
+fail:
+       TALLOC_FREE(rec);
+       return ret;
+}
+
+static bool run_local_dbtrans(int dummy)
+{
+       struct db_context *db;
+       struct db_record *rec;
+       NTSTATUS status;
+       uint32_t initial;
+       int res;
+
+       db = db_open(talloc_tos(), "transtest.tdb", 0, TDB_DEFAULT,
+                    O_RDWR|O_CREAT, 0600);
+       if (db == NULL) {
+               printf("Could not open transtest.db\n");
+               return false;
+       }
+
+       res = db->transaction_start(db);
+       if (res == -1) {
+               printf(__location__ "transaction_start failed\n");
+               return false;
+       }
+
+       rec = db->fetch_locked(db, db, string_term_tdb_data("transtest"));
+       if (rec == NULL) {
+               printf(__location__ "fetch_lock failed\n");
+               return false;
+       }
+
+       if (rec->value.dptr == NULL) {
+               initial = 0;
+               status = rec->store(
+                       rec, make_tdb_data((uint8_t *)&initial,
+                                          sizeof(initial)),
+                       0);
+               if (!NT_STATUS_IS_OK(status)) {
+                       printf(__location__ "store returned %s\n",
+                              nt_errstr(status));
+                       return false;
+               }
+       }
+
+       TALLOC_FREE(rec);
+
+       res = db->transaction_commit(db);
+       if (res == -1) {
+               printf(__location__ "transaction_commit failed\n");
+               return false;
+       }
+
+       while (true) {
+               uint32_t val, val2;
+               int i;
+
+               res = db->transaction_start(db);
+               if (res == -1) {
+                       printf(__location__ "transaction_start failed\n");
+                       break;
+               }
+
+               if (!dbwrap_fetch_uint32(db, "transtest", &val)) {
+                       printf(__location__ "dbwrap_fetch_uint32 failed\n");
+                       break;
+               }
+
+               for (i=0; i<10; i++) {
+                       if (!dbtrans_inc(db)) {
+                               return false;
+                       }
+               }
+
+               if (!dbwrap_fetch_uint32(db, "transtest", &val2)) {
+                       printf(__location__ "dbwrap_fetch_uint32 failed\n");
+                       break;
+               }
+
+               if (val2 != val + 10) {
+                       printf(__location__ "val=%d, val2=%d\n",
+                              (int)val, (int)val2);
+                       break;
+               }
+
+               printf("val2=%d\r", val2);
+
+               res = db->transaction_commit(db);
+               if (res == -1) {
+                       printf(__location__ "transaction_commit failed\n");
+                       break;
+               }
+       }
+
+       TALLOC_FREE(db);
+       return true;
+}
+
+/*
+ * Just a dummy test to be run under a debugger. There's no real way
+ * to inspect the tevent_select specific function from outside of
+ * tevent_select.c.
+ */
+
+static bool run_local_tevent_select(int dummy)
+{
+       struct tevent_context *ev;
+       struct tevent_fd *fd1, *fd2;
+       bool result = false;
+
+       ev = tevent_context_init_byname(NULL, "select");
+       if (ev == NULL) {
+               d_fprintf(stderr, "tevent_context_init_byname failed\n");
+               goto fail;
+       }
+
+       fd1 = tevent_add_fd(ev, ev, 2, 0, NULL, NULL);
+       if (fd1 == NULL) {
+               d_fprintf(stderr, "tevent_add_fd failed\n");
+               goto fail;
+       }
+       fd2 = tevent_add_fd(ev, ev, 3, 0, NULL, NULL);
+       if (fd2 == NULL) {
+               d_fprintf(stderr, "tevent_add_fd failed\n");
+               goto fail;
+       }
+       TALLOC_FREE(fd2);
+
+       fd2 = tevent_add_fd(ev, ev, 1, 0, NULL, NULL);
+       if (fd2 == NULL) {
+               d_fprintf(stderr, "tevent_add_fd failed\n");
+               goto fail;
+       }
+
+       result = true;
+fail:
+       TALLOC_FREE(ev);
+       return result;
+}
 
 static double create_procs(bool (*fn)(int), bool *result)
 {
@@ -5979,6 +7684,7 @@ static double create_procs(bool (*fn)(int), bool *result)
        volatile bool *child_status_out;
        int synccount;
        int tries = 8;
+       struct timeval start;
 
        synccount = 0;
 
@@ -5999,7 +7705,7 @@ static double create_procs(bool (*fn)(int), bool *result)
                child_status_out[i] = True;
        }
 
-       start_timer();
+       start = timeval_current();
 
        for (i=0;i<nprocs;i++) {
                procnum = i;
@@ -6020,7 +7726,7 @@ static double create_procs(bool (*fn)(int), bool *result)
 
                        child_status[i] = getpid();
 
-                       while (child_status[i] && end_timer() < 5) smb_msleep(2);
+                       while (child_status[i] && timeval_elapsed(&start) < 5) smb_msleep(2);
 
                        child_status_out[i] = fn(i);
                        _exit(0);
@@ -6034,16 +7740,16 @@ static double create_procs(bool (*fn)(int), bool *result)
                }
                if (synccount == nprocs) break;
                smb_msleep(10);
-       } while (end_timer() < 30);
+       } while (timeval_elapsed(&start) < 30);
 
        if (synccount != nprocs) {
                printf("FAILED TO START %d CLIENTS (started %d)\n", nprocs, synccount);
                *result = False;
-               return end_timer();
+               return timeval_elapsed(&start);
        }
 
        /* start the client load */
-       start_timer();
+       start = timeval_current();
 
        for (i=0;i<nprocs;i++) {
                child_status[i] = 0;
@@ -6062,7 +7768,7 @@ static double create_procs(bool (*fn)(int), bool *result)
                        *result = False;
                }
        }
-       return end_timer();
+       return timeval_elapsed(&start);
 }
 
 #define FLAG_MULTIPROC 1
@@ -6081,6 +7787,7 @@ static struct {
        {"LOCK6",  run_locktest6,  0},
        {"LOCK7",  run_locktest7,  0},
        {"LOCK8",  run_locktest8,  0},
+       {"LOCK9",  run_locktest9,  0},
        {"UNLINK", run_unlinktest, 0},
        {"BROWSE", run_browsetest, 0},
        {"ATTR",   run_attrtest,   0},
@@ -6090,11 +7797,13 @@ static struct {
        {"RANDOMIPC", run_randomipc, 0},
        {"NEGNOWAIT", run_negprot_nowait, 0},
        {"NBENCH",  run_nbench, 0},
+       {"NBENCH2", run_nbench2, 0},
        {"OPLOCK1",  run_oplock1, 0},
        {"OPLOCK2",  run_oplock2, 0},
        {"OPLOCK3",  run_oplock3, 0},
        {"DIR",  run_dirtest, 0},
        {"DIR1",  run_dirtest1, 0},
+       {"DIR-CREATETIME",  run_dir_createtime, 0},
        {"DENY1",  torture_denytest1, 0},
        {"DENY2",  torture_denytest2, 0},
        {"TCON",  run_tcon_test, 0},
@@ -6102,8 +7811,11 @@ static struct {
        {"RW1",  run_readwritetest, 0},
        {"RW2",  run_readwritemulti, FLAG_MULTIPROC},
        {"RW3",  run_readwritelarge, 0},
+       {"RW-SIGNING",  run_readwritelarge_signtest, 0},
        {"OPEN", run_opentest, 0},
        {"POSIX", run_simple_posix_open_test, 0},
+       {"POSIX-APPEND", run_posix_append, 0},
+       {"ASYNC-ECHO", run_async_echo, 0},
        { "UID-REGRESSION-TEST", run_uid_regression_test, 0},
        { "SHORTNAME-TEST", run_shortname_test, 0},
 #if 1
@@ -6133,12 +7845,22 @@ static struct {
        { "WINDOWS-WRITE", run_windows_write, 0},
        { "CLI_ECHO", run_cli_echo, 0},
        { "GETADDRINFO", run_getaddrinfo_send, 0},
+       { "TLDAP", run_tldap },
+       { "STREAMERROR", run_streamerror },
+       { "NOTIFY-BENCH", run_notify_bench },
+       { "BAD-NBT-SESSION", run_bad_nbt_session },
        { "LOCAL-SUBSTITUTE", run_local_substitute, 0},
        { "LOCAL-GENCACHE", run_local_gencache, 0},
+       { "LOCAL-TALLOC-DICT", run_local_talloc_dict, 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},
+       { "LOCAL-string_to_sid", run_local_string_to_sid, 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},
        {NULL, NULL, 0}};
 
 
@@ -6174,12 +7896,13 @@ static bool run_test(const char *name)
                                        printf("TEST %s FAILED!\n", name);
                                }
                        } else {
-                               start_timer();
+                               struct timeval start;
+                               start = timeval_current();
                                if (!torture_ops[i].fn(0)) {
                                        ret = False;
                                        printf("TEST %s FAILED!\n", name);
                                }
-                               t = end_timer();
+                               t = timeval_elapsed(&start);
                        }
                        printf("%s took %g secs\n\n", name, t);
                }
@@ -6244,12 +7967,12 @@ static void usage(void)
        TALLOC_CTX *frame = talloc_stackframe();
        int seed = time(NULL);
 
-       dbf = x_stdout;
-
 #ifdef HAVE_SETBUFFER
        setbuffer(stdout, NULL, 0);
 #endif
 
+       setup_logging("smbtorture", DEBUG_STDOUT);
+
        load_case_tables();
 
        if (is_default_dyn_CONFIGFILE()) {
@@ -6295,7 +8018,7 @@ static void usage(void)
 
        fstrcpy(workgroup, lp_workgroup());
 
-       while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ld:Aec:ks:b:B:")) != EOF) {
+       while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:m:Ll:d:Aec:ks:b:B:")) != EOF) {
                switch (opt) {
                case 'p':
                        port_to_use = atoi(optarg);
@@ -6316,7 +8039,7 @@ static void usage(void)
                        torture_numops = atoi(optarg);
                        break;
                case 'd':
-                       DEBUGLEVEL = atoi(optarg);
+                       lp_set_cmdline("log level", optarg);
                        break;
                case 'O':
                        sockops = optarg;
@@ -6324,6 +8047,9 @@ static void usage(void)
                case 'L':
                        use_oplocks = True;
                        break;
+               case 'l':
+                       local_path = optarg;
+                       break;
                case 'A':
                        torture_showall = True;
                        break;