r14173: change smb interface structures to always use
[jelmer/samba4-debian.git] / source / torture / raw / write.c
index 644a5579c8eb9091267e08d9d67160c3029b4eb9..e9a391a7dc049af04fbb49fff3caff4ac55e91aa 100644 (file)
@@ -1,6 +1,7 @@
 /* 
    Unix SMB/CIFS implementation.
    test suite for various write operations
+
    Copyright (C) Andrew Tridgell 2003
    
    This program is free software; you can redistribute it and/or modify
 */
 
 #include "includes.h"
+#include "torture/torture.h"
+#include "libcli/raw/libcliraw.h"
+#include "system/time.h"
+#include "system/filesys.h"
+#include "libcli/libcli.h"
 
 #define CHECK_STATUS(status, correct) do { \
        if (!NT_STATUS_EQUAL(status, correct)) { \
-               printf("(%d) Incorrect status %s - should be %s\n", \
-                      __LINE__, nt_errstr(status), nt_errstr(correct)); \
+               printf("(%s) Incorrect status %s - should be %s\n", \
+                      __location__, nt_errstr(status), nt_errstr(correct)); \
                ret = False; \
                goto done; \
        }} while (0)
 
 #define CHECK_VALUE(v, correct) do { \
        if ((v) != (correct)) { \
-               printf("(%d) Incorrect value %s=%d - should be %d\n", \
-                      __LINE__, #v, v, correct); \
+               printf("(%s) Incorrect value %s=%d - should be %d\n", \
+                      __location__, #v, v, correct); \
                ret = False; \
                goto done; \
        }} while (0)
 
 #define CHECK_BUFFER(buf, seed, len) do { \
-       if (!check_buffer(buf, seed, len, __LINE__)) { \
+       if (!check_buffer(buf, seed, len, __location__)) { \
                ret = False; \
                goto done; \
        }} while (0)
 
 #define CHECK_ALL_INFO(v, field) do { \
        finfo.all_info.level = RAW_FILEINFO_ALL_INFO; \
-       finfo.all_info.in.fname = fname; \
+       finfo.all_info.file.path = fname; \
        status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo); \
        CHECK_STATUS(status, NT_STATUS_OK); \
        if ((v) != finfo.all_info.out.field) { \
-               printf("(%d) wrong value for field %s  %.0f - %.0f\n", \
-                      __LINE__, #field, (double)v, (double)finfo.all_info.out.field); \
+               printf("(%s) wrong value for field %s  %.0f - %.0f\n", \
+                      __location__, #field, (double)v, (double)finfo.all_info.out.field); \
                dump_all_info(mem_ctx, &finfo); \
                ret = False; \
        }} while (0)
@@ -61,7 +67,7 @@
 /*
   setup a random buffer based on a seed
 */
-static void setup_buffer(char *buf, unsigned seed, int len)
+static void setup_buffer(uint8_t *buf, uint_t seed, int len)
 {
        int i;
        srandom(seed);
@@ -71,15 +77,15 @@ static void setup_buffer(char *buf, unsigned seed, int len)
 /*
   check a random buffer based on a seed
 */
-static BOOL check_buffer(char *buf, unsigned seed, int len, int line)
+static BOOL check_buffer(uint8_t *buf, uint_t seed, int len, const char *location)
 {
        int i;
        srandom(seed);
        for (i=0;i<len;i++) {
-               char v = random();
+               uint8_t v = random();
                if (buf[i] != v) {
-                       printf("Buffer incorrect at line %d! ofs=%d buf=0x%x correct=0x%x\n", 
-                              line, i, buf[i], v);
+                       printf("Buffer incorrect at %s! ofs=%d buf=0x%x correct=0x%x\n", 
+                              location, i, buf[i], v);
                        return False;
                }
        }
@@ -89,38 +95,36 @@ static BOOL check_buffer(char *buf, unsigned seed, int len, int line)
 /*
   test write ops
 */
-static BOOL test_write(struct cli_state *cli, TALLOC_CTX *mem_ctx)
+static BOOL test_write(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 {
        union smb_write io;
        NTSTATUS status;
        BOOL ret = True;
        int fnum;
-       char *buf;
+       uint8_t *buf;
        const int maxsize = 90000;
        const char *fname = BASEDIR "\\test.txt";
-       unsigned seed = time(NULL);
+       uint_t seed = time(NULL);
        union smb_fileinfo finfo;
 
-       buf = talloc_zero(mem_ctx, maxsize);
+       buf = talloc_zero_size(mem_ctx, maxsize);
 
-       if (cli_deltree(cli, BASEDIR) == -1 ||
-           !cli_mkdir(cli, BASEDIR)) {
-               printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli));
+       if (!torture_setup_dir(cli, BASEDIR)) {
                return False;
        }
 
        printf("Testing RAW_WRITE_WRITE\n");
        io.generic.level = RAW_WRITE_WRITE;
        
-       fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
+       fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
        if (fnum == -1) {
-               printf("Failed to create %s - %s\n", fname, cli_errstr(cli));
+               printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
                ret = False;
                goto done;
        }
 
        printf("Trying zero write\n");
-       io.write.in.fnum = fnum;
+       io.write.file.fnum = fnum;
        io.write.in.count = 0;
        io.write.in.offset = 0;
        io.write.in.remaining = 0;
@@ -140,8 +144,8 @@ static BOOL test_write(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        CHECK_VALUE(io.write.out.nwritten, io.write.in.count);
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, 0, 13) != 13) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
@@ -159,15 +163,15 @@ static BOOL test_write(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        CHECK_VALUE(io.write.out.nwritten, 4000);
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, 0, 4000) != 4000) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 4000) != 4000) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
        CHECK_BUFFER(buf, seed, 4000);
 
        printf("Trying bad fnum\n");
