Convert libcli routines to return NTSTATUS instead of BOOL. Again, the

only users are smbclient and smbtorture.
(This used to be commit 54cb508c78e5c1faa3ade46b46b165983c880d10)

26 files changed, 394 insertions, 394 deletions

diff --git a/source4/client/client.c b/source4/client/client.c
index ce754498f8..fef258a6b2 100644
--- a/source4/client/client.c
+++ b/source4/client/client.c
@@ -243,7 +243,7 @@ static int do_dskattr(void)
 {
 	int total, bsize, avail;
 
-	if (!cli_dskattr(cli->tree, &bsize, &total, &avail)) {
+	if (NT_STATUS_IS_ERR(cli_dskattr(cli->tree, &bsize, &total, &avail))) {
 		d_printf("Error in dskattr: %s\n",cli_errstr(cli->tree)); 
 		return 1;
 	}
@@ -292,7 +292,7 @@ static int do_cd(char *newdir)
 	dos_clean_name(cur_dir);
 	
 	if (!strequal(cur_dir,"\\")) {
-		if (!cli_chkpath(cli->tree, dname)) {
+		if (NT_STATUS_IS_ERR(cli_chkpath(cli->tree, dname))) {
 			d_printf("cd %s: %s\n", dname, cli_errstr(cli->tree));
 			pstrcpy(cur_dir,saved_dir);
 		}
@@ -759,10 +759,10 @@ static int do_get(char *rname, const char *lname, BOOL reget)
 	}
 
 
-	if (!cli_qfileinfo(cli->tree, fnum, 
-			   &attr, &size, NULL, NULL, NULL, NULL, NULL) &&
-	    !cli_getattrE(cli->tree, fnum, 
-			  &attr, &size, NULL, NULL, NULL)) {
+	if (NT_STATUS_IS_ERR(cli_qfileinfo(cli->tree, fnum, 
+			   &attr, &size, NULL, NULL, NULL, NULL, NULL)) &&
+	    NT_STATUS_IS_ERR(cli_getattrE(cli->tree, fnum, 
+			  &attr, &size, NULL, NULL, NULL))) {
 		d_printf("getattrib: %s\n",cli_errstr(cli->tree));
 		return 1;
 	}
@@ -799,7 +799,7 @@ static int do_get(char *rname, const char *lname, BOOL reget)
 
 	SAFE_FREE(data);
 	
-	if (!cli_close(cli->tree, fnum)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnum))) {
 		d_printf("Error %s closing remote file\n",cli_errstr(cli->tree));
 		rc = 1;
 	}
@@ -1011,15 +1011,17 @@ static int cmd_mget(void)
 /****************************************************************************
 make a directory of name "name"
 ****************************************************************************/
-static BOOL do_mkdir(char *name)
+static NTSTATUS do_mkdir(char *name)
 {
-	if (!cli_mkdir(cli->tree, name)) {
+	NTSTATUS status;
+
+	if (NT_STATUS_IS_ERR(status = cli_mkdir(cli->tree, name))) {
 		d_printf("%s making remote directory %s\n",
 			 cli_errstr(cli->tree),name);
-		return(False);
+		return status;
 	}
 
-	return(True);
+	return status;
 }
 
 /****************************************************************************
@@ -1079,7 +1081,7 @@ static int cmd_mkdir(void)
 		p = strtok(ddir,"/\\");
 		while (p) {
 			pstrcat(ddir2,p);
-			if (!cli_chkpath(cli->tree, ddir2)) { 
+			if (NT_STATUS_IS_ERR(cli_chkpath(cli->tree, ddir2))) { 
 				do_mkdir(ddir2);
 			}
 			pstrcat(ddir2,"\\");
@@ -1135,8 +1137,8 @@ static int do_put(char *rname, char *lname, BOOL reput)
 	if (reput) {
 		fnum = cli_open(cli->tree, rname, O_RDWR|O_CREAT, DENY_NONE);
 		if (fnum >= 0) {
-			if (!cli_qfileinfo(cli->tree, fnum, NULL, &start, NULL, NULL, NULL, NULL, NULL) &&
-			    !cli_getattrE(cli->tree, fnum, NULL, &start, NULL, NULL, NULL)) {
+			if (NT_STATUS_IS_ERR(cli_qfileinfo(cli->tree, fnum, NULL, &start, NULL, NULL, NULL, NULL, NULL)) &&
+			    NT_STATUS_IS_ERR(cli_getattrE(cli->tree, fnum, NULL, &start, NULL, NULL, NULL))) {
 				d_printf("getattrib: %s\n",cli_errstr(cli->tree));
 				return 1;
 			}
@@ -1207,7 +1209,7 @@ static int do_put(char *rname, char *lname, BOOL reput)
 		nread += n;
 	}
 
-	if (!cli_close(cli->tree, fnum)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnum))) {
 		d_printf("%s closing remote file %s\n",cli_errstr(cli->tree),rname);
 		x_fclose(f);
 		SAFE_FREE(buf);
@@ -1453,8 +1455,8 @@ static int cmd_mput(void)
 	      				SAFE_FREE(rname);
 					if(asprintf(&rname, "%s%s", cur_dir, lname) < 0) break;
 					dos_format(rname);
-					if (!cli_chkpath(cli->tree, rname) && 
-					    !do_mkdir(rname)) {
+					if (NT_STATUS_IS_ERR(cli_chkpath(cli->tree, rname)) && 
+					    NT_STATUS_IS_ERR(do_mkdir(rname))) {
 						DEBUG (0, ("Unable to make dir, skipping..."));
 						/* Skip the directory */
 						lname[strlen(lname)-1] = '/';
@@ -1570,7 +1572,7 @@ static void do_del(file_info *finfo)
 	if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) 
 		return;
 
-	if (!cli_unlink(cli->tree, mask)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(cli->tree, mask))) {
 		d_printf("%s deleting remote file %s\n",cli_errstr(cli->tree),mask);
 	}
 }
@@ -1822,7 +1824,7 @@ static int cmd_rmdir(void)
 	}
 	pstrcat(mask,buf);
 
-	if (!cli_rmdir(cli->tree, mask)) {
+	if (NT_STATUS_IS_ERR(cli_rmdir(cli->tree, mask))) {
 		d_printf("%s removing remote directory file %s\n",
 			 cli_errstr(cli->tree),mask);
 	}
@@ -1855,7 +1857,7 @@ static int cmd_link(void)
 	pstrcat(src,buf);
 	pstrcat(dest,buf2);
 
-	if (!cli_unix_hardlink(cli->tree, src, dest)) {
+	if (NT_STATUS_IS_ERR(cli_unix_hardlink(cli->tree, src, dest))) {
 		d_printf("%s linking files (%s -> %s)\n", cli_errstr(cli->tree), src, dest);
 		return 1;
 	}  
@@ -1889,7 +1891,7 @@ static int cmd_symlink(void)
 	pstrcat(src,buf);
 	pstrcat(dest,buf2);
 
-	if (!cli_unix_symlink(cli->tree, src, dest)) {
+	if (NT_STATUS_IS_ERR(cli_unix_symlink(cli->tree, src, dest))) {
 		d_printf("%s symlinking files (%s -> %s)\n",
 			cli_errstr(cli->tree), src, dest);
 		return 1;
@@ -1924,7 +1926,7 @@ static int cmd_chmod(void)
 	mode = (mode_t)strtol(buf, NULL, 8);
 	pstrcat(src,buf2);
 
-	if (!cli_unix_chmod(cli->tree, src, mode)) {
+	if (NT_STATUS_IS_ERR(cli_unix_chmod(cli->tree, src, mode))) {
 		d_printf("%s chmod file %s 0%o\n",
 			cli_errstr(cli->tree), src, (unsigned int)mode);
 		return 1;
@@ -1962,7 +1964,7 @@ static int cmd_chown(void)
 	gid = (gid_t)atoi(buf2);
 	pstrcat(src,buf3);
 
-	if (!cli_unix_chown(cli->tree, src, uid, gid)) {
+	if (NT_STATUS_IS_ERR(cli_unix_chown(cli->tree, src, uid, gid))) {
 		d_printf("%s chown file %s uid=%d, gid=%d\n",
 			cli_errstr(cli->tree), src, (int)uid, (int)gid);
 		return 1;
@@ -1991,7 +1993,7 @@ static int cmd_rename(void)
 	pstrcat(src,buf);
 	pstrcat(dest,buf2);
 
-	if (!cli_rename(cli->tree, src, dest)) {
+	if (NT_STATUS_IS_ERR(cli_rename(cli->tree, src, dest))) {
 		d_printf("%s renaming files\n",cli_errstr(cli->tree));
 		return 1;
 	}
@@ -2732,7 +2734,7 @@ static struct cli_state *do_connect(const char *server, const char *share)
 
 	DEBUG(4,(" session request ok\n"));
 
-	if (!cli_negprot(c)) {
+	if (NT_STATUS_IS_ERR(cli_negprot(c))) {
 		d_printf("protocol negotiation failed\n");
 		cli_shutdown(c);
 		return NULL;
@@ -2745,11 +2747,11 @@ static struct cli_state *do_connect(const char *server, const char *share)
 		}
 	}
 
-	if (!cli_session_setup(c, username, password, 
-			       lp_workgroup())) {
+	if (NT_STATUS_IS_ERR(cli_session_setup(c, username, password, 
+					       lp_workgroup()))) {
 		/* if a password was not supplied then try again with a null username */
 		if (password[0] || !username[0] || use_kerberos ||
-		    !cli_session_setup(c, "", "", lp_workgroup())) { 
+		    NT_STATUS_IS_ERR(cli_session_setup(c, "", "", lp_workgroup()))) { 
 			d_printf("session setup failed: %s\n", cli_errstr(c->tree));
 			cli_shutdown(c);
 			return NULL;
@@ -2759,7 +2761,7 @@ static struct cli_state *do_connect(const char *server, const char *share)
 
 	DEBUG(4,(" session setup ok\n"));
 
-	if (!cli_send_tconX(c, sharename, "?????", password)) {
+	if (NT_STATUS_IS_ERR(cli_send_tconX(c, sharename, "?????", password))) {
 		d_printf("tree connect failed: %s\n", cli_errstr(c->tree));
 		cli_shutdown(c);
 		return NULL;
diff --git a/source4/client/clitar.c b/source4/client/clitar.c
index 2f423ede7d..da91ba4beb 100644
--- a/source4/client/clitar.c
+++ b/source4/client/clitar.c
@@ -539,8 +539,8 @@ static BOOL ensurepath(char *fname)
     {
       safe_strcat(partpath, p, strlen(fname) + 1);
 
-      if (!cli_chkpath(cli->tree, partpath)) {
-	if (!cli_mkdir(cli->tree, partpath))
+      if (NT_STATUS_IS_ERR(cli_chkpath(cli->tree, partpath))) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, partpath)))
 	  {
 	    DEBUG(0, ("Error mkdirhiering\n"));
 	    return False;
@@ -578,7 +578,8 @@ static void do_setrattr(char *name, uint16 attr, int set)
 {
 	uint16 oldattr;
 
-	if (!cli_getatr(cli->tree, name, &oldattr, NULL, NULL)) return;
+	if (NT_STATUS_IS_ERR(cli_getatr(cli->tree, name, &oldattr, NULL, NULL)))
+		return;
 
 	if (set == ATTRSET) {
 		attr |= oldattr;
@@ -586,7 +587,7 @@ static void do_setrattr(char *name, uint16 attr, int set)
 		attr = oldattr & ~attr;
 	}
 
-	if (!cli_setatr(cli->tree, name, attr, 0)) {
+	if (NT_STATUS_IS_ERR(cli_setatr(cli->tree, name, attr, 0))) {
 		DEBUG(1,("setatr failed: %s\n", cli_errstr(cli->tree)));
 	}
 }
@@ -663,7 +664,7 @@ static void do_atar(char *rname,char *lname,file_info *finfo1)
   safe_strcpy(finfo.name,rname, strlen(rname));
   if (!finfo1) {
 	  size_t size;
-	  if (!cli_getattrE(cli->tree, fnum, &finfo.mode, &size, NULL, &finfo.atime, &finfo.mtime)) {
+	  if (NT_STATUS_IS_ERR(cli_getattrE(cli->tree, fnum, &finfo.mode, &size, NULL, &finfo.atime, &finfo.mtime))) {
 		  DEBUG(0, ("getattrE: %s\n", cli_errstr(cli->tree)));
 		  return;
 	  }
@@ -1036,7 +1037,7 @@ static int get_file(file_info2 finfo)
 
   /* Now close the file ... */
 
-  if (!cli_close(cli->tree, fnum)) {
+  if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnum))) {
 	  DEBUG(0, ("Error closing remote file\n"));
 	  return(False);
   }
@@ -1045,7 +1046,7 @@ static int get_file(file_info2 finfo)
 
   DEBUG(5, ("Updating creation date on %s\n", finfo.name));
 
-  if (!cli_setatr(cli->tree, finfo.name, finfo.mode, finfo.mtime)) {
+  if (NT_STATUS_IS_ERR(cli_setatr(cli->tree, finfo.name, finfo.mode, finfo.mtime))) {
 	  if (tar_real_noisy) {
 		  DEBUG(0, ("Could not set time on file: %s\n", finfo.name));
 		  /*return(False); */ /* Ignore, as Win95 does not allow changes */
diff --git a/source4/libcli/cliconnect.c b/source4/libcli/cliconnect.c
index 4fdffa6287..e2d9665792 100644
--- a/source4/libcli/cliconnect.c
+++ b/source4/libcli/cliconnect.c
@@ -53,28 +53,26 @@ BOOL cli_transport_establish(struct cli_state *cli,
 }
 
 /* wrapper around smb_raw_negotiate() */
-BOOL cli_negprot(struct cli_state *cli)
+NTSTATUS cli_negprot(struct cli_state *cli)
 {
-	NTSTATUS status;
-	status = smb_raw_negotiate(cli->transport);
-	return NT_STATUS_IS_OK(status);
+	return smb_raw_negotiate(cli->transport);
 }
 
 /* wrapper around smb_raw_session_setup() */
-BOOL cli_session_setup(struct cli_state *cli, 
-		       const char *user, 
-		       const char *password, 
-		       const char *domain)
+NTSTATUS cli_session_setup(struct cli_state *cli, 
+			   const char *user, 
+			   const char *password, 
+			   const char *domain)
 {
 	union smb_sesssetup setup;
 	NTSTATUS status;
 	TALLOC_CTX *mem_ctx;
 
 	cli->session = cli_session_init(cli->transport);
-	if (!cli->session) return False;
+	if (!cli->session) return NT_STATUS_UNSUCCESSFUL;
 
 	mem_ctx = talloc_init("cli_session_setup");
-	if (!mem_ctx) return False;
+	if (!mem_ctx) return NT_STATUS_NO_MEMORY;
 
 	setup.generic.level = RAW_SESSSETUP_GENERIC;
 	setup.generic.in.sesskey = cli->transport->negotiate.sesskey;
@@ -91,19 +89,19 @@ BOOL cli_session_setup(struct cli_state *cli,
 
 	talloc_destroy(mem_ctx);
 
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 /* wrapper around smb_tree_connect() */
-BOOL cli_send_tconX(struct cli_state *cli, const char *sharename, const char *devtype,
-		    const char *password)
+NTSTATUS cli_send_tconX(struct cli_state *cli, const char *sharename, 
+			const char *devtype, const char *password)
 {
 	union smb_tcon tcon;
 	TALLOC_CTX *mem_ctx;
 	NTSTATUS status;
 
 	cli->tree = cli_tree_init(cli->session);
-	if (!cli->tree) return False;
+	if (!cli->tree) return NT_STATUS_UNSUCCESSFUL;
 
 	cli->tree->reference_count++;
 
@@ -115,9 +113,8 @@ BOOL cli_send_tconX(struct cli_state *cli, const char *sharename, const char *de
 	tcon.tconx.in.device = devtype;
 	
 	mem_ctx = talloc_init("tcon");
-	if (!mem_ctx) {
-		return False;
-	}
+	if (!mem_ctx)
+		return NT_STATUS_NO_MEMORY;
 
 	status = smb_tree_connect(cli->tree, mem_ctx, &tcon);
 
@@ -125,7 +122,7 @@ BOOL cli_send_tconX(struct cli_state *cli, const char *sharename, const char *de
 
 	talloc_destroy(mem_ctx);
 
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 
@@ -182,11 +179,9 @@ done:
 /*
   disconnect the tree
 */
-BOOL cli_tdis(struct cli_state *cli)
+NTSTATUS cli_tdis(struct cli_state *cli)
 {
-	NTSTATUS status;
-	status = smb_tree_disconnect(cli->tree);
-	return NT_STATUS_IS_OK(status);
+	return smb_tree_disconnect(cli->tree);
 }
 
 /****************************************************************************
diff --git a/source4/libcli/clideltree.c b/source4/libcli/clideltree.c
index d28950f136..2bbfd9bd22 100644
--- a/source4/libcli/clideltree.c
+++ b/source4/libcli/clideltree.c
@@ -41,7 +41,7 @@ static void delete_fn(file_info *finfo, const char *name, void *state)
 	asprintf(&s, "%s%s", n, finfo->name);
 
 	if (finfo->mode & FILE_ATTRIBUTE_READONLY) {
-		if (!cli_setatr(dstate->tree, s, 0, 0)) {
+		if (NT_STATUS_IS_ERR(cli_setatr(dstate->tree, s, 0, 0))) {
 			DEBUG(2,("Failed to remove READONLY on %s - %s\n",
 				 s, cli_errstr(dstate->tree)));			
 		}
@@ -55,14 +55,14 @@ static void delete_fn(file_info *finfo, const char *name, void *state)
 			 FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM, 
 			 delete_fn, state);
 		free(s2);
-		if (!cli_rmdir(dstate->tree, s)) {
+		if (NT_STATUS_IS_ERR(cli_rmdir(dstate->tree, s))) {
 			DEBUG(2,("Failed to delete %s - %s\n", 
 				 s, cli_errstr(dstate->tree)));
 			dstate->failed = True;
 		}
 		dstate->total_deleted++;
 	} else {
-		if (!cli_unlink(dstate->tree, s)) {
+		if (NT_STATUS_IS_ERR(cli_unlink(dstate->tree, s))) {
 			DEBUG(2,("Failed to delete %s - %s\n", 
 				 s, cli_errstr(dstate->tree)));
 			dstate->failed = True;
@@ -87,7 +87,7 @@ int cli_deltree(struct cli_tree *tree, const char *dname)
 	dstate.failed = False;
 
 	/* it might be a file */
-	if (cli_unlink(tree, dname)) {
+	if (NT_STATUS_IS_OK(cli_unlink(tree, dname))) {
 		return 1;
 	}
 	if (NT_STATUS_EQUAL(cli_nt_error(tree), NT_STATUS_OBJECT_NAME_NOT_FOUND) ||
@@ -102,7 +102,7 @@ int cli_deltree(struct cli_tree *tree, const char *dname)
 		 FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM, 
 		 delete_fn, &dstate);
 	free(mask);
-	if (!cli_rmdir(dstate.tree, dname)) {
+	if (NT_STATUS_IS_ERR(cli_rmdir(dstate.tree, dname))) {
 		DEBUG(2,("Failed to delete %s - %s\n", 
 			 dname, cli_errstr(dstate.tree)));
 		return -1;
diff --git a/source4/libcli/clifile.c b/source4/libcli/clifile.c
index 6606455e49..5432834522 100644
--- a/source4/libcli/clifile.c
+++ b/source4/libcli/clifile.c
@@ -26,9 +26,9 @@
  Hard/Symlink a file (UNIX extensions).
 ****************************************************************************/
 
-static BOOL cli_link_internal(struct cli_tree *tree, 
-			      const char *fname_src, 
-			      const char *fname_dst, BOOL hard_link)
+static NTSTATUS cli_link_internal(struct cli_tree *tree, 
+				  const char *fname_src, 
+				  const char *fname_dst, BOOL hard_link)
 {
 	union smb_setfileinfo parms;
 	NTSTATUS status;
@@ -45,13 +45,13 @@ static BOOL cli_link_internal(struct cli_tree *tree,
 	
 	status = smb_raw_setpathinfo(tree, &parms);
 
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 /****************************************************************************
  Map standard UNIX permissions onto wire representations.
 ****************************************************************************/
-static uint32  unix_perms_to_wire(mode_t perms)
+static uint32 unix_perms_to_wire(mode_t perms)
 {
         unsigned int ret = 0;
 
@@ -79,8 +79,8 @@ static uint32  unix_perms_to_wire(mode_t perms)
 /****************************************************************************
  Symlink a file (UNIX extensions).
 ****************************************************************************/
-BOOL cli_unix_symlink(struct cli_tree *tree, const char *fname_src, 
-		      const char *fname_dst)
+NTSTATUS cli_unix_symlink(struct cli_tree *tree, const char *fname_src, 
+			  const char *fname_dst)
 {
 	return cli_link_internal(tree, fname_src, fname_dst, False);
 }
@@ -88,8 +88,8 @@ BOOL cli_unix_symlink(struct cli_tree *tree, const char *fname_src,
 /****************************************************************************
  Hard a file (UNIX extensions).
 ****************************************************************************/
-BOOL cli_unix_hardlink(struct cli_tree *tree, const char *fname_src, 
-		       const char *fname_dst)
+NTSTATUS cli_unix_hardlink(struct cli_tree *tree, const char *fname_src, 
+			   const char *fname_dst)
 {
 	return cli_link_internal(tree, fname_src, fname_dst, True);
 }
@@ -98,9 +98,10 @@ BOOL cli_unix_hardlink(struct cli_tree *tree, const char *fname_src,
 /****************************************************************************
  Chmod or chown a file internal (UNIX extensions).
 ****************************************************************************/
-static BOOL cli_unix_chmod_chown_internal(struct cli_tree *tree, 
-					  const char *fname, 
-					  uint32 mode, uint32 uid, uint32 gid)
+static NTSTATUS cli_unix_chmod_chown_internal(struct cli_tree *tree, 
+					      const char *fname, 
+					      uint32 mode, uint32 uid, 
+					      uint32 gid)
 {
 	union smb_setfileinfo parms;
 	NTSTATUS status;
@@ -113,14 +114,14 @@ static BOOL cli_unix_chmod_chown_internal(struct cli_tree *tree,
 	
 	status = smb_raw_setpathinfo(tree, &parms);
 
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 /****************************************************************************
  chmod a file (UNIX extensions).
 ****************************************************************************/
 
-BOOL cli_unix_chmod(struct cli_tree *tree, const char *fname, mode_t mode)
+NTSTATUS cli_unix_chmod(struct cli_tree *tree, const char *fname, mode_t mode)
 {
 	return cli_unix_chmod_chown_internal(tree, fname, 
 					     unix_perms_to_wire(mode), 
@@ -131,8 +132,8 @@ BOOL cli_unix_chmod(struct cli_tree *tree, const char *fname, mode_t mode)
 /****************************************************************************
  chown a file (UNIX extensions).
 ****************************************************************************/
-BOOL cli_unix_chown(struct cli_tree *tree, const char *fname, uid_t uid, 
-		    gid_t gid)
+NTSTATUS cli_unix_chown(struct cli_tree *tree, const char *fname, uid_t uid, 
+			gid_t gid)
 {
 	return cli_unix_chmod_chown_internal(tree, fname, SMB_MODE_NO_CHANGE, 
 					     (uint32)uid, (uint32)gid);
@@ -142,8 +143,8 @@ BOOL cli_unix_chown(struct cli_tree *tree, const char *fname, uid_t uid,
 /****************************************************************************
  Rename a file.
 ****************************************************************************/
-BOOL cli_rename(struct cli_tree *tree, const char *fname_src, 
-		const char *fname_dst)
+NTSTATUS cli_rename(struct cli_tree *tree, const char *fname_src, 
+		    const char *fname_dst)
 {
 	union smb_rename parms;
 
@@ -151,14 +152,15 @@ BOOL cli_rename(struct cli_tree *tree, const char *fname_src,
 	parms.rename.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
 	parms.rename.in.pattern1 = fname_src;
 	parms.rename.in.pattern2 = fname_dst;
-	return NT_STATUS_IS_OK(smb_raw_rename(tree, &parms));
+
+	return smb_raw_rename(tree, &parms);
 }
 
 
 /****************************************************************************
  Delete a file.
 ****************************************************************************/
-BOOL cli_unlink(struct cli_tree *tree, const char *fname)
+NTSTATUS cli_unlink(struct cli_tree *tree, const char *fname)
 {
 	struct smb_unlink parms;
 
@@ -168,39 +170,41 @@ BOOL cli_unlink(struct cli_tree *tree, const char *fname)
 	} else {
 		parms.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
 	}
-	return NT_STATUS_IS_OK(smb_raw_unlink(tree, &parms));
+
+	return smb_raw_unlink(tree, &parms);
 }
 
 /****************************************************************************
  Create a directory.
 ****************************************************************************/
-BOOL cli_mkdir(struct cli_tree *tree, const char *dname)
+NTSTATUS cli_mkdir(struct cli_tree *tree, const char *dname)
 {
 	union smb_mkdir parms;
 
 	parms.mkdir.level = RAW_MKDIR_MKDIR;
 	parms.mkdir.in.path = dname;
 
-	return NT_STATUS_IS_OK(smb_raw_mkdir(tree, &parms));
+	return smb_raw_mkdir(tree, &parms);
 }
 
 
 /****************************************************************************
  Remove a directory.
 ****************************************************************************/
-BOOL cli_rmdir(struct cli_tree *tree, const char *dname)
+NTSTATUS cli_rmdir(struct cli_tree *tree, const char *dname)
 {
 	struct smb_rmdir parms;
 
 	parms.in.path = dname;
-	return NT_STATUS_IS_OK(smb_raw_rmdir(tree, &parms));
+
+	return smb_raw_rmdir(tree, &parms);
 }
 
 
 /****************************************************************************
  Set or clear the delete on close flag.
 ****************************************************************************/
-BOOL cli_nt_delete_on_close(struct cli_tree *tree, int fnum, BOOL flag)
+NTSTATUS cli_nt_delete_on_close(struct cli_tree *tree, int fnum, BOOL flag)
 {
 	union smb_setfileinfo parms;
 	NTSTATUS status;
@@ -211,7 +215,7 @@ BOOL cli_nt_delete_on_close(struct cli_tree *tree, int fnum, BOOL flag)
 	
 	status = smb_raw_setfileinfo(tree, &parms);
 
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 
@@ -326,7 +330,7 @@ int cli_open(struct cli_tree *tree, const char *fname, int flags,
 /****************************************************************************
  Close a file.
 ****************************************************************************/
-BOOL cli_close(struct cli_tree *tree, int fnum)
+NTSTATUS cli_close(struct cli_tree *tree, int fnum)
 {
 	union smb_close close_parms;
 	NTSTATUS status;
@@ -335,7 +339,7 @@ BOOL cli_close(struct cli_tree *tree, int fnum)
 	close_parms.close.in.fnum = fnum;
 	close_parms.close.in.write_time = 0;
 	status = smb_raw_close(tree, &close_parms);
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 /****************************************************************************
@@ -343,7 +347,8 @@ BOOL cli_close(struct cli_tree *tree, int fnum)
  this is used for testing LOCKING_ANDX_CANCEL_LOCK
 ****************************************************************************/
 NTSTATUS cli_locktype(struct cli_tree *tree, int fnum, 
-		      uint32 offset, uint32 len, int timeout, unsigned char locktype)
+		      uint32 offset, uint32 len, int timeout, 
+		      unsigned char locktype)
 {
 	union smb_lock parms;
 	struct smb_lock_entry lock[1];
@@ -369,8 +374,9 @@ NTSTATUS cli_locktype(struct cli_tree *tree, int fnum,
 /****************************************************************************
  Lock a file.
 ****************************************************************************/
-BOOL cli_lock(struct cli_tree *tree, int fnum, 
-	      uint32 offset, uint32 len, int timeout, enum brl_type lock_type)
+NTSTATUS cli_lock(struct cli_tree *tree, int fnum, 
+		  uint32 offset, uint32 len, int timeout, 
+		  enum brl_type lock_type)
 {
 	union smb_lock parms;
 	struct smb_lock_entry lock[1];
@@ -389,14 +395,14 @@ BOOL cli_lock(struct cli_tree *tree, int fnum,
 
 	status = smb_raw_lock(tree, &parms);
 
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 
 /****************************************************************************
  Unlock a file.
 ****************************************************************************/
-BOOL cli_unlock(struct cli_tree *tree, int fnum, uint32 offset, uint32 len)
+NTSTATUS cli_unlock(struct cli_tree *tree, int fnum, uint32 offset, uint32 len)
 {
 	union smb_lock parms;
 	struct smb_lock_entry lock[1];
@@ -414,15 +420,16 @@ BOOL cli_unlock(struct cli_tree *tree, int fnum, uint32 offset, uint32 len)
 	parms.lockx.in.locks = &lock[0];
 	
 	status = smb_raw_lock(tree, &parms);
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 	
 
 /****************************************************************************
  Lock a file with 64 bit offsets.
 ****************************************************************************/
-BOOL cli_lock64(struct cli_tree *tree, int fnum, 
-		SMB_OFF_T offset, SMB_OFF_T len, int timeout, enum brl_type lock_type)
+NTSTATUS cli_lock64(struct cli_tree *tree, int fnum, 
+		    SMB_OFF_T offset, SMB_OFF_T len, int timeout, 
+		    enum brl_type lock_type)
 {
 	union smb_lock parms;
 	int ltype;
@@ -449,14 +456,15 @@ BOOL cli_lock64(struct cli_tree *tree, int fnum,
 
 	status = smb_raw_lock(tree, &parms);
 	
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 
 /****************************************************************************
  Unlock a file with 64 bit offsets.
 ****************************************************************************/
-BOOL cli_unlock64(struct cli_tree *tree, int fnum, SMB_OFF_T offset, SMB_OFF_T len)
+NTSTATUS cli_unlock64(struct cli_tree *tree, int fnum, SMB_OFF_T offset, 
+		      SMB_OFF_T len)
 {
 	union smb_lock parms;
 	struct smb_lock_entry lock[1];
@@ -479,16 +487,16 @@ BOOL cli_unlock64(struct cli_tree *tree, int fnum, SMB_OFF_T offset, SMB_OFF_T l
 
 	status = smb_raw_lock(tree, &parms);
 
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 
 /****************************************************************************
  Do a SMBgetattrE call.
 ****************************************************************************/
-BOOL cli_getattrE(struct cli_tree *tree, int fd,
-		  uint16 *attr, size_t *size,
-		  time_t *c_time, time_t *a_time, time_t *m_time)
+NTSTATUS cli_getattrE(struct cli_tree *tree, int fd,
+		      uint16 *attr, size_t *size,
+		      time_t *c_time, time_t *a_time, time_t *m_time)
 {		
 	union smb_fileinfo parms;
 	NTSTATUS status;
@@ -499,7 +507,7 @@ BOOL cli_getattrE(struct cli_tree *tree, int fd,
 	status = smb_raw_fileinfo(tree, NULL, &parms);
 
 	if (!NT_STATUS_IS_OK(status))
-		return False;
+		return status;
 
 	if (size) {
 		*size = parms.getattre.out.size;
@@ -521,14 +529,14 @@ BOOL cli_getattrE(struct cli_tree *tree, int fd,
 		*m_time = parms.getattre.out.write_time;
 	}
 
-	return True;
+	return status;
 }
 
 /****************************************************************************
  Do a SMBgetatr call
 ****************************************************************************/
-BOOL cli_getatr(struct cli_tree *tree, const char *fname, 
-		uint16 *attr, size_t *size, time_t *t)
+NTSTATUS cli_getatr(struct cli_tree *tree, const char *fname, 
+		    uint16 *attr, size_t *size, time_t *t)
 {
 	union smb_fileinfo parms;
 	NTSTATUS status;
@@ -539,7 +547,7 @@ BOOL cli_getatr(struct cli_tree *tree, const char *fname,
 	status = smb_raw_pathinfo(tree, NULL, &parms);
 	
 	if (!NT_STATUS_IS_OK(status)) {
-		return False;
+		return status;
 	}
 
 	if (size) {
@@ -554,14 +562,15 @@ BOOL cli_getatr(struct cli_tree *tree, const char *fname,
 		*attr = parms.getattr.out.attrib;
 	}
 
-	return True;
+	return status;
 }
 
 
 /****************************************************************************
  Do a SMBsetatr call.
 ****************************************************************************/
-BOOL cli_setatr(struct cli_tree *tree, const char *fname, uint16 mode, time_t t)
+NTSTATUS cli_setatr(struct cli_tree *tree, const char *fname, uint16 mode, 
+		    time_t t)
 {
 	union smb_setfileinfo parms;
 	NTSTATUS status;
@@ -573,14 +582,14 @@ BOOL cli_setatr(struct cli_tree *tree, const char *fname, uint16 mode, time_t t)
 	
 	status = smb_raw_setpathinfo(tree, &parms);
 
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 
 /****************************************************************************
  Check for existence of a dir.
 ****************************************************************************/
-BOOL cli_chkpath(struct cli_tree *tree, const char *path)
+NTSTATUS cli_chkpath(struct cli_tree *tree, const char *path)
 {
 	struct smb_chkpath parms;
 	char *path2;
@@ -599,14 +608,14 @@ BOOL cli_chkpath(struct cli_tree *tree, const char *path)
 
 	free(path2);
 
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 
 /****************************************************************************
  Query disk space.
 ****************************************************************************/
-BOOL cli_dskattr(struct cli_tree *tree, int *bsize, int *total, int *avail)
+NTSTATUS cli_dskattr(struct cli_tree *tree, int *bsize, int *total, int *avail)
 {
 	union smb_fsinfo fsinfo_parms;
 	TALLOC_CTX *mem_ctx;
@@ -624,7 +633,7 @@ BOOL cli_dskattr(struct cli_tree *tree, int *bsize, int *total, int *avail)
 
 	talloc_destroy(mem_ctx);
 	
-	return NT_STATUS_IS_OK(status);
+	return status;
 }
 
 
@@ -654,4 +663,3 @@ int cli_ctemp(struct cli_tree *tree, const char *path, char **tmp_path)
 	}
 	return -1;
 }
-
diff --git a/source4/libcli/clitrans2.c b/source4/libcli/clitrans2.c
index c8f7db5a9d..777150a257 100644
--- a/source4/libcli/clitrans2.c
+++ b/source4/libcli/clitrans2.c
@@ -23,25 +23,24 @@
 /****************************************************************************
 send a qpathinfo call
 ****************************************************************************/
-BOOL cli_qpathinfo(struct cli_tree *tree, const char *fname, 
-		   time_t *c_time, time_t *a_time, time_t *m_time, 
-		   size_t *size, uint16 *mode)
+NTSTATUS cli_qpathinfo(struct cli_tree *tree, const char *fname, 
+		       time_t *c_time, time_t *a_time, time_t *m_time, 
+		       size_t *size, uint16 *mode)
 {
 	union smb_fileinfo parms;
 	TALLOC_CTX *mem_ctx;
 	NTSTATUS status;
 
 	mem_ctx = talloc_init("cli_qpathinfo");
-	if (!mem_ctx) return False;
+	if (!mem_ctx) return NT_STATUS_NO_MEMORY;
 
 	parms.standard.level = RAW_FILEINFO_STANDARD;
 	parms.standard.in.fname = fname;
 
 	status = smb_raw_pathinfo(tree, mem_ctx, &parms);
 	talloc_destroy(mem_ctx);
-	if (!NT_STATUS_IS_OK(status)) {
-		return False;
-	}
+	if (!NT_STATUS_IS_OK(status))
+		return status;
 
 	if (c_time) {
 		*c_time = parms.standard.out.create_time;
@@ -59,32 +58,31 @@ BOOL cli_qpathinfo(struct cli_tree *tree, const char *fname,
 		*mode = parms.standard.out.attrib;
 	}
 
-	return True;
+	return status;
 }
 
 /****************************************************************************
 send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level
 ****************************************************************************/
-BOOL cli_qpathinfo2(struct cli_tree *tree, const char *fname, 
-		    time_t *c_time, time_t *a_time, time_t *m_time, 
-		    time_t *w_time, size_t *size, uint16 *mode,
-		    SMB_INO_T *ino)
+NTSTATUS cli_qpathinfo2(struct cli_tree *tree, const char *fname, 
+			time_t *c_time, time_t *a_time, time_t *m_time, 
+			time_t *w_time, size_t *size, uint16 *mode,
+			SMB_INO_T *ino)
 {
 	union smb_fileinfo parms;
 	TALLOC_CTX *mem_ctx;
 	NTSTATUS status;
 
 	mem_ctx = talloc_init("cli_qfilename");
-	if (!mem_ctx) return False;
+	if (!mem_ctx) return NT_STATUS_NO_MEMORY;
 
 	parms.all_info.level = RAW_FILEINFO_ALL_INFO;
 	parms.all_info.in.fname = fname;
 
 	status = smb_raw_pathinfo(tree, mem_ctx, &parms);
 	talloc_destroy(mem_ctx);
-	if (!NT_STATUS_IS_OK(status)) {
-		return False;
-	}
+	if (!NT_STATUS_IS_OK(status))
+		return status;
 
 	if (c_time) {
 		*c_time = nt_time_to_unix(&parms.all_info.out.create_time);
@@ -105,22 +103,21 @@ BOOL cli_qpathinfo2(struct cli_tree *tree, const char *fname,
 		*mode = parms.all_info.out.attrib;
 	}
 
-	return True;
+	return status;
 }
 
 
 /****************************************************************************
 send a qfileinfo QUERY_FILE_NAME_INFO call
 ****************************************************************************/
-BOOL cli_qfilename(struct cli_tree *tree, int fnum, 
-		   const char **name)
+NTSTATUS cli_qfilename(struct cli_tree *tree, int fnum, const char **name)
 {
 	union smb_fileinfo parms;
 	TALLOC_CTX *mem_ctx;
 	NTSTATUS status;
 
 	mem_ctx = talloc_init("cli_qfilename");
-	if (!mem_ctx) return False;
+	if (!mem_ctx) return NT_STATUS_NO_MEMORY;
 
 	parms.name_info.level = RAW_FILEINFO_NAME_INFO;
 	parms.name_info.in.fnum = fnum;
@@ -129,31 +126,32 @@ BOOL cli_qfilename(struct cli_tree *tree, int fnum,
 	if (!NT_STATUS_IS_OK(status)) {
 		talloc_destroy(mem_ctx);
 		*name = NULL;
-		return False;
+		return status;
 	}
 
 	*name = strdup(parms.name_info.out.fname.s);
 
 	talloc_destroy(mem_ctx);
 
-	return True;
+	return status;
 }
 
 
 /****************************************************************************
 send a qfileinfo call
 ****************************************************************************/
-BOOL cli_qfileinfo(struct cli_tree *tree, int fnum, 
-		   uint16 *mode, size_t *size,
-		   time_t *c_time, time_t *a_time, time_t *m_time, 
-		   time_t *w_time, SMB_INO_T *ino)
+NTSTATUS cli_qfileinfo(struct cli_tree *tree, int fnum, 
+		       uint16 *mode, size_t *size,
+		       time_t *c_time, time_t *a_time, time_t *m_time, 
+		       time_t *w_time, SMB_INO_T *ino)
 {
 	union smb_fileinfo parms;
 	TALLOC_CTX *mem_ctx;
 	NTSTATUS status;
 
 	mem_ctx = talloc_init("cli_qfileinfo");
-	if (!mem_ctx) return False;
+	if (!mem_ctx) 
+		return NT_STATUS_NO_MEMORY;
 
 	parms.all_info.level = RAW_FILEINFO_ALL_INFO;
 	parms.all_info.in.fnum = fnum;
@@ -161,7 +159,7 @@ BOOL cli_qfileinfo(struct cli_tree *tree, int fnum,
 	status = smb_raw_fileinfo(tree, mem_ctx, &parms);
 	talloc_destroy(mem_ctx);
 	if (!NT_STATUS_IS_OK(status)) {
-		return False;
+		return status;
 	}
 
 	if (c_time) {
@@ -186,7 +184,7 @@ BOOL cli_qfileinfo(struct cli_tree *tree, int fnum,
 		*ino = 0;
 	}
 
-	return True;
+	return status;
 }
 
 
diff --git a/source4/torture/aliases.c b/source4/torture/aliases.c
index 9c8c366fd1..c4d6f94700 100644
--- a/source4/torture/aliases.c
+++ b/source4/torture/aliases.c
@@ -371,7 +371,7 @@ static void setpathinfo_aliases(struct cli_state *cli)
 
 	gen_set_aliases(cli, &t2, 0);
 
-	if (!cli_unlink(cli->tree, fname)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(cli->tree, fname))) {
 		printf("unlink: %s\n", cli_errstr(cli->tree));
 	}
 	talloc_destroy(mem_ctx);
diff --git a/source4/torture/gentest.c b/source4/torture/gentest.c
index 484ee9aee9..03a66487fa 100644
--- a/source4/torture/gentest.c
+++ b/source4/torture/gentest.c
@@ -127,8 +127,8 @@ static BOOL connect_servers_fast(void)
 	for (h=0;h<options.max_open_handles;h++) {
 		if (!open_handles[h].active) continue;
 		for (i=0;i<NSERVERS;i++) {
-			if (!cli_close(servers[i].cli[open_handles[h].instance]->tree,
-				       open_handles[h].server_fnum[i])) {
+			if (NT_STATUS_IS_ERR((cli_close(servers[i].cli[open_handles[h].instance]->tree,
+				       open_handles[h].server_fnum[i])))) {
 				return False;
 			}
 			open_handles[h].active = False;
@@ -234,8 +234,8 @@ static void gen_add_handle(int instance, const char *name, uint16 fnums[NSERVERS
 		/* we have to force close a random handle */
 		h = random() % options.max_open_handles;
 		for (i=0;i<NSERVERS;i++) {
-			if (!cli_close(servers[i].cli[open_handles[h].instance]->tree, 
-				       open_handles[h].server_fnum[i])) {
+			if (NT_STATUS_IS_ERR((cli_close(servers[i].cli[open_handles[h].instance]->tree, 
+				       open_handles[h].server_fnum[i])))) {
 				printf("INTERNAL ERROR: Close failed when recovering handle! - %s\n",
 				       cli_errstr(servers[i].cli[open_handles[h].instance]->tree));
 			}
@@ -1811,7 +1811,7 @@ static void wipe_files(void)
 			printf("Failed to wipe tree on server %d\n", i);
 			exit(1);
 		}
-		if (!cli_mkdir(servers[i].cli[0]->tree, "\\gentest")) {
+		if (NT_STATUS_IS_ERR(cli_mkdir(servers[i].cli[0]->tree, "\\gentest"))) {
 			printf("Failed to create \\gentest - %s\n",
 			       cli_errstr(servers[i].cli[0]->tree));
 			exit(1);
diff --git a/source4/torture/locktest.c b/source4/torture/locktest.c
index fcb229df08..cfc3d95cde 100644
--- a/source4/torture/locktest.c
+++ b/source4/torture/locktest.c
@@ -177,9 +177,9 @@ static BOOL test_one(struct cli_state *cli[NSERVERS][NCONNECTIONS],
 	case OP_LOCK:
 		/* set a lock */
 		for (server=0;server<NSERVERS;server++) {
-			ret[server] = cli_lock64(cli[server][conn]->tree, 
+			ret[server] = NT_STATUS_IS_OK(cli_lock64(cli[server][conn]->tree, 
 						 fnum[server][conn][f],
-						 start, len, LOCK_TIMEOUT, op);
+						 start, len, LOCK_TIMEOUT, op));
 			status[server] = cli_nt_error(cli[server][conn]->tree);
 			if (!exact_error_codes && 
 			    NT_STATUS_EQUAL(status[server], 
@@ -200,9 +200,9 @@ static BOOL test_one(struct cli_state *cli[NSERVERS][NCONNECTIONS],
 	case OP_UNLOCK:
 		/* unset a lock */
 		for (server=0;server<NSERVERS;server++) {
-			ret[server] = cli_unlock64(cli[server][conn]->tree, 
+			ret[server] = NT_STATUS_IS_OK(cli_unlock64(cli[server][conn]->tree, 
 						   fnum[server][conn][f],
-						   start, len);
+						   start, len));
 			status[server] = cli_nt_error(cli[server][conn]->tree);
 		}
 		if (showall || 
diff --git a/source4/torture/mangle_test.c b/source4/torture/mangle_test.c
index f0aaee18ec..94dac45b9d 100644
--- a/source4/torture/mangle_test.c
+++ b/source4/torture/mangle_test.c
@@ -42,7 +42,7 @@ static BOOL test_one(struct cli_state *cli, const char *name)
 		return False;
 	}
 
-	if (!cli_close(cli->tree, fnum)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnum))) {
 		printf("close of %s failed (%s)\n", name, cli_errstr(cli->tree));
 		return False;
 	}
@@ -55,7 +55,7 @@ static BOOL test_one(struct cli_state *cli, const char *name)
 	}
 
 	snprintf(name2, sizeof(name2), "\\mangle_test\\%s", shortname);
-	if (!cli_unlink(cli->tree, name2)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(cli->tree, name2))) {
 		printf("unlink of %s  (%s) failed (%s)\n", 
 		       name2, name, cli_errstr(cli->tree));
 		return False;
@@ -67,13 +67,13 @@ static BOOL test_one(struct cli_state *cli, const char *name)
 		printf("open2 of %s failed (%s)\n", name2, cli_errstr(cli->tree));
 		return False;
 	}
-	if (!cli_close(cli->tree, fnum)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnum))) {
 		printf("close of %s failed (%s)\n", name, cli_errstr(cli->tree));
 		return False;
 	}
 
 	/* and unlink by long name */
-	if (!cli_unlink(cli->tree, name)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(cli->tree, name))) {
 		printf("unlink2 of %s  (%s) failed (%s)\n", 
 		       name, name2, cli_errstr(cli->tree));
 		failures++;
@@ -170,7 +170,7 @@ BOOL torture_mangle(int dummy)
 	cli_unlink(cli->tree, "\\mangle_test\\*");
 	cli_rmdir(cli->tree, "\\mangle_test");
 
-	if (!cli_mkdir(cli->tree, "\\mangle_test")) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, "\\mangle_test"))) {
 		printf("ERROR: Failed to make directory\n");
 		return False;
 	}
@@ -190,7 +190,7 @@ BOOL torture_mangle(int dummy)
 	}
 
 	cli_unlink(cli->tree, "\\mangle_test\\*");
-	if (!cli_rmdir(cli->tree, "\\mangle_test")) {
+	if (NT_STATUS_IS_ERR(cli_rmdir(cli->tree, "\\mangle_test"))) {
 		printf("ERROR: Failed to remove directory\n");
 		return False;
 	}
diff --git a/source4/torture/nbio.c b/source4/torture/nbio.c
index 49688d6354..65584b1852 100644
--- a/source4/torture/nbio.c
+++ b/source4/torture/nbio.c
@@ -118,7 +118,7 @@ void nb_setup(struct cli_state *cli)
 
 void nb_unlink(const char *fname)
 {
-	if (!cli_unlink(c->tree, fname)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(c->tree, fname))) {
 #if NBDEBUG
 		printf("(%d) unlink %s failed (%s)\n", 
 		       line_count, fname, cli_errstr(c));
@@ -201,7 +201,7 @@ void nb_close(int handle)
 {
 	int i;
 	i = find_handle(handle);
-	if (!cli_close(c->tree, ftable[i].fd)) {
+	if (NT_STATUS_IS_ERR(cli_close(c->tree, ftable[i].fd))) {
 		printf("(%d) close failed on handle %d\n", line_count, handle);
 		exit(1);
 	}
@@ -210,7 +210,7 @@ void nb_close(int handle)
 
 void nb_rmdir(const char *fname)
 {
-	if (!cli_rmdir(c->tree, fname)) {
+	if (NT_STATUS_IS_ERR(cli_rmdir(c->tree, fname))) {
 		printf("ERROR: rmdir %s failed (%s)\n", 
 		       fname, cli_errstr(c->tree));
 		exit(1);
@@ -219,7 +219,7 @@ void nb_rmdir(const char *fname)
 
 void nb_rename(const char *old, const char *new)
 {
-	if (!cli_rename(c->tree, old, new)) {
+	if (NT_STATUS_IS_ERR(cli_rename(c->tree, old, new))) {
 		printf("ERROR: rename %s %s failed (%s)\n", 
 		       old, new, cli_errstr(c->tree));
 		exit(1);
diff --git a/source4/torture/raw/chkpath.c b/source4/torture/raw/chkpath.c
index 6e128a01a4..72ddf3b5a2 100644
--- a/source4/torture/raw/chkpath.c
+++ b/source4/torture/raw/chkpath.c
@@ -124,7 +124,7 @@ BOOL torture_raw_chkpath(int dummy)
 		printf("Failed to clean " BASEDIR "\n");
 		return False;
 	}
-	if (!cli_mkdir(cli->tree, BASEDIR)) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Failed to create " BASEDIR " - %s\n", cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/raw/context.c b/source4/torture/raw/context.c
index 4fc9b3788e..91763da86f 100644
--- a/source4/torture/raw/context.c
+++ b/source4/torture/raw/context.c
@@ -60,7 +60,7 @@ static BOOL test_session(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	printf("TESTING SESSION HANDLING\n");
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -168,7 +168,7 @@ static BOOL test_tree(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	printf("TESTING TREE HANDLING\n");
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -270,7 +270,7 @@ static BOOL test_pid(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	printf("TESTING PID HANDLING\n");
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/raw/ioctl.c b/source4/torture/raw/ioctl.c
index a7787b6d28..4fd296d811 100644
--- a/source4/torture/raw/ioctl.c
+++ b/source4/torture/raw/ioctl.c
@@ -137,7 +137,7 @@ BOOL torture_raw_ioctl(int dummy)
 		printf("Failed to clean " BASEDIR "\n");
 		return False;
 	}
-	if (!cli_mkdir(cli->tree, BASEDIR)) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Failed to create " BASEDIR " - %s\n", cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/raw/lock.c b/source4/torture/raw/lock.c
index e36f9edddf..9a9b841568 100644
--- a/source4/torture/raw/lock.c
+++ b/source4/torture/raw/lock.c
@@ -51,7 +51,7 @@ static BOOL test_lock(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	const char *fname = BASEDIR "\\test.txt";
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -153,7 +153,7 @@ static BOOL test_lockx(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	const char *fname = BASEDIR "\\test.txt";
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -203,7 +203,7 @@ static BOOL test_pidhigh(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	char c = 1;
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/raw/mux.c b/source4/torture/raw/mux.c
index 70e6c09d9e..8b3bcc12e3 100644
--- a/source4/torture/raw/mux.c
+++ b/source4/torture/raw/mux.c
@@ -110,7 +110,7 @@ static BOOL test_mux_write(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	cli->session->pid = 1;
 
 	/* lock a range */
-	if (!cli_lock(cli->tree, fnum, 0, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli->tree, fnum, 0, 4, 0, WRITE_LOCK))) {
 		printf("lock failed in mux_write - %s\n", cli_errstr(cli->tree));
 		ret = False;
 		goto done;
@@ -271,7 +271,7 @@ BOOL torture_raw_mux(int dummy)
 	}
 
 
-	if (!cli_mkdir(cli->tree, BASEDIR)) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Failed to create %s\n", BASEDIR);
 		ret = False;
 		goto done;
diff --git a/source4/torture/raw/open.c b/source4/torture/raw/open.c
index 567940b2e8..d2055536a1 100644
--- a/source4/torture/raw/open.c
+++ b/source4/torture/raw/open.c
@@ -912,7 +912,7 @@ BOOL torture_raw_open(int dummy)
 		printf("Failed to clean " BASEDIR "\n");
 		return False;
 	}
-	if (!cli_mkdir(cli->tree, BASEDIR)) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Failed to create " BASEDIR " - %s\n", cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/raw/read.c b/source4/torture/raw/read.c
index 0836b4d021..3e9547856c 100644
--- a/source4/torture/raw/read.c
+++ b/source4/torture/raw/read.c
@@ -91,7 +91,7 @@ static BOOL test_read(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	buf = talloc_zero(mem_ctx, maxsize);
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -178,7 +178,7 @@ static BOOL test_read(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 
 	printf("Trying locked region\n");
 	cli->session->pid++;
-	if (!cli_lock(cli->tree, fnum, 103, 1, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli->tree, fnum, 103, 1, 0, WRITE_LOCK))) {
 		printf("Failed to lock file at %d\n", __LINE__);
 		ret = False;
 		goto done;
@@ -217,7 +217,7 @@ static BOOL test_lockread(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	buf = talloc_zero(mem_ctx, maxsize);
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -322,7 +322,7 @@ static BOOL test_lockread(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 
 	printf("Trying locked region\n");
 	cli->session->pid++;
-	if (!cli_lock(cli->tree, fnum, 103, 1, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli->tree, fnum, 103, 1, 0, WRITE_LOCK))) {
 		printf("Failed to lock file at %d\n", __LINE__);
 		ret = False;
 		goto done;
@@ -360,7 +360,7 @@ static BOOL test_readx(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	buf = talloc_zero(mem_ctx, maxsize);
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -489,7 +489,7 @@ static BOOL test_readx(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 
 	printf("Trying locked region\n");
 	cli->session->pid++;
-	if (!cli_lock(cli->tree, fnum, 103, 1, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli->tree, fnum, 103, 1, 0, WRITE_LOCK))) {
 		printf("Failed to lock file at %d\n", __LINE__);
 		ret = False;
 		goto done;
@@ -511,7 +511,7 @@ static BOOL test_readx(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	CHECK_STATUS(status, NT_STATUS_OK);
 	CHECK_VALUE(io.readx.out.nread, 0);
 
-	if (!cli_lock64(cli->tree, fnum, io.readx.in.offset, 1, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock64(cli->tree, fnum, io.readx.in.offset, 1, 0, WRITE_LOCK))) {
 		printf("Failed to lock file at %d\n", __LINE__);
 		ret = False;
 		goto done;
@@ -547,7 +547,7 @@ static BOOL test_readbraw(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	buf = talloc_zero(mem_ctx, maxsize);
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -660,7 +660,7 @@ static BOOL test_readbraw(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 
 	printf("Trying locked region\n");
 	cli->session->pid++;
-	if (!cli_lock(cli->tree, fnum, 103, 1, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli->tree, fnum, 103, 1, 0, WRITE_LOCK))) {
 		printf("Failed to lock file at %d\n", __LINE__);
 		ret = False;
 		goto done;
diff --git a/source4/torture/raw/rename.c b/source4/torture/raw/rename.c
index d2f922cdfd..98a6ce5fde 100644
--- a/source4/torture/raw/rename.c
+++ b/source4/torture/raw/rename.c
@@ -52,7 +52,7 @@ static BOOL test_mv(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	printf("Testing SMBmv\n");
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -142,7 +142,7 @@ static BOOL test_ntrename(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	printf("Testing SMBntrename\n");
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/raw/search.c b/source4/torture/raw/search.c
index 164c9bb4d8..9881a45cb1 100644
--- a/source4/torture/raw/search.c
+++ b/source4/torture/raw/search.c
@@ -551,7 +551,7 @@ static BOOL test_many_files(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	};
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 || 
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Failed to create " BASEDIR " - %s\n", cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/raw/seek.c b/source4/torture/raw/seek.c
index fa95156969..89528c72ad 100644
--- a/source4/torture/raw/seek.c
+++ b/source4/torture/raw/seek.c
@@ -53,7 +53,7 @@ static BOOL test_seek(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	char c[2];
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/raw/setfileinfo.c b/source4/torture/raw/setfileinfo.c
index f82a63180a..fa286ae4da 100644
--- a/source4/torture/raw/setfileinfo.c
+++ b/source4/torture/raw/setfileinfo.c
@@ -500,10 +500,10 @@ BOOL torture_raw_sfileinfo(int dummy)
 done:
 	smb_raw_exit(cli->session);
 	cli_close(cli->tree, fnum);
-	if (!cli_unlink(cli->tree, fnum_fname)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(cli->tree, fnum_fname))) {
 		printf("Failed to delete %s - %s\n", fnum_fname, cli_errstr(cli->tree));
 	}
-	if (!cli_unlink(cli->tree, path_fname)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(cli->tree, path_fname))) {
 		printf("Failed to delete %s - %s\n", path_fname, cli_errstr(cli->tree));
 	}
 
diff --git a/source4/torture/raw/unlink.c b/source4/torture/raw/unlink.c
index 741f8c61f7..f4598bc1d7 100644
--- a/source4/torture/raw/unlink.c
+++ b/source4/torture/raw/unlink.c
@@ -41,7 +41,7 @@ static BOOL test_unlink(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	const char *fname = BASEDIR "\\test.txt";
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/raw/write.c b/source4/torture/raw/write.c
index 3b356f1095..eb20fe3b84 100644
--- a/source4/torture/raw/write.c
+++ b/source4/torture/raw/write.c
@@ -104,7 +104,7 @@ static BOOL test_write(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	buf = talloc_zero(mem_ctx, maxsize);
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -223,7 +223,7 @@ static BOOL test_writex(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	buf = talloc_zero(mem_ctx, maxsize);
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -312,7 +312,7 @@ static BOOL test_writex(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 
 	printf("Trying locked region\n");
 	cli->session->pid++;
-	if (!cli_lock(cli->tree, fnum, 3, 1, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli->tree, fnum, 3, 1, 0, WRITE_LOCK))) {
 		printf("Failed to lock file at %d\n", __LINE__);
 		ret = False;
 		goto done;
@@ -397,7 +397,7 @@ static BOOL test_writeunlock(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	buf = talloc_zero(mem_ctx, maxsize);
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
@@ -536,7 +536,7 @@ static BOOL test_writeclose(struct cli_state *cli, TALLOC_CTX *mem_ctx)
 	buf = talloc_zero(mem_ctx, maxsize);
 
 	if (cli_deltree(cli->tree, BASEDIR) == -1 ||
-	    !cli_mkdir(cli->tree, BASEDIR)) {
+	    NT_STATUS_IS_ERR(cli_mkdir(cli->tree, BASEDIR))) {
 		printf("Unable to setup %s - %s\n", BASEDIR, cli_errstr(cli->tree));
 		return False;
 	}
diff --git a/source4/torture/torture.c b/source4/torture/torture.c
index 393ac9c56b..9c71508bdf 100644
--- a/source4/torture/torture.c
+++ b/source4/torture/torture.c
@@ -120,7 +120,7 @@ BOOL torture_close_connection(struct cli_state *c)
 	BOOL ret = True;
 	DEBUG(9,("torture_close_connection: cli_state@%p\n", c));
 	if (!c) return True;
-	if (!cli_tdis(c)) {
+	if (NT_STATUS_IS_ERR(cli_tdis(c))) {
 		printf("tdis failed (%s)\n", cli_errstr(c->tree));
 		ret = False;
 	}
@@ -201,7 +201,7 @@ static BOOL check_error(int line, struct cli_state *c,
 
 static BOOL wait_lock(struct cli_state *c, int fnum, uint32 offset, uint32 len)
 {
-	while (!cli_lock(c->tree, fnum, offset, len, -1, WRITE_LOCK)) {
+	while (NT_STATUS_IS_ERR(cli_lock(c->tree, fnum, offset, len, -1, WRITE_LOCK))) {
 		if (!check_error(__LINE__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
 	}
 	return True;
@@ -273,17 +273,17 @@ static BOOL rw_torture(struct cli_state *c)
 			correct = False;
 		}
 
-		if (!cli_close(c->tree, fnum)) {
+		if (NT_STATUS_IS_ERR(cli_close(c->tree, fnum))) {
 			printf("close failed (%s)\n", cli_errstr(c->tree));
 			correct = False;
 		}
 
-		if (!cli_unlink(c->tree, fname)) {
+		if (NT_STATUS_IS_ERR(cli_unlink(c->tree, fname))) {
 			printf("unlink failed (%s)\n", cli_errstr(c->tree));
 			correct = False;
 		}
 
-		if (!cli_unlock(c->tree, fnum2, n*sizeof(int), sizeof(int))) {
+		if (NT_STATUS_IS_ERR(cli_unlock(c->tree, fnum2, n*sizeof(int), sizeof(int)))) {
 			printf("unlock failed (%s)\n", cli_errstr(c->tree));
 			correct = False;
 		}
@@ -406,7 +406,7 @@ static BOOL rw_torture3(struct cli_state *c, const char *lockfname)
 
 	}
 
-	if (!cli_close(c->tree, fnum)) {
+	if (NT_STATUS_IS_ERR(cli_close(c->tree, fnum))) {
 		printf("close failed (%s)\n", cli_errstr(c->tree));
 		correct = False;
 	}
@@ -478,16 +478,16 @@ static BOOL rw_torture2(struct cli_state *c1, struct cli_state *c2)
 		}
 	}
 
-	if (!cli_close(c2->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(c2->tree, fnum2))) {
 		printf("close failed (%s)\n", cli_errstr(c2->tree));
 		correct = False;
 	}
-	if (!cli_close(c1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(c1->tree, fnum1))) {
 		printf("close failed (%s)\n", cli_errstr(c1->tree));
 		correct = False;
 	}
 
-	if (!cli_unlink(c1->tree, lockfname)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(c1->tree, lockfname))) {
 		printf("unlink failed (%s)\n", cli_errstr(c1->tree));
 		correct = False;
 	}
@@ -703,13 +703,13 @@ static BOOL run_locktest1(int dummy)
 		return False;
 	}
 
-	if (!cli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
 		printf("lock1 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
 
 
-	if (cli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
 		printf("lock2 succeeded! This is a locking bug\n");
 		return False;
 	} else {
@@ -721,7 +721,7 @@ static BOOL run_locktest1(int dummy)
 	lock_timeout = (6 + (random() % 20));
 	printf("Testing lock timeout with timeout=%u\n", lock_timeout);
 	t1 = time(NULL);
-	if (cli_lock(cli2->tree, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)) {
+	if (NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK))) {
 		printf("lock3 succeeded! This is a locking bug\n");
 		return False;
 	} else {
@@ -736,12 +736,12 @@ static BOOL run_locktest1(int dummy)
 	printf("server slept for %u seconds for a %u second timeout\n",
 	       (unsigned int)(t2-t1), lock_timeout);
 
-	if (!cli_close(cli1->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum2))) {
 		printf("close1 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
 
-	if (cli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
 		printf("lock4 succeeded! This is a locking bug\n");
 		return False;
 	} else {
@@ -749,17 +749,17 @@ static BOOL run_locktest1(int dummy)
 				 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("close2 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
 
-	if (!cli_close(cli2->tree, fnum3)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli2->tree, fnum3))) {
 		printf("close3 failed (%s)\n", cli_errstr(cli2->tree));
 		return False;
 	}
 
-	if (!cli_unlink(cli1->tree, fname)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(cli1->tree, fname))) {
 		printf("unlink failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
@@ -821,8 +821,7 @@ static BOOL run_tcon_test(int dummy)
 	}
 
 	tree1 = cli->tree;	/* save old tree connection */
-	if (!cli_send_tconX(cli, share, "?????",
-			    password)) {
+	if (NT_STATUS_IS_ERR(cli_send_tconX(cli, share, "?????", password))) {
 		printf("%s refused 2nd tree connect (%s)\n", host,
 		           cli_errstr(cli->tree));
 		cli_shutdown(cli);
@@ -868,14 +867,14 @@ static BOOL run_tcon_test(int dummy)
 	cli->session->vuid = vuid1;
 	cli->tree->tid = cnum1;
 
-	if (!cli_close(cli->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnum1))) {
 		printf("close failed (%s)\n", cli_errstr(cli->tree));
 		return False;
 	}
 
 	cli->tree->tid = cnum2;
 
-	if (!cli_tdis(cli)) {
+	if (NT_STATUS_IS_ERR(cli_tdis(cli))) {
 		printf("secondary tdis failed (%s)\n", cli_errstr(cli->tree));
 		return False;
 	}
@@ -900,8 +899,8 @@ static BOOL tcon_devtest(struct cli_state *cli,
 	BOOL ret;
 	char *password = lp_parm_string(-1, "torture", "password");
 
-	status = cli_send_tconX(cli, myshare, devtype,
-				password);
+	status = NT_STATUS_IS_OK(cli_send_tconX(cli, myshare, devtype, 
+						password));
 
 	printf("Trying share %s with devtype %s\n", myshare, devtype);
 
@@ -1051,12 +1050,12 @@ static BOOL run_locktest2(int dummy)
 
 	cli->session->pid = 1;
 
-	if (!cli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
 		printf("lock1 failed (%s)\n", cli_errstr(cli->tree));
 		return False;
 	}
 
-	if (cli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_OK(cli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
 		printf("WRITE lock1 succeeded! This is a locking bug\n");
 		correct = False;
 	} else {
@@ -1064,7 +1063,7 @@ static BOOL run_locktest2(int dummy)
 				 NT_STATUS_LOCK_NOT_GRANTED)) return False;
 	}
 
-	if (cli_lock(cli->tree, fnum2, 0, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_OK(cli_lock(cli->tree, fnum2, 0, 4, 0, WRITE_LOCK))) {
 		printf("WRITE lock2 succeeded! This is a locking bug\n");
 		correct = False;
 	} else {
@@ -1072,7 +1071,7 @@ static BOOL run_locktest2(int dummy)
 				 NT_STATUS_LOCK_NOT_GRANTED)) return False;
 	}
 
-	if (cli_lock(cli->tree, fnum2, 0, 4, 0, READ_LOCK)) {
+	if (NT_STATUS_IS_OK(cli_lock(cli->tree, fnum2, 0, 4, 0, READ_LOCK))) {
 		printf("READ lock2 succeeded! This is a locking bug\n");
 		correct = False;
 	} else {
@@ -1080,18 +1079,18 @@ static BOOL run_locktest2(int dummy)
 				 NT_STATUS_FILE_LOCK_CONFLICT)) return False;
 	}
 
-	if (!cli_lock(cli->tree, fnum1, 100, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli->tree, fnum1, 100, 4, 0, WRITE_LOCK))) {
 		printf("lock at 100 failed (%s)\n", cli_errstr(cli->tree));
 	}
 
 	cli->session->pid = 2;
 
-	if (cli_unlock(cli->tree, fnum1, 100, 4)) {
+	if (NT_STATUS_IS_OK(cli_unlock(cli->tree, fnum1, 100, 4))) {
 		printf("unlock at 100 succeeded! This is a locking bug\n");
 		correct = False;
 	}
 
-	if (cli_unlock(cli->tree, fnum1, 0, 4)) {
+	if (NT_STATUS_IS_OK(cli_unlock(cli->tree, fnum1, 0, 4))) {
 		printf("unlock1 succeeded! This is a locking bug\n");
 		correct = False;
 	} else {
@@ -1100,7 +1099,7 @@ static BOOL run_locktest2(int dummy)
 				 NT_STATUS_RANGE_NOT_LOCKED)) return False;
 	}
 
-	if (cli_unlock(cli->tree, fnum1, 0, 8)) {
+	if (NT_STATUS_IS_OK(cli_unlock(cli->tree, fnum1, 0, 8))) {
 		printf("unlock2 succeeded! This is a locking bug\n");
 		correct = False;
 	} else {
@@ -1109,7 +1108,7 @@ static BOOL run_locktest2(int dummy)
 				 NT_STATUS_RANGE_NOT_LOCKED)) return False;
 	}
 
-	if (cli_lock(cli->tree, fnum3, 0, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_OK(cli_lock(cli->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
 		printf("lock3 succeeded! This is a locking bug\n");
 		correct = False;
 	} else {
@@ -1118,17 +1117,17 @@ static BOOL run_locktest2(int dummy)
 
 	cli->session->pid = 1;
 
-	if (!cli_close(cli->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnum1))) {
 		printf("close1 failed (%s)\n", cli_errstr(cli->tree));
 		return False;
 	}
 
-	if (!cli_close(cli->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnum2))) {
 		printf("close2 failed (%s)\n", cli_errstr(cli->tree));
 		return False;
 	}
 
-	if (!cli_close(cli->tree, fnum3)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnum3))) {
 		printf("close3 failed (%s)\n", cli_errstr(cli->tree));
 		return False;
 	}
@@ -1183,14 +1182,14 @@ static BOOL run_locktest3(int dummy)
 
 	for (offset=i=0;i<torture_numops;i++) {
 		NEXT_OFFSET;
-		if (!cli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
+		if (NT_STATUS_IS_ERR(cli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK))) {
 			printf("lock1 %d failed (%s)\n", 
 			       i,
 			       cli_errstr(cli1->tree));
 			return False;
 		}
 
-		if (!cli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
+		if (NT_STATUS_IS_ERR(cli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK))) {
 			printf("lock2 %d failed (%s)\n", 
 			       i,
 			       cli_errstr(cli1->tree));
@@ -1203,22 +1202,22 @@ static BOOL run_locktest3(int dummy)
 	for (offset=i=0;i<torture_numops;i++) {
 		NEXT_OFFSET;
 
-		if (cli_lock(cli1->tree, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
+		if (NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, offset-2, 1, 0, WRITE_LOCK))) {
 			printf("error: lock1 %d succeeded!\n", i);
 			return False;
 		}
 
-		if (cli_lock(cli2->tree, fnum2, offset-1, 1, 0, WRITE_LOCK)) {
+		if (NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum2, offset-1, 1, 0, WRITE_LOCK))) {
 			printf("error: lock2 %d succeeded!\n", i);
 			return False;
 		}
 
-		if (cli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
+		if (NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK))) {
 			printf("error: lock3 %d succeeded!\n", i);
 			return False;
 		}
 
-		if (cli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK)) {
+		if (NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK))) {
 			printf("error: lock4 %d succeeded!\n", i);
 			return False;
 		}
@@ -1229,14 +1228,14 @@ static BOOL run_locktest3(int dummy)
 	for (offset=i=0;i<torture_numops;i++) {
 		NEXT_OFFSET;
 
-		if (!cli_unlock(cli1->tree, fnum1, offset-1, 1)) {
+		if (NT_STATUS_IS_ERR(cli_unlock(cli1->tree, fnum1, offset-1, 1))) {
 			printf("unlock1 %d failed (%s)\n", 
 			       i,
 			       cli_errstr(cli1->tree));
 			return False;
 		}
 
-		if (!cli_unlock(cli2->tree, fnum2, offset-2, 1)) {
+		if (NT_STATUS_IS_ERR(cli_unlock(cli2->tree, fnum2, offset-2, 1))) {
 			printf("unlock2 %d failed (%s)\n", 
 			       i,
 			       cli_errstr(cli1->tree));
@@ -1244,17 +1243,17 @@ static BOOL run_locktest3(int dummy)
 		}
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("close1 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
 
-	if (!cli_close(cli2->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli2->tree, fnum2))) {
 		printf("close2 failed (%s)\n", cli_errstr(cli2->tree));
 		return False;
 	}
 
-	if (!cli_unlink(cli1->tree, fname)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(cli1->tree, fname))) {
 		printf("unlink failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
@@ -1307,113 +1306,113 @@ static BOOL run_locktest4(int dummy)
 		goto fail;
 	}
 
-	ret = cli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 2, 4, 0, WRITE_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 2, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, False);
 	printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
 	    
-	ret = cli_lock(cli1->tree, fnum1, 10, 4, 0, READ_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 12, 4, 0, READ_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 10, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 12, 4, 0, READ_LOCK));
 	EXPECTED(ret, True);
 	printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
 
-	ret = cli_lock(cli1->tree, fnum1, 20, 4, 0, WRITE_LOCK) &&
-	      cli_lock(cli2->tree, fnum2, 22, 4, 0, WRITE_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 20, 4, 0, WRITE_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum2, 22, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, False);
 	printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
 	    
-	ret = cli_lock(cli1->tree, fnum1, 30, 4, 0, READ_LOCK) &&
-	      cli_lock(cli2->tree, fnum2, 32, 4, 0, READ_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 30, 4, 0, READ_LOCK)) &&
+		NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum2, 32, 4, 0, READ_LOCK));
 	EXPECTED(ret, True);
 	printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
 	
-	ret = (cli1->session->pid = 1, cli_lock(cli1->tree, fnum1, 40, 4, 0, WRITE_LOCK)) &&
-	      (cli1->session->pid = 2, cli_lock(cli1->tree, fnum1, 42, 4, 0, WRITE_LOCK));
+	ret = NT_STATUS_IS_OK((cli1->session->pid = 1, cli_lock(cli1->tree, fnum1, 40, 4, 0, WRITE_LOCK))) &&
+	      NT_STATUS_IS_OK((cli1->session->pid = 2, cli_lock(cli1->tree, fnum1, 42, 4, 0, WRITE_LOCK)));
 	EXPECTED(ret, False);
 	printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
 	    
-	ret = (cli1->session->pid = 1, cli_lock(cli1->tree, fnum1, 50, 4, 0, READ_LOCK)) &&
-	      (cli1->session->pid = 2, cli_lock(cli1->tree, fnum1, 52, 4, 0, READ_LOCK));
+	ret = NT_STATUS_IS_OK((cli1->session->pid = 1, cli_lock(cli1->tree, fnum1, 50, 4, 0, READ_LOCK))) &&
+	      NT_STATUS_IS_OK((cli1->session->pid = 2, cli_lock(cli1->tree, fnum1, 52, 4, 0, READ_LOCK)));
 	EXPECTED(ret, True);
 	printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
 
-	ret = cli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK));
 	EXPECTED(ret, True);
 	printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
 
-	ret = cli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, False);
 	printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
 
-	ret = cli_lock(cli1->tree, fnum1, 80, 4, 0, READ_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 80, 4, 0, WRITE_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 80, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 80, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, False);
 	printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
 
-	ret = cli_lock(cli1->tree, fnum1, 90, 4, 0, WRITE_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 90, 4, 0, READ_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 90, 4, 0, WRITE_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 90, 4, 0, READ_LOCK));
 	EXPECTED(ret, True);
 	printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
 
-	ret = (cli1->session->pid = 1, cli_lock(cli1->tree, fnum1, 100, 4, 0, WRITE_LOCK)) &&
-	      (cli1->session->pid = 2, cli_lock(cli1->tree, fnum1, 100, 4, 0, READ_LOCK));
+	ret = NT_STATUS_IS_OK((cli1->session->pid = 1, cli_lock(cli1->tree, fnum1, 100, 4, 0, WRITE_LOCK))) &&
+	      NT_STATUS_IS_OK((cli1->session->pid = 2, cli_lock(cli1->tree, fnum1, 100, 4, 0, READ_LOCK)));
 	EXPECTED(ret, False);
 	printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
 
-	ret = cli_lock(cli1->tree, fnum1, 110, 4, 0, READ_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 112, 4, 0, READ_LOCK) &&
-	      cli_unlock(cli1->tree, fnum1, 110, 6);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 110, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 112, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 110, 6));
 	EXPECTED(ret, False);
 	printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
 
 
-	ret = cli_lock(cli1->tree, fnum1, 120, 4, 0, WRITE_LOCK) &&
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 120, 4, 0, WRITE_LOCK)) &&
 	      (cli_read(cli2->tree, fnum2, buf, 120, 4) == 4);
 	EXPECTED(ret, False);
 	printf("this server %s strict write locking\n", ret?"doesn't do":"does");
 
-	ret = cli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK) &&
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK)) &&
 	      (cli_write(cli2->tree, fnum2, 0, buf, 130, 4) == 4);
 	EXPECTED(ret, False);
 	printf("this server %s strict read locking\n", ret?"doesn't do":"does");
 
 
-	ret = cli_lock(cli1->tree, fnum1, 140, 4, 0, READ_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 140, 4, 0, READ_LOCK) &&
-	      cli_unlock(cli1->tree, fnum1, 140, 4) &&
-	      cli_unlock(cli1->tree, fnum1, 140, 4);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 140, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 140, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 140, 4)) &&
+	      NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 140, 4));
 	EXPECTED(ret, True);
 	printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
 
 
-	ret = cli_lock(cli1->tree, fnum1, 150, 4, 0, WRITE_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 150, 4, 0, READ_LOCK) &&
-	      cli_unlock(cli1->tree, fnum1, 150, 4) &&
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 150, 4, 0, WRITE_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 150, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 150, 4)) &&
 	      (cli_read(cli2->tree, fnum2, buf, 150, 4) == 4) &&
 	      !(cli_write(cli2->tree, fnum2, 0, buf, 150, 4) == 4) &&
-	      cli_unlock(cli1->tree, fnum1, 150, 4);
+	      NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 150, 4));
 	EXPECTED(ret, True);
 	printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
 
-	ret = cli_lock(cli1->tree, fnum1, 160, 4, 0, READ_LOCK) &&
-	      cli_unlock(cli1->tree, fnum1, 160, 4) &&
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 160, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 160, 4)) &&
 	      (cli_write(cli2->tree, fnum2, 0, buf, 160, 4) == 4) &&		
 	      (cli_read(cli2->tree, 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->tree, fnum1, 170, 4, 0, WRITE_LOCK) &&
-	      cli_unlock(cli1->tree, fnum1, 170, 4) &&
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 170, 4, 0, WRITE_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 170, 4)) &&
 	      (cli_write(cli2->tree, fnum2, 0, buf, 170, 4) == 4) &&		
 	      (cli_read(cli2->tree, fnum2, buf, 170, 4) == 4);		
 	EXPECTED(ret, True);
 	printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
 
-	ret = cli_lock(cli1->tree, fnum1, 190, 4, 0, WRITE_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 190, 4, 0, READ_LOCK) &&
-	      cli_unlock(cli1->tree, fnum1, 190, 4) &&
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 190, 4, 0, WRITE_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 190, 4, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 190, 4)) &&
 	      !(cli_write(cli2->tree, fnum2, 0, buf, 190, 4) == 4) &&		
 	      (cli_read(cli2->tree, fnum2, buf, 190, 4) == 4);		
 	EXPECTED(ret, True);
@@ -1423,11 +1422,11 @@ static BOOL run_locktest4(int dummy)
 	cli_close(cli2->tree, fnum2);
 	fnum1 = cli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 	f = cli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
-	ret = cli_lock(cli1->tree, fnum1, 0, 8, 0, READ_LOCK) &&
-	      cli_lock(cli1->tree, f, 0, 1, 0, READ_LOCK) &&
-	      cli_close(cli1->tree, fnum1) &&
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 0, 8, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, f, 0, 1, 0, READ_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_close(cli1->tree, fnum1)) &&
 	      ((fnum1 = cli_open(cli1->tree, fname, O_RDWR, DENY_NONE)) != -1) &&
-	      cli_lock(cli1->tree, fnum1, 7, 1, 0, WRITE_LOCK);
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 7, 1, 0, WRITE_LOCK));
         cli_close(cli1->tree, f);
 	cli_close(cli1->tree, fnum1);
 	EXPECTED(ret, True);
@@ -1477,23 +1476,23 @@ static BOOL run_locktest5(int dummy)
 	}
 
 	/* Check for NT bug... */
-	ret = cli_lock(cli1->tree, fnum1, 0, 8, 0, READ_LOCK) &&
-		  cli_lock(cli1->tree, fnum3, 0, 1, 0, READ_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 0, 8, 0, READ_LOCK)) &&
+		  NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum3, 0, 1, 0, READ_LOCK));
 	cli_close(cli1->tree, fnum1);
 	fnum1 = cli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
-	ret = cli_lock(cli1->tree, fnum1, 7, 1, 0, WRITE_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 7, 1, 0, WRITE_LOCK));
 	EXPECTED(ret, True);
 	printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
 	cli_close(cli1->tree, fnum1);
 	fnum1 = cli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 	cli_unlock(cli1->tree, fnum3, 0, 1);
 
-	ret = cli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK) &&
-	      cli_lock(cli1->tree, fnum1, 1, 1, 0, READ_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK)) &&
+	      NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 1, 1, 0, READ_LOCK));
 	EXPECTED(ret, True);
 	printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
 
-	ret = cli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK));
 	EXPECTED(ret, False);
 
 	printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
@@ -1501,7 +1500,7 @@ static BOOL run_locktest5(int dummy)
 	/* Unlock the process 2 lock. */
 	cli_unlock(cli2->tree, fnum2, 0, 4);
 
-	ret = cli_lock(cli1->tree, fnum3, 0, 4, 0, READ_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum3, 0, 4, 0, READ_LOCK));
 	EXPECTED(ret, False);
 
 	printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
@@ -1510,8 +1509,8 @@ static BOOL run_locktest5(int dummy)
 	cli_unlock(cli1->tree, fnum3, 0, 4);
 
 	/* Stack 2 more locks here. */
-	ret = cli_lock(cli1->tree, fnum1, 0, 4, 0, READ_LOCK) &&
-		  cli_lock(cli1->tree, fnum1, 0, 4, 0, READ_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 0, 4, 0, READ_LOCK)) &&
+		  NT_STATUS_IS_OK(cli_lock(cli1->tree, fnum1, 0, 4, 0, READ_LOCK));
 
 	EXPECTED(ret, True);
 	printf("the same process %s stack read locks\n", ret?"can":"cannot");
@@ -1519,8 +1518,8 @@ 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->tree, fnum1, 0, 4) &&
-			cli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK);
+ret = NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 0, 4)) &&
+	NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK));
 
 	EXPECTED(ret, True);
 	printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
@@ -1530,20 +1529,20 @@ static BOOL run_locktest5(int dummy)
 
 	/* We should have 3 stacked locks here. Ensure we need to do 3 unlocks. */
 
-	ret = cli_unlock(cli1->tree, fnum1, 1, 1) &&
-		  cli_unlock(cli1->tree, fnum1, 0, 4) &&
-		  cli_unlock(cli1->tree, fnum1, 0, 4);
+	ret = NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 1, 1)) &&
+		  NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 0, 4)) &&
+		  NT_STATUS_IS_OK(cli_unlock(cli1->tree, 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->tree, fnum1, 0, 4);
+	ret = NT_STATUS_IS_OK(cli_unlock(cli1->tree, fnum1, 0, 4));
 	EXPECTED(ret, False);
 	printf("the same process %s count the lock stack\n", !ret?"can":"cannot"); 
 
 	/* Ensure connection 2 can get a write lock. */
-	ret = cli_lock(cli2->tree, fnum2, 0, 4, 0, WRITE_LOCK);
+	ret = NT_STATUS_IS_OK(cli_lock(cli2->tree, fnum2, 0, 4, 0, WRITE_LOCK));
 	EXPECTED(ret, True);
 
 	printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
@@ -1633,7 +1632,7 @@ static BOOL run_locktest7(int dummy)
 
 	cli1->session->pid = 1;
 
-	if (!cli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK))) {
 		printf("Unable to apply read lock on range 130:4, error was %s\n", cli_errstr(cli1->tree));
 		goto fail;
 	} else {
@@ -1680,7 +1679,7 @@ static BOOL run_locktest7(int dummy)
 	cli1->session->pid = 1;
 	cli_unlock(cli1->tree, fnum1, 130, 4);
 
-	if (!cli_lock(cli1->tree, fnum1, 130, 4, 0, WRITE_LOCK)) {
+	if (NT_STATUS_IS_ERR(cli_lock(cli1->tree, fnum1, 130, 4, 0, WRITE_LOCK))) {
 		printf("Unable to apply write lock on range 130:4, error was %s\n", cli_errstr(cli1->tree));
 		goto fail;
 	} else {
@@ -1829,7 +1828,7 @@ static BOOL run_unlinktest(int dummy)
 
 	printf("Unlinking a open file\n");
 
-	if (cli_unlink(cli->tree, fname)) {
+	if (NT_STATUS_IS_OK(cli_unlink(cli->tree, fname))) {
 		printf("error: server allowed unlink on an open file\n");
 		correct = False;
 	} else {
@@ -1890,10 +1889,10 @@ static BOOL run_maxfidtest(int dummy)
 	printf("cleaning up\n");
 	for (;i>=0;i--) {
 		asprintf(&fname, template, i,(int)getpid());
-		if (!cli_close(cli->tree, fnums[i])) {
+		if (NT_STATUS_IS_ERR(cli_close(cli->tree, fnums[i]))) {
 			printf("Close of fnum %d failed - %s\n", fnums[i], cli_errstr(cli->tree));
 		}
-		if (!cli_unlink(cli->tree, fname)) {
+		if (NT_STATUS_IS_ERR(cli_unlink(cli->tree, fname))) {
 			printf("unlink of %s failed (%s)\n", 
 			       fname, cli_errstr(cli->tree));
 			correct = False;
@@ -1962,7 +1961,7 @@ static BOOL run_attrtest(int dummy)
 			O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
 	cli_close(cli->tree, fnum);
 
-	if (!cli_getatr(cli->tree, fname, NULL, NULL, &t)) {
+	if (NT_STATUS_IS_ERR(cli_getatr(cli->tree, fname, NULL, NULL, &t))) {
 		printf("getatr failed (%s)\n", cli_errstr(cli->tree));
 		correct = False;
 	}
@@ -1980,12 +1979,12 @@ static BOOL run_attrtest(int dummy)
 
 	printf("Setting file time to %s", ctime(&t2));
 
-	if (!cli_setatr(cli->tree, fname, 0, t2)) {
+	if (NT_STATUS_IS_ERR(cli_setatr(cli->tree, fname, 0, t2))) {
 		printf("setatr failed (%s)\n", cli_errstr(cli->tree));
 		correct = True;
 	}
 
-	if (!cli_getatr(cli->tree, fname, NULL, NULL, &t)) {
+	if (NT_STATUS_IS_ERR(cli_getatr(cli->tree, fname, NULL, NULL, &t))) {
 		printf("getatr failed (%s)\n", cli_errstr(cli->tree));
 		correct = True;
 	}
@@ -2038,15 +2037,15 @@ static BOOL run_trans2test(int dummy)
 	
 	fnum = cli_open(cli->tree, fname, 
 			O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
-	if (!cli_qfileinfo(cli->tree, fnum, NULL, &size, &c_time, &a_time, &m_time,
-			   NULL, NULL)) {
+	if (NT_STATUS_IS_ERR(cli_qfileinfo(cli->tree, fnum, NULL, &size, &c_time, &a_time, &m_time,
+			   NULL, NULL))) {
 		printf("ERROR: qfileinfo failed (%s)\n", cli_errstr(cli->tree));
 		correct = False;
 	}
 
 	printf("Testing NAME_INFO\n");
 
-	if (!cli_qfilename(cli->tree, fnum, &pname)) {
+	if (NT_STATUS_IS_ERR(cli_qfilename(cli->tree, fnum, &pname))) {
 		printf("ERROR: qfilename failed (%s)\n", cli_errstr(cli->tree));
 		correct = False;
 	}
@@ -2070,7 +2069,7 @@ static BOOL run_trans2test(int dummy)
 
 	printf("Checking for sticky create times\n");
 
-	if (!cli_qpathinfo(cli->tree, fname, &c_time, &a_time, &m_time, &size, NULL)) {
+	if (NT_STATUS_IS_ERR(cli_qpathinfo(cli->tree, fname, &c_time, &a_time, &m_time, &size, NULL))) {
 		printf("ERROR: qpathinfo failed (%s)\n", cli_errstr(cli->tree));
 		correct = False;
 	} else {
@@ -2096,8 +2095,7 @@ static BOOL run_trans2test(int dummy)
 	fnum = cli_open(cli->tree, fname, 
 			O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
 	cli_close(cli->tree, fnum);
-	if (!cli_qpathinfo2(cli->tree, fname, &c_time, &a_time, &m_time, 
-			    &w_time, &size, NULL, NULL)) {
+	if (NT_STATUS_IS_ERR(cli_qpathinfo2(cli->tree, fname, &c_time, &a_time, &m_time, &w_time, &size, NULL, NULL))) {
 		printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli->tree));
 		correct = False;
 	} else {
@@ -2113,13 +2111,12 @@ static BOOL run_trans2test(int dummy)
 
 	/* check if the server updates the directory modification time
            when creating a new file */
-	if (!cli_mkdir(cli->tree, dname)) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, dname))) {
 		printf("ERROR: mkdir failed (%s)\n", cli_errstr(cli->tree));
 		correct = False;
 	}
 	sleep(3);
-	if (!cli_qpathinfo2(cli->tree, "\\trans2\\", &c_time, &a_time, &m_time, 
-			    &w_time, &size, NULL, NULL)) {
+	if (NT_STATUS_IS_ERR(cli_qpathinfo2(cli->tree, "\\trans2\\", &c_time, &a_time, &m_time, &w_time, &size, NULL, NULL))) {
 		printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli->tree));
 		correct = False;
 	}
@@ -2128,8 +2125,7 @@ static BOOL run_trans2test(int dummy)
 			O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
 	cli_write(cli->tree, fnum,  0, (char *)&fnum, 0, sizeof(fnum));
 	cli_close(cli->tree, fnum);
-	if (!cli_qpathinfo2(cli->tree, "\\trans2\\", &c_time, &a_time, &m_time2, 
-			    &w_time, &size, NULL, NULL)) {
+	if (NT_STATUS_IS_ERR(cli_qpathinfo2(cli->tree, "\\trans2\\", &c_time, &a_time, &m_time2, &w_time, &size, NULL, NULL))) {
 		printf("ERROR: qpathinfo2 failed (%s)\n", cli_errstr(cli->tree));
 		correct = False;
 	} else {
@@ -2183,7 +2179,7 @@ static BOOL run_deletetest(int dummy)
 		goto fail;
 	}
 	
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[1] close failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2213,13 +2209,13 @@ static BOOL run_deletetest(int dummy)
 		goto fail;
 	}
 	
-	if (!cli_nt_delete_on_close(cli1->tree, fnum1, True)) {
+	if (NT_STATUS_IS_ERR(cli_nt_delete_on_close(cli1->tree, fnum1, True))) {
 		printf("[2] setting delete_on_close failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
 	}
 	
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[2] close failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2228,7 +2224,7 @@ static BOOL run_deletetest(int dummy)
 	fnum1 = cli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
 	if (fnum1 != -1) {
 		printf("[2] open of %s succeeded should have been deleted on close !\n", fname);
-		if (!cli_close(cli1->tree, fnum1)) {
+		if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 			printf("[2] close failed (%s)\n", cli_errstr(cli1->tree));
 			correct = False;
 			goto fail;
@@ -2274,19 +2270,19 @@ static BOOL run_deletetest(int dummy)
 		goto fail;
 	}
 
-	if (!cli_nt_delete_on_close(cli1->tree, fnum1, True)) {
+	if (NT_STATUS_IS_ERR(cli_nt_delete_on_close(cli1->tree, fnum1, True))) {
 		printf("[3] setting delete_on_close failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
 	}
 	
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[3] close 1 failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
 	}
 	
-	if (!cli_close(cli1->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum2))) {
 		printf("[3] close 2 failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2297,7 +2293,7 @@ static BOOL run_deletetest(int dummy)
 	fnum1 = cli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
 	if (fnum1 != -1) {
 		printf("[3] open of %s succeeded should have been deleted on close !\n", fname);
-		if (!cli_close(cli1->tree, fnum1)) {
+		if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 			printf("[3] close failed (%s)\n", cli_errstr(cli1->tree));
 		}
 		cli_unlink(cli1->tree, fname);
@@ -2337,13 +2333,13 @@ static BOOL run_deletetest(int dummy)
 		goto fail;
 	}
 	
-	if (!cli_close(cli1->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum2))) {
 		printf("[4] close - 1 failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
 	}
 	
-	if (!cli_nt_delete_on_close(cli1->tree, fnum1, True)) {
+	if (NT_STATUS_IS_ERR(cli_nt_delete_on_close(cli1->tree, fnum1, True))) {
 		printf("[4] setting delete_on_close failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2360,7 +2356,7 @@ static BOOL run_deletetest(int dummy)
 	} else
 		printf("fourth delete on close test succeeded.\n");
 	
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[4] close - 2 failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2379,13 +2375,13 @@ static BOOL run_deletetest(int dummy)
 
 	/* This should fail - only allowed on NT opens with DELETE access. */
 
-	if (cli_nt_delete_on_close(cli1->tree, fnum1, True)) {
+	if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1->tree, fnum1, True))) {
 		printf("[5] setting delete_on_close on OpenX file succeeded - should fail !\n");
 		correct = False;
 		goto fail;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[5] close - 2 failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2413,13 +2409,13 @@ static BOOL run_deletetest(int dummy)
 	
 	/* This should fail - only allowed on NT opens with DELETE access. */
 	
-	if (cli_nt_delete_on_close(cli1->tree, fnum1, True)) {
+	if (NT_STATUS_IS_OK(cli_nt_delete_on_close(cli1->tree, fnum1, True))) {
 		printf("[6] setting delete_on_close on file with no delete access succeeded - should fail !\n");
 		correct = False;
 		goto fail;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[6] close - 2 failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2443,19 +2439,19 @@ static BOOL run_deletetest(int dummy)
 		goto fail;
 	}
 
-	if (!cli_nt_delete_on_close(cli1->tree, fnum1, True)) {
+	if (NT_STATUS_IS_ERR(cli_nt_delete_on_close(cli1->tree, fnum1, True))) {
 		printf("[7] setting delete_on_close on file failed !\n");
 		correct = False;
 		goto fail;
 	}
 	
-	if (!cli_nt_delete_on_close(cli1->tree, fnum1, False)) {
+	if (NT_STATUS_IS_ERR(cli_nt_delete_on_close(cli1->tree, fnum1, False))) {
 		printf("[7] unsetting delete_on_close on file failed !\n");
 		correct = False;
 		goto fail;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2470,7 +2466,7 @@ static BOOL run_deletetest(int dummy)
 		goto fail;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[7] close - 2 failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2508,19 +2504,19 @@ static BOOL run_deletetest(int dummy)
 		goto fail;
 	}
 
-	if (!cli_nt_delete_on_close(cli1->tree, fnum1, True)) {
+	if (NT_STATUS_IS_ERR(cli_nt_delete_on_close(cli1->tree, fnum1, True))) {
 		printf("[8] setting delete_on_close on file failed !\n");
 		correct = False;
 		goto fail;
 	}
 	
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[8] close - 1 failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
 	}
 
-	if (!cli_close(cli2->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli2->tree, fnum2))) {
 		printf("[8] close - 2 failed (%s)\n", cli_errstr(cli2->tree));
 		correct = False;
 		goto fail;
@@ -2556,7 +2552,7 @@ static BOOL run_deletetest(int dummy)
 	}
 
 	/* This should delete the file. */
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("[10] close failed (%s)\n", cli_errstr(cli1->tree));
 		correct = False;
 		goto fail;
@@ -2707,14 +2703,14 @@ static BOOL run_rename(int dummy)
 		return False;
 	}
 
-	if (!cli_rename(cli1->tree, fname, fname1)) {
+	if (NT_STATUS_IS_ERR(cli_rename(cli1->tree, fname, fname1))) {
 		printf("First rename failed (this is correct) - %s\n", cli_errstr(cli1->tree));
 	} else {
 		printf("First rename succeeded - this should have failed !\n");
 		correct = False;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("close - 1 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
@@ -2733,14 +2729,14 @@ static BOOL run_rename(int dummy)
 		return False;
 	}
 
-	if (!cli_rename(cli1->tree, fname, fname1)) {
+	if (NT_STATUS_IS_ERR(cli_rename(cli1->tree, fname, fname1))) {
 		printf("Second rename failed - this should have succeeded - %s\n", cli_errstr(cli1->tree));
 		correct = False;
 	} else {
 		printf("Second rename succeeded\n");
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("close - 2 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
@@ -2780,14 +2776,14 @@ static BOOL run_rename(int dummy)
   }
 #endif
 
-	if (!cli_rename(cli1->tree, fname, fname1)) {
+	if (NT_STATUS_IS_ERR(cli_rename(cli1->tree, fname, fname1))) {
 		printf("Third rename failed - this should have succeeded - %s\n", cli_errstr(cli1->tree));
 		correct = False;
 	} else {
 		printf("Third rename succeeded\n");
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("close - 3 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
@@ -2861,12 +2857,12 @@ static BOOL run_pipe_number(int dummy)
 		return False;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("close2 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
 	
-	if (!cli_setatr(cli1->tree, fname, FILE_ATTRIBUTE_READONLY, 0)) {
+	if (NT_STATUS_IS_ERR(cli_setatr(cli1->tree, fname, FILE_ATTRIBUTE_READONLY, 0))) {
 		printf("cli_setatr failed (%s)\n", cli_errstr(cli1->tree));
 		CHECK_MAX_FAILURES(error_test1);
 		return False;
@@ -2909,7 +2905,7 @@ error_test1:
 		printf("correct error code ERRDOS/ERRbadshare returned\n");
 	}
 	
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("close2 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
@@ -2935,13 +2931,13 @@ error_test1:
 		correct = False;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("(3) close1 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
 	
 	/* Ensure size == 20. */
-	if (!cli_getatr(cli1->tree, fname, NULL, &fsize, NULL)) {
+	if (NT_STATUS_IS_ERR(cli_getatr(cli1->tree, fname, NULL, &fsize, NULL))) {
 		printf("(3) getatr failed (%s)\n", cli_errstr(cli1->tree));
 		CHECK_MAX_FAILURES(error_test3);
 		return False;
@@ -2962,13 +2958,13 @@ error_test1:
 		return False;
 	}
 	
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("close2 failed (%s)\n", cli_errstr(cli1->tree));
 		return False;
 	}
 
 	/* Ensure size == 0. */
-	if (!cli_getatr(cli1->tree, fname, NULL, &fsize, NULL)) {
+	if (NT_STATUS_IS_ERR(cli_getatr(cli1->tree, fname, NULL, &fsize, NULL))) {
 		printf("(3) getatr failed (%s)\n", cli_errstr(cli1->tree));
 		CHECK_MAX_FAILURES(error_test3);
 		return False;
@@ -2992,10 +2988,10 @@ error_test3:
 		return False;
 	}
 	printf("ctemp gave path %s\n", tmp_path);
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("close of temp failed (%s)\n", cli_errstr(cli1->tree));
 	}
-	if (!cli_unlink(cli1->tree, tmp_path)) {
+	if (NT_STATUS_IS_ERR(cli_unlink(cli1->tree, tmp_path))) {
 		printf("unlink of temp failed (%s)\n", cli_errstr(cli1->tree));
 	}
 error_test4:	
@@ -3027,11 +3023,11 @@ error_test4:
 		return False;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1->tree));
 		return False;
 	}
-	if (!cli_close(cli2->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli2->tree, fnum2))) {
 		printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2->tree));
 		return False;
 	}
@@ -3060,11 +3056,11 @@ error_test10:
 		return False;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("test 1 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1->tree));
 		return False;
 	}
-	if (!cli_close(cli2->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli2->tree, fnum2))) {
 		printf("test 1 close 2 of %s failed (%s)\n", fname, cli_errstr(cli1->tree));
 		return False;
 	}
@@ -3093,11 +3089,11 @@ error_test20:
 		return False;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("test 3 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1->tree));
 		return False;
 	}
-	if (!cli_close(cli2->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli2->tree, fnum2))) {
 		printf("test 3 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2->tree));
 		return False;
 	}
@@ -3128,7 +3124,7 @@ error_test30:
 
 	printf("test 4 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2->tree), "sharing violation");
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("test 4 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1->tree));
 		return False;
 	}
@@ -3157,12 +3153,12 @@ error_test40:
 		return False;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("test 5 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1->tree));
 		return False;
 	}
 
-	if (!cli_close(cli2->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli2->tree, fnum2))) {
 		printf("test 5 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2->tree));
 		return False;
 	}
@@ -3191,12 +3187,12 @@ error_test50:
 		return False;
 	}
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("test 6 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1->tree));
 		return False;
 	}
 
-	if (!cli_close(cli2->tree, fnum2)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli2->tree, fnum2))) {
 		printf("test 6 close 2 of %s failed (%s)\n", fname, cli_errstr(cli2->tree));
 		return False;
 	}
@@ -3227,7 +3223,7 @@ error_test60:
 
 	printf("test 7 open 2 of %s gave %s (correct error should be %s)\n", fname, cli_errstr(cli2->tree), "sharing violation");
 
-	if (!cli_close(cli1->tree, fnum1)) {
+	if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 		printf("test 7 close 1 of %s failed (%s)\n", fname, cli_errstr(cli1->tree));
 		return False;
 	}
@@ -3330,7 +3326,7 @@ static BOOL run_openattrtest(int dummy)
 			return False;
 		}
 
-		if (!cli_close(cli1->tree, fnum1)) {
+		if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 			printf("close %d (1) of %s failed (%s)\n", i, fname, cli_errstr(cli1->tree));
 			return False;
 		}
@@ -3367,12 +3363,12 @@ static BOOL run_openattrtest(int dummy)
 				continue;
 			}
 
-			if (!cli_close(cli1->tree, fnum1)) {
+			if (NT_STATUS_IS_ERR(cli_close(cli1->tree, fnum1))) {
 				printf("close %d (2) of %s failed (%s)\n", j, fname, cli_errstr(cli1->tree));
 				return False;
 			}
 
-			if (!cli_getatr(cli1->tree, fname, &attr, NULL, NULL)) {
+			if (NT_STATUS_IS_ERR(cli_getatr(cli1->tree, fname, &attr, NULL, NULL))) {
 				printf("getatr(2) failed (%s)\n", cli_errstr(cli1->tree));
 				return False;
 			}
@@ -3485,10 +3481,10 @@ static void del_fn(file_info *finfo, const char *mask, void *state)
 		return;
 
 	if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
-		if (!cli_rmdir(pcli->tree, fname))
+		if (NT_STATUS_IS_ERR(cli_rmdir(pcli->tree, fname)))
 			printf("del_fn: failed to rmdir %s, error=%s\n", fname, cli_errstr(pcli->tree) );
 	} else {
-		if (!cli_unlink(pcli->tree, fname))
+		if (NT_STATUS_IS_ERR(cli_unlink(pcli->tree, fname)))
 			printf("del_fn: failed to unlink %s, error=%s\n", fname, cli_errstr(pcli->tree) );
 	}
 	free(fname);
@@ -3572,12 +3568,12 @@ BOOL torture_chkpath_test(int dummy)
 	cli_unlink(cli->tree, "\\chkpath.dir\\*");
 	cli_rmdir(cli->tree, "\\chkpath.dir");
 
-	if (!cli_mkdir(cli->tree, "\\chkpath.dir")) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, "\\chkpath.dir"))) {
 		printf("mkdir1 failed : %s\n", cli_errstr(cli->tree));
 		return False;
 	}
 
-	if (!cli_mkdir(cli->tree, "\\chkpath.dir\\dir2")) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, "\\chkpath.dir\\dir2"))) {
 		printf("mkdir2 failed : %s\n", cli_errstr(cli->tree));
 		return False;
 	}
@@ -3589,17 +3585,17 @@ BOOL torture_chkpath_test(int dummy)
 	}
 	cli_close(cli->tree, fnum);
 
-	if (!cli_chkpath(cli->tree, "\\chkpath.dir")) {
+	if (NT_STATUS_IS_ERR(cli_chkpath(cli->tree, "\\chkpath.dir"))) {
 		printf("chkpath1 failed: %s\n", cli_errstr(cli->tree));
 		ret = False;
 	}
 
-	if (!cli_chkpath(cli->tree, "\\chkpath.dir\\dir2")) {
+	if (NT_STATUS_IS_ERR(cli_chkpath(cli->tree, "\\chkpath.dir\\dir2"))) {
 		printf("chkpath2 failed: %s\n", cli_errstr(cli->tree));
 		ret = False;
 	}
 
-	if (!cli_chkpath(cli->tree, "\\chkpath.dir\\foo.txt")) {
+	if (NT_STATUS_IS_ERR(cli_chkpath(cli->tree, "\\chkpath.dir\\foo.txt"))) {
 		ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath, 
 				  NT_STATUS_NOT_A_DIRECTORY);
 	} else {
@@ -3607,7 +3603,7 @@ BOOL torture_chkpath_test(int dummy)
 		ret = False;
 	}
 
-	if (!cli_chkpath(cli->tree, "\\chkpath.dir\\bar.txt")) {
+	if (NT_STATUS_IS_ERR(cli_chkpath(cli->tree, "\\chkpath.dir\\bar.txt"))) {
 		ret = check_error(__LINE__, cli, ERRDOS, ERRbadfile, 
 				  NT_STATUS_OBJECT_NAME_NOT_FOUND);
 	} else {
@@ -3615,7 +3611,7 @@ BOOL torture_chkpath_test(int dummy)
 		ret = False;
 	}
 
-	if (!cli_chkpath(cli->tree, "\\chkpath.dir\\dirxx\\bar.txt")) {
+	if (NT_STATUS_IS_ERR(cli_chkpath(cli->tree, "\\chkpath.dir\\dirxx\\bar.txt"))) {
 		ret = check_error(__LINE__, cli, ERRDOS, ERRbadpath, 
 				  NT_STATUS_OBJECT_PATH_NOT_FOUND);
 	} else {
@@ -3653,7 +3649,7 @@ static BOOL run_dirtest1(int dummy)
 		fprintf(stderr,"Failed to deltree %s, error=%s\n", "\\LISTDIR", cli_errstr(cli->tree));
 		return False;
 	}
-	if (!cli_mkdir(cli->tree, "\\LISTDIR")) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, "\\LISTDIR"))) {
 		fprintf(stderr,"Failed to mkdir %s, error=%s\n", "\\LISTDIR", cli_errstr(cli->tree));
 		return False;
 	}
@@ -3676,7 +3672,7 @@ static BOOL run_dirtest1(int dummy)
 	for (i=0;i<torture_entries;i++) {
 		char *fname;
 		asprintf(&fname, "\\LISTDIR\\d%d", i);
-		if (!cli_mkdir(cli->tree, fname)) {
+		if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, fname))) {
 			fprintf(stderr,"Failed to open %s, error=%s\n", fname, cli_errstr(cli->tree));
 			return False;
 		}
diff --git a/source4/torture/utable.c b/source4/torture/utable.c
index 9d23f10121..ec37edab82 100644
--- a/source4/torture/utable.c
+++ b/source4/torture/utable.c
@@ -133,7 +133,7 @@ BOOL torture_casetable(int dummy)
 	memset(equiv, 0, sizeof(equiv));
 
 	cli_deltree(cli->tree, "\\utable");
-	if (!cli_mkdir(cli->tree, "\\utable")) {
+	if (NT_STATUS_IS_ERR(cli_mkdir(cli->tree, "\\utable"))) {
 		printf("Failed to create utable directory!\n");
 		return False;
 	}
@@ -163,8 +163,8 @@ BOOL torture_casetable(int dummy)
 
 		size = 0;
 
-		if (!cli_qfileinfo(cli->tree, fnum, NULL, &size, 
-				   NULL, NULL, NULL, NULL, NULL)) continue;
+		if (NT_STATUS_IS_ERR(cli_qfileinfo(cli->tree, fnum, NULL, &size, 
+						   NULL, NULL, NULL, NULL, NULL))) continue;
 
 		if (size > 0) {
 			/* found a character equivalence! */