-       io.write.in.fnum = fnum+1;
+       io.write.file.fnum = fnum+1;
        io.write.in.count = 4000;
        io.write.in.offset = 0;
        io.write.in.data = buf;
@@ -180,27 +184,27 @@ static BOOL test_write(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        
        printf("Trying 2^32 offset\n");
        setup_buffer(buf, seed, maxsize);
-       io.write.in.fnum = fnum;
+       io.write.file.fnum = fnum;
        io.write.in.count = 4000;
        io.write.in.offset = 0xFFFFFFFF - 2000;
        io.write.in.data = buf;
        status = smb_raw_write(cli->tree, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
        CHECK_VALUE(io.write.out.nwritten, 4000);
-       CHECK_ALL_INFO(io.write.in.count + (SMB_BIG_UINT)io.write.in.offset, size);
+       CHECK_ALL_INFO(io.write.in.count + (uint64_t)io.write.in.offset, size);
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, io.write.in.offset, 4000) != 4000) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, io.write.in.offset, 4000) != 4000) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
        CHECK_BUFFER(buf, seed, 4000);
 
 done:
-       cli_close(cli, fnum);
+       smbcli_close(cli->tree, fnum);
        smb_raw_exit(cli->session);
-       cli_deltree(cli, BASEDIR);
+       smbcli_deltree(cli->tree, BASEDIR);
        return ret;
 }
 
@@ -208,38 +212,36 @@ done:
 /*
   test writex ops
 */
-static BOOL test_writex(struct cli_state *cli, TALLOC_CTX *mem_ctx)
+static BOOL test_writex(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 {
        union smb_write io;
        NTSTATUS status;
        BOOL ret = True;
        int fnum, i;
-       char *buf;
+       uint8_t *buf;
        const int maxsize = 90000;
        const char *fname = BASEDIR "\\test.txt";
-       unsigned seed = time(NULL);
+       uint_t seed = time(NULL);
        union smb_fileinfo finfo;
 
-       buf = talloc_zero(mem_ctx, maxsize);
+       buf = talloc_zero_size(mem_ctx, maxsize);
 
-       if (cli_deltree(cli, BASEDIR) == -1 ||
-           !cli_mkdir(cli, BASEDIR)) {
-               printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli));
+       if (!torture_setup_dir(cli, BASEDIR)) {
                return False;
        }
 
        printf("Testing RAW_WRITE_WRITEX\n");
        io.generic.level = RAW_WRITE_WRITEX;
        
-       fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
+       fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
        if (fnum == -1) {
-               printf("Failed to create %s - %s\n", fname, cli_errstr(cli));
+               printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
                ret = False;
                goto done;
        }
 
        printf("Trying zero write\n");
-       io.writex.in.fnum = fnum;
+       io.writex.file.fnum = fnum;
        io.writex.in.offset = 0;
        io.writex.in.wmode = 0;
        io.writex.in.remaining = 0;
@@ -260,8 +262,8 @@ static BOOL test_writex(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        CHECK_VALUE(io.writex.out.nwritten, io.writex.in.count);
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, 0, 13) != 13) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
@@ -279,15 +281,15 @@ static BOOL test_writex(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        CHECK_VALUE(io.writex.out.nwritten, 4000);
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, 0, 4000) != 4000) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 4000) != 4000) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
        CHECK_BUFFER(buf, seed, 4000);
 
        printf("Trying bad fnum\n");
-       io.writex.in.fnum = fnum+1;
+       io.writex.file.fnum = fnum+1;
        io.writex.in.count = 4000;
        io.writex.in.offset = 0;
        io.writex.in.data = buf;
@@ -295,7 +297,7 @@ static BOOL test_writex(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);
 
        printf("Testing wmode\n");
-       io.writex.in.fnum = fnum;
+       io.writex.file.fnum = fnum;
        io.writex.in.count = 1;
        io.writex.in.offset = 0;
        io.writex.in.wmode = 1;
@@ -312,8 +314,8 @@ static BOOL test_writex(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 
        printf("Trying locked region\n");
        cli->session->pid++;
-       if (!cli_lock(cli, fnum, 3, 1, 0, WRITE_LOCK)) {
-               printf("Failed to lock file at %d\n", __LINE__);
+       if (NT_STATUS_IS_ERR(smbcli_lock(cli->tree, fnum, 3, 1, 0, WRITE_LOCK))) {
+               printf("Failed to lock file at %s\n", __location__);
                ret = False;
                goto done;
        }
@@ -330,18 +332,18 @@ static BOOL test_writex(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        
        printf("Trying 2^32 offset\n");
        setup_buffer(buf, seed, maxsize);
-       io.writex.in.fnum = fnum;
+       io.writex.file.fnum = fnum;
        io.writex.in.count = 4000;
        io.writex.in.offset = 0xFFFFFFFF - 2000;
        io.writex.in.data = buf;
        status = smb_raw_write(cli->tree, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
        CHECK_VALUE(io.writex.out.nwritten, 4000);
-       CHECK_ALL_INFO(io.writex.in.count + (SMB_BIG_UINT)io.writex.in.offset, size);
+       CHECK_ALL_INFO(io.writex.in.count + (uint64_t)io.writex.in.offset, size);
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, io.writex.in.offset, 4000) != 4000) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, io.writex.in.offset, 4000) != 4000) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
@@ -350,31 +352,35 @@ static BOOL test_writex(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        for (i=33;i<64;i++) {
                printf("Trying 2^%d offset\n", i);
                setup_buffer(buf, seed+1, maxsize);
-               io.writex.in.fnum = fnum;
+               io.writex.file.fnum = fnum;
                io.writex.in.count = 4000;
-               io.writex.in.offset = ((SMB_BIG_UINT)1) << i;
+               io.writex.in.offset = ((uint64_t)1) << i;
                io.writex.in.data = buf;
                status = smb_raw_write(cli->tree, &io);
+               if (i>33 &&
+                   NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
+                       break;
+               }
                CHECK_STATUS(status, NT_STATUS_OK);
                CHECK_VALUE(io.writex.out.nwritten, 4000);
-               CHECK_ALL_INFO(io.writex.in.count + (SMB_BIG_UINT)io.writex.in.offset, size);
+               CHECK_ALL_INFO(io.writex.in.count + (uint64_t)io.writex.in.offset, size);
 
                memset(buf, 0, maxsize);
-               if (cli_read(cli, fnum, buf, io.writex.in.offset, 4000) != 4000) {
-                       printf("read failed at %d\n", __LINE__);
+               if (smbcli_read(cli->tree, fnum, buf, io.writex.in.offset, 4000) != 4000) {
+                       printf("read failed at %s\n", __location__);
                        ret = False;
                        goto done;
                }
                CHECK_BUFFER(buf, seed+1, 4000);
        }
-
+       printf("limit is 2^%d\n", i);
 
        setup_buffer(buf, seed, maxsize);
 
 done:
-       cli_close(cli, fnum);
+       smbcli_close(cli->tree, fnum);
        smb_raw_exit(cli->session);
-       cli_deltree(cli, BASEDIR);
+       smbcli_deltree(cli->tree, BASEDIR);
        return ret;
 }
 
@@ -382,38 +388,36 @@ done:
 /*
   test write unlock ops
 */
-static BOOL test_writeunlock(struct cli_state *cli, TALLOC_CTX *mem_ctx)
+static BOOL test_writeunlock(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 {
        union smb_write io;
        NTSTATUS status;
        BOOL ret = True;
        int fnum;
-       char *buf;
+       uint8_t *buf;
        const int maxsize = 90000;
        const char *fname = BASEDIR "\\test.txt";
-       unsigned seed = time(NULL);
+       uint_t seed = time(NULL);
        union smb_fileinfo finfo;
 
-       buf = talloc_zero(mem_ctx, maxsize);
+       buf = talloc_zero_size(mem_ctx, maxsize);
 
-       if (cli_deltree(cli, BASEDIR) == -1 ||
-           !cli_mkdir(cli, BASEDIR)) {
-               printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli));
+       if (!torture_setup_dir(cli, BASEDIR)) {
                return False;
        }
 
        printf("Testing RAW_WRITE_WRITEUNLOCK\n");
        io.generic.level = RAW_WRITE_WRITEUNLOCK;
        
-       fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
+       fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
        if (fnum == -1) {
-               printf("Failed to create %s - %s\n", fname, cli_errstr(cli));
+               printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
                ret = False;
                goto done;
        }
 
        printf("Trying zero write\n");
-       io.writeunlock.in.fnum = fnum;
+       io.writeunlock.file.fnum = fnum;
        io.writeunlock.in.count = 0;
        io.writeunlock.in.offset = 0;
        io.writeunlock.in.remaining = 0;
@@ -430,8 +434,8 @@ static BOOL test_writeunlock(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        io.writeunlock.in.data = buf;
        status = smb_raw_write(cli->tree, &io);
        CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
-       if (cli_read(cli, fnum, buf, 0, 13) != 13) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
@@ -439,15 +443,15 @@ static BOOL test_writeunlock(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        CHECK_VALUE(IVAL(buf,0), 0);
 
        setup_buffer(buf, seed, maxsize);
-       cli_lock(cli, fnum, io.writeunlock.in.offset, io.writeunlock.in.count, 
+       smbcli_lock(cli->tree, fnum, io.writeunlock.in.offset, io.writeunlock.in.count, 
                 0, WRITE_LOCK);
        status = smb_raw_write(cli->tree, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
        CHECK_VALUE(io.writeunlock.out.nwritten, io.writeunlock.in.count);
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, 0, 13) != 13) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
@@ -460,7 +464,7 @@ static BOOL test_writeunlock(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        io.writeunlock.in.count = 4000;
        io.writeunlock.in.offset = 0;
        io.writeunlock.in.data = buf;
-       cli_lock(cli, fnum, io.writeunlock.in.offset, io.writeunlock.in.count, 
+       smbcli_lock(cli->tree, fnum, io.writeunlock.in.offset, io.writeunlock.in.count, 
                 0, WRITE_LOCK);
        status = smb_raw_write(cli->tree, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
@@ -470,15 +474,15 @@ static BOOL test_writeunlock(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, 0, 4000) != 4000) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 4000) != 4000) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
        CHECK_BUFFER(buf, seed, 4000);
 
        printf("Trying bad fnum\n");
-       io.writeunlock.in.fnum = fnum+1;
+       io.writeunlock.file.fnum = fnum+1;
        io.writeunlock.in.count = 4000;
        io.writeunlock.in.offset = 0;
        io.writeunlock.in.data = buf;
@@ -491,29 +495,29 @@ static BOOL test_writeunlock(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        
        printf("Trying 2^32 offset\n");
        setup_buffer(buf, seed, maxsize);
-       io.writeunlock.in.fnum = fnum;
+       io.writeunlock.file.fnum = fnum;
        io.writeunlock.in.count = 4000;
        io.writeunlock.in.offset = 0xFFFFFFFF - 2000;
        io.writeunlock.in.data = buf;
-       cli_lock(cli, fnum, io.writeunlock.in.offset, io.writeunlock.in.count, 
+       smbcli_lock(cli->tree, fnum, io.writeunlock.in.offset, io.writeunlock.in.count, 
                 0, WRITE_LOCK);
        status = smb_raw_write(cli->tree, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
        CHECK_VALUE(io.writeunlock.out.nwritten, 4000);
-       CHECK_ALL_INFO(io.writeunlock.in.count + (SMB_BIG_UINT)io.writeunlock.in.offset, size);
+       CHECK_ALL_INFO(io.writeunlock.in.count + (uint64_t)io.writeunlock.in.offset, size);
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, io.writeunlock.in.offset, 4000) != 4000) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, io.writeunlock.in.offset, 4000) != 4000) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
        CHECK_BUFFER(buf, seed, 4000);
 
 done:
-       cli_close(cli, fnum);
+       smbcli_close(cli->tree, fnum);
        smb_raw_exit(cli->session);
-       cli_deltree(cli, BASEDIR);
+       smbcli_deltree(cli->tree, BASEDIR);
        return ret;
 }
 
@@ -521,38 +525,36 @@ done:
 /*
   test write close ops
 */
-static BOOL test_writeclose(struct cli_state *cli, TALLOC_CTX *mem_ctx)
+static BOOL test_writeclose(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
 {
        union smb_write io;
        NTSTATUS status;
        BOOL ret = True;
        int fnum;
-       char *buf;
+       uint8_t *buf;
        const int maxsize = 90000;
        const char *fname = BASEDIR "\\test.txt";
-       unsigned seed = time(NULL);
+       uint_t seed = time(NULL);
        union smb_fileinfo finfo;
 
-       buf = talloc_zero(mem_ctx, maxsize);
+       buf = talloc_zero_size(mem_ctx, maxsize);
 
-       if (cli_deltree(cli, BASEDIR) == -1 ||
-           !cli_mkdir(cli, BASEDIR)) {
-               printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli));
+       if (!torture_setup_dir(cli, BASEDIR)) {
                return False;
        }
 
        printf("Testing RAW_WRITE_WRITECLOSE\n");
        io.generic.level = RAW_WRITE_WRITECLOSE;
        
-       fnum = cli_open(cli, fname, O_RDWR|O_CREAT, DENY_NONE);
+       fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
        if (fnum == -1) {
-               printf("Failed to create %s - %s\n", fname, cli_errstr(cli));
+               printf("Failed to create %s - %s\n", fname, smbcli_errstr(cli->tree));
                ret = False;
                goto done;
        }
 
        printf("Trying zero write\n");
-       io.writeclose.in.fnum = fnum;
+       io.writeclose.file.fnum = fnum;
        io.writeclose.in.count = 0;
        io.writeclose.in.offset = 0;
        io.writeclose.in.mtime = 0;
@@ -577,11 +579,11 @@ static BOOL test_writeclose(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        status = smb_raw_write(cli->tree, &io);
        CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);
 
-       fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
-       io.writeclose.in.fnum = fnum;
+       fnum = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
+       io.writeclose.file.fnum = fnum;
 
-       if (cli_read(cli, fnum, buf, 0, 13) != 13) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
@@ -593,12 +595,12 @@ static BOOL test_writeclose(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        CHECK_STATUS(status, NT_STATUS_OK);
        CHECK_VALUE(io.writeclose.out.nwritten, io.writeclose.in.count);
 
-       fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
-       io.writeclose.in.fnum = fnum;
+       fnum = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
+       io.writeclose.file.fnum = fnum;
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, 0, 13) != 13) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 13) != 13) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
@@ -618,19 +620,19 @@ static BOOL test_writeclose(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        status = smb_raw_write(cli->tree, &io);
        CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);
 
-       fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
-       io.writeclose.in.fnum = fnum;
+       fnum = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
+       io.writeclose.file.fnum = fnum;
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, 0, 4000) != 4000) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, 0, 4000) != 4000) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
        CHECK_BUFFER(buf, seed, 4000);
 
        printf("Trying bad fnum\n");
-       io.writeclose.in.fnum = fnum+1;
+       io.writeclose.file.fnum = fnum+1;
        io.writeclose.in.count = 4000;
        io.writeclose.in.offset = 0;
        io.writeclose.in.data = buf;
@@ -643,40 +645,39 @@ static BOOL test_writeclose(struct cli_state *cli, TALLOC_CTX *mem_ctx)
        
        printf("Trying 2^32 offset\n");
        setup_buffer(buf, seed, maxsize);
-       io.writeclose.in.fnum = fnum;
+       io.writeclose.file.fnum = fnum;
        io.writeclose.in.count = 4000;
        io.writeclose.in.offset = 0xFFFFFFFF - 2000;
        io.writeclose.in.data = buf;
        status = smb_raw_write(cli->tree, &io);
        CHECK_STATUS(status, NT_STATUS_OK);
        CHECK_VALUE(io.writeclose.out.nwritten, 4000);
-       CHECK_ALL_INFO(io.writeclose.in.count + (SMB_BIG_UINT)io.writeclose.in.offset, size);
+       CHECK_ALL_INFO(io.writeclose.in.count + (uint64_t)io.writeclose.in.offset, size);
 
-       fnum = cli_open(cli, fname, O_RDWR, DENY_NONE);
-       io.writeclose.in.fnum = fnum;
+       fnum = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
+       io.writeclose.file.fnum = fnum;
 
        memset(buf, 0, maxsize);
-       if (cli_read(cli, fnum, buf, io.writeclose.in.offset, 4000) != 4000) {
-               printf("read failed at %d\n", __LINE__);
+       if (smbcli_read(cli->tree, fnum, buf, io.writeclose.in.offset, 4000) != 4000) {
+               printf("read failed at %s\n", __location__);
                ret = False;
                goto done;
        }
        CHECK_BUFFER(buf, seed, 4000);
 
 done:
-       cli_close(cli, fnum);
+       smbcli_close(cli->tree, fnum);
        smb_raw_exit(cli->session);
-       cli_deltree(cli, BASEDIR);
+       smbcli_deltree(cli->tree, BASEDIR);
        return ret;
 }
 
-
 /* 
    basic testing of write calls
 */
-BOOL torture_raw_write(int dummy)
+BOOL torture_raw_write(void)
 {
-       struct cli_state *cli;
+       struct smbcli_state *cli;
        BOOL ret = True;
        TALLOC_CTX *mem_ctx;
 
@@ -686,23 +687,12 @@ BOOL torture_raw_write(int dummy)
 
        mem_ctx = talloc_init("torture_raw_write");
 
-       if (!test_write(cli, mem_ctx)) {
-               ret = False;
-       }
-
-       if (!test_writeunlock(cli, mem_ctx)) {
-               ret = False;
-       }
-
-       if (!test_writeclose(cli, mem_ctx)) {
-               ret = False;
-       }
-
-       if (!test_writex(cli, mem_ctx)) {
-               ret = False;
-       }
+       ret &= test_write(cli, mem_ctx);
+       ret &= test_writeunlock(cli, mem_ctx);
+       ret &= test_writeclose(cli, mem_ctx);
+       ret &= test_writex(cli, mem_ctx);
 
        torture_close_connection(cli);
-       talloc_destroy(mem_ctx);
+       talloc_free(mem_ctx);
        return ret;
 }