Changeset 740 for vendor/current/source3/client

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/source3/client

Files:

• client.c (modified) (99 diffs)
• client_proto.h (modified) (2 diffs)
• clitar.c (modified) (31 diffs)
• dnsbrowse.c (modified) (5 diffs)
• smbspool.c (modified) (6 diffs)

vendor/current/source3/client/client.c

@@ -23 +23 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "popt_common.h"
+#include "rpc_client/cli_pipe.h"
 #include "client/client_proto.h"
-#include "../librpc/gen_ndr/cli_srvsvc.h"
+#include "../librpc/gen_ndr/ndr_srvsvc_c.h"
+#include "../lib/util/select.h"
+#include "system/readline.h"
+#include "../libcli/smbreadline/smbreadline.h"
+#include "../libcli/security/security.h"
+#include "system/select.h"
+#include "libsmb/libsmb.h"
+#include "libsmb/clirap.h"
+#include "trans2.h"
+#include "libsmb/nmblib.h"
 
 #ifndef REGISTER
@@ -32 +44 @@
 extern int do_smb_browse(void); /* mDNS browsing */
 
-extern bool AllowDebugChange;
 extern bool override_logfile;
 extern char tar_type;
@@ -164 +175 @@
 
 /****************************************************************************
+ Put up a yes/no prompt.
+****************************************************************************/
+
+static bool yesno(const char *p)
+{
+        char ans[20];
+        printf("%s",p);
+
+        if (!fgets(ans,sizeof(ans)-1,stdin))
+                return(False);
+
+        if (*ans == 'y' || *ans == 'Y')
+                return(True);
+
+        return(False);
+}
+
+/****************************************************************************
  Write to a local file with CR/LF->LF translation if appropriate. Return the
  number taken from the buffer. This may not equal the number written.
@@ -281 +310 @@
         char *targetpath = NULL;
         TALLOC_CTX *ctx = talloc_tos();
+        NTSTATUS status;
 
         if ( !cli_resolve_path(ctx, "", auth_info, cli, client_get_cur_dir(), &targetcli, &targetpath)) {
@@ -287 +317 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_dskattr(targetcli, &bsize, &total, &avail))) {
-                d_printf("Error in dskattr: %s\n",cli_errstr(targetcli));
+        status = cli_dskattr(targetcli, &bsize, &total, &avail);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Error in dskattr: %s\n", nt_errstr(status));
                 return 1;
         }
@@ -315 +346 @@
 static void normalize_name(char *newdir)
 {
-        if (!(cli->posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP)) {
+        if (!(cli->requested_posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP)) {
                 string_replace(newdir,'/','\\');
         }
@@ -391 +422 @@
 
         if (targetcli->protocol > PROTOCOL_LANMAN2 && !targetcli->win95) {
-                if (!cli_qpathinfo_basic( targetcli, targetpath, &sbuf, &attributes ) ) {
-                        d_printf("cd %s: %s\n", new_cd, cli_errstr(targetcli));
+                NTSTATUS status;
+
+                status = cli_qpathinfo_basic(targetcli, targetpath, &sbuf,
+                                             &attributes);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_printf("cd %s: %s\n", new_cd, nt_errstr(status));
                         client_set_cur_dir(saved_dir);
                         goto out;
@@ -403 +438 @@
                 }
         } else {
+                NTSTATUS status;
+
                 targetpath = talloc_asprintf(ctx,
                                 "%s%s",
@@ -417 +454 @@
                 }
 
-                if (!NT_STATUS_IS_OK(cli_chkpath(targetcli, targetpath))) {
-                        d_printf("cd %s: %s\n", new_cd, cli_errstr(targetcli));
+                status = cli_chkpath(targetcli, targetpath);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_printf("cd %s: %s\n", new_cd, nt_errstr(status));
                         client_set_cur_dir(saved_dir);
                         goto out;
@@ -463 +501 @@
 ********************************************************************/
 
-static bool do_this_one(file_info *finfo)
+static bool do_this_one(struct file_info *finfo)
 {
         if (!finfo->name) {
@@ -469 +507 @@
         }
 
-        if (finfo->mode & aDIR) {
+        if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
                 return true;
         }
@@ -484 +522 @@
         }
 
-        if ((archive_level==1 || archive_level==2) && !(finfo->mode & aARCH)) {
+        if ((archive_level==1 || archive_level==2) && !(finfo->mode & FILE_ATTRIBUTE_ARCHIVE)) {
                 DEBUG(3,("archive %s failed\n", finfo->name));
                 return false;
@@ -496 +534 @@
 ****************************************************************************/
 
-static void display_finfo(file_info *finfo, const char *dir)
+static NTSTATUS display_finfo(struct cli_state *cli_state, struct file_info *finfo,
+                          const char *dir)
 {
         time_t t;
         TALLOC_CTX *ctx = talloc_tos();
+        NTSTATUS status = NT_STATUS_OK;
 
         if (!do_this_one(finfo)) {
-                return;
+                return NT_STATUS_OK;
         }
 
@@ -519 +559 @@
                 /* skip if this is . or .. */
                 if ( strequal(finfo->name,"..") || strequal(finfo->name,".") )
-                        return;
+                        return NT_STATUS_OK;
                 /* create absolute filename for cli_ntcreate() FIXME */
                 afname = talloc_asprintf(ctx,
@@ -527 +567 @@
                                         finfo->name);
                 if (!afname) {
-                        return;
+                        return NT_STATUS_NO_MEMORY;
                 }
                 /* print file meta date header */
@@ -534 +574 @@
                 d_printf( "SIZE:%.0f\n", (double)finfo->size);
                 d_printf( "MTIME:%s", time_to_asc(t));
-                if (!NT_STATUS_IS_OK(cli_ntcreate(finfo->cli, afname, 0,
-                                CREATE_ACCESS_READ, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
-                                FILE_OPEN, 0x0, 0x0, &fnum))) {
+                status = cli_ntcreate(cli_state, afname, 0,
+                                      CREATE_ACCESS_READ, 0,
+                                      FILE_SHARE_READ|FILE_SHARE_WRITE,
+                                      FILE_OPEN, 0x0, 0x0, &fnum);
+                if (!NT_STATUS_IS_OK(status)) {
                         DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
-                                afname,
-                                cli_errstr( finfo->cli)));
+                                   afname, nt_errstr(status)));
                 } else {
-                        SEC_DESC *sd = NULL;
-                        sd = cli_query_secdesc(finfo->cli, fnum, ctx);
+                        struct security_descriptor *sd = NULL;
+                        sd = cli_query_secdesc(cli_state, fnum, ctx);
                         if (!sd) {
                                 DEBUG( 0, ("display_finfo() failed to "
                                         "get security descriptor: %s",
-                                        cli_errstr( finfo->cli)));
+                                        cli_errstr(cli_state)));
+                                status = cli_nt_error(cli_state);
                         } else {
                                 display_sec_desc(sd);
@@ -554 +596 @@
                 TALLOC_FREE(afname);
         }
+        return status;
 }
 
@@ -560 +603 @@
 ****************************************************************************/
 
-static void do_du(file_info *finfo, const char *dir)
+static NTSTATUS do_du(struct cli_state *cli_state, struct file_info *finfo,
+                  const char *dir)
 {
         if (do_this_one(finfo)) {
                 dir_total += finfo->size;
         }
+        return NT_STATUS_OK;
 }
 
@@ -573 +618 @@
 static long do_list_queue_start = 0;
 static long do_list_queue_end = 0;
-static void (*do_list_fn)(file_info *, const char *dir);
+static NTSTATUS (*do_list_fn)(struct cli_state *cli_state, struct file_info *,
+                          const char *dir);
 
 /****************************************************************************
@@ -690 +736 @@
 ****************************************************************************/
 
-static void do_list_helper(const char *mntpoint, file_info *f, const char *mask, void *state)
-{
+static NTSTATUS do_list_helper(const char *mntpoint, struct file_info *f,
+                           const char *mask, void *state)
+{
+        struct cli_state *cli_state = (struct cli_state *)state;
         TALLOC_CTX *ctx = talloc_tos();
         char *dir = NULL;
         char *dir_end = NULL;
+        NTSTATUS status = NT_STATUS_OK;
 
         /* Work out the directory. */
         dir = talloc_strdup(ctx, mask);
         if (!dir) {
-                return;
+                return NT_STATUS_NO_MEMORY;
         }
         if ((dir_end = strrchr(dir, CLI_DIRSEP_CHAR)) != NULL) {
@@ -705 +754 @@
         }
 
-        if (f->mode & aDIR) {
+        if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
                 if (do_list_dirs && do_this_one(f)) {
-                        do_list_fn(f, dir);
+                        status = do_list_fn(cli_state, f, dir);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                return status;
+                        }
                 }
                 if (do_list_recurse &&
@@ -719 +771 @@
                                 d_printf("Empty dir name returned. Possible server misconfiguration.\n");
                                 TALLOC_FREE(dir);
-                                return;
+                                return NT_STATUS_UNSUCCESSFUL;
                         }
 
@@ -728 +780 @@
                         if (!mask2) {
                                 TALLOC_FREE(dir);
-                                return;
+                                return NT_STATUS_NO_MEMORY;
                         }
                         p = strrchr_m(mask2,CLI_DIRSEP_CHAR);
@@ -742 +794 @@
                         if (!mask2) {
                                 TALLOC_FREE(dir);
-                                return;
+                                return NT_STATUS_NO_MEMORY;
                         }
                         add_to_do_list_queue(mask2);
@@ -748 +800 @@
                 }
                 TALLOC_FREE(dir);
-                return;
+                return NT_STATUS_OK;
         }
 
         if (do_this_one(f)) {
-                do_list_fn(f,dir);
+                status = do_list_fn(cli_state, f, dir);
         }
         TALLOC_FREE(dir);
+        return status;
 }
 
@@ -761 +814 @@
 ****************************************************************************/
 
-void do_list(const char *mask,
+NTSTATUS do_list(const char *mask,
                         uint16 attribute,
-                        void (*fn)(file_info *, const char *dir),
+                        NTSTATUS (*fn)(struct cli_state *cli_state, struct file_info *,
+                                   const char *dir),
                         bool rec,
                         bool dirs)
@@ -771 +825 @@
         struct cli_state *targetcli = NULL;
         char *targetpath = NULL;
+        NTSTATUS ret_status = NT_STATUS_OK;
+        NTSTATUS status = NT_STATUS_OK;
 
         if (in_do_list && rec) {
@@ -798 +854 @@
 
                         if (!head) {
-                                return;
+                                return NT_STATUS_NO_MEMORY;
                         }
 
@@ -809 +865 @@
                         }
 
-                        cli_list(targetcli, targetpath, attribute, do_list_helper, NULL);
+                        status = cli_list(targetcli, targetpath, attribute,
+                                 do_list_helper, targetcli);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                d_printf("%s listing %s\n",
+                                         nt_errstr(status), targetpath);
+                                ret_status = status;
+                        }
                         remove_do_list_queue_head();
                         if ((! do_list_queue_empty()) && (fn == display_finfo)) {
@@ -837 +899 @@
                 /* check for dfs */
                 if (cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetpath)) {
-                        if (cli_list(targetcli, targetpath, attribute, do_list_helper, NULL) == -1) {
+
+                        status = cli_list(targetcli, targetpath, attribute,
+                                          do_list_helper, targetcli);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 d_printf("%s listing %s\n",
-                                        cli_errstr(targetcli), targetpath);
+                                         nt_errstr(status), targetpath);
+                                ret_status = status;
                         }
                         TALLOC_FREE(targetpath);
                 } else {
                         d_printf("do_list: [%s] %s\n", mask, cli_errstr(cli));
+                        ret_status = cli_nt_error(cli);
                 }
         }
@@ -849 +916 @@
         in_do_list = 0;
         reset_do_list_queue();
+        return ret_status;
 }
 
@@ -858 +926 @@
 {
         TALLOC_CTX *ctx = talloc_tos();
-        uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
+        uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
         char *mask = NULL;
         char *buf = NULL;
         int rc = 1;
+        NTSTATUS status;
 
         dir_total = 0;
@@ -888 +957 @@
         }
 
-        do_list(mask, attribute, display_finfo, recurse, true);
+        status = do_list(mask, attribute, display_finfo, recurse, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                return 1;
+        }
 
         rc = do_dskattr();
@@ -904 +976 @@
 {
         TALLOC_CTX *ctx = talloc_tos();
-        uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
+        uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
         char *mask = NULL;
         char *buf = NULL;
+        NTSTATUS status;
         int rc = 1;
 
@@ -932 +1005 @@
         }
 
-        do_list(mask, attribute, do_du, recurse, true);
+        status = do_list(mask, attribute, do_du, recurse, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                return 1;
+        }
 
         rc = do_dskattr();
@@ -983 +1059 @@
         uint16_t fnum;
         bool newhandle = false;
-        struct timeval tp_start;
+        struct timespec tp_start;
         uint16 attr;
         SMB_OFF_T size;
@@ -1008 +1084 @@
         }
 
-        GetTimeOfDay(&tp_start);
-
-        if (!NT_STATUS_IS_OK(cli_open(targetcli, targetname, O_RDONLY, DENY_NONE, &fnum))) {
-                d_printf("%s opening remote file %s\n",cli_errstr(cli),rname);
+        clock_gettime_mono(&tp_start);
+
+        status = cli_open(targetcli, targetname, O_RDONLY, DENY_NONE, &fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("%s opening remote file %s\n", nt_errstr(status),
+                         rname);
                 return 1;
         }
@@ -1038 +1116 @@
 
 
-        if (!cli_qfileinfo(targetcli, fnum,
-                           &attr, &size, NULL, NULL, NULL, NULL, NULL) &&
-            !NT_STATUS_IS_OK(cli_getattrE(targetcli, fnum,
-                          &attr, &size, NULL, NULL, NULL))) {
-                d_printf("getattrib: %s\n",cli_errstr(targetcli));
-                return 1;
+        status = cli_qfileinfo_basic(targetcli, fnum, &attr, &size, NULL, NULL,
+                                     NULL, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                status = cli_getattrE(targetcli, fnum, &attr, &size, NULL, NULL,
+                                      NULL);
+                if(!NT_STATUS_IS_OK(status)) {
+                        d_printf("getattrib: %s\n", nt_errstr(status));
+                        return 1;
+                }
         }
 
@@ -1058 +1139 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(targetcli, fnum))) {
-                d_printf("Error %s closing remote file\n",cli_errstr(cli));
+        status = cli_close(targetcli, fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Error %s closing remote file\n", nt_errstr(status));
                 rc = 1;
         }
@@ -1067 +1149 @@
         }
 
-        if (archive_level >= 2 && (attr & aARCH)) {
-                cli_setatr(cli, rname, attr & ~(uint16)aARCH, 0);
+        if (archive_level >= 2 && (attr & FILE_ATTRIBUTE_ARCHIVE)) {
+                cli_setatr(cli, rname, attr & ~(uint16)FILE_ATTRIBUTE_ARCHIVE, 0);
         }
 
         {
-                struct timeval tp_end;
+                struct timespec tp_end;
                 int this_time;
 
-                GetTimeOfDay(&tp_end);
-                this_time =
-                        (tp_end.tv_sec - tp_start.tv_sec)*1000 +
-                        (tp_end.tv_usec - tp_start.tv_usec)/1000;
+                clock_gettime_mono(&tp_end);
+                this_time = nsec_time_diff(&tp_end,&tp_start)/1000000;
                 get_total_time_ms += this_time;
                 get_total_size += nread;
@@ -1132 +1212 @@
 ****************************************************************************/
 
-static void do_mget(file_info *finfo, const char *dir)
-{
-        TALLOC_CTX *ctx = talloc_tos();
+static NTSTATUS do_mget(struct cli_state *cli_state, struct file_info *finfo,
+                    const char *dir)
+{
+        TALLOC_CTX *ctx = talloc_tos();
+        NTSTATUS status = NT_STATUS_OK;
         char *rname = NULL;
         char *quest = NULL;
@@ -1142 +1224 @@
 
         if (!finfo->name) {
-                return;
+                return NT_STATUS_OK;
         }
 
         if (strequal(finfo->name,".") || strequal(finfo->name,".."))
-                return;
+                return NT_STATUS_OK;
 
         if (abort_mget) {
                 d_printf("mget aborted\n");
-                return;
-        }
-
-        if (finfo->mode & aDIR) {
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
+        if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
                 if (asprintf(&quest,
                          "Get directory %s? ",finfo->name) < 0) {
-                        return;
+                        return NT_STATUS_NO_MEMORY;
                 }
         } else {
                 if (asprintf(&quest,
                          "Get file %s? ",finfo->name) < 0) {
-                        return;
+                        return NT_STATUS_NO_MEMORY;
                 }
         }
@@ -1167 +1249 @@
         if (prompt && !yesno(quest)) {
                 SAFE_FREE(quest);
-                return;
+                return NT_STATUS_OK;
         }
         SAFE_FREE(quest);
 
-        if (!(finfo->mode & aDIR)) {
+        if (!(finfo->mode & FILE_ATTRIBUTE_DIRECTORY)) {
                 rname = talloc_asprintf(ctx,
                                 "%s%s",
@@ -1177 +1259 @@
                                 finfo->name);
                 if (!rname) {
-                        return;
+                        return NT_STATUS_NO_MEMORY;
                 }
                 do_get(rname, finfo->name, false);
                 TALLOC_FREE(rname);
-                return;
+                return NT_STATUS_OK;
         }
 
@@ -1187 +1269 @@
         saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
         if (!saved_curdir) {
-                return;
+                return NT_STATUS_NO_MEMORY;
         }
 
@@ -1196 +1278 @@
                                 CLI_DIRSEP_STR);
         if (!new_cd) {
-                return;
+                return NT_STATUS_NO_MEMORY;
         }
         client_set_cur_dir(new_cd);
@@ -1209 +1291 @@
                 d_printf("failed to create directory %s\n",finfo->name);
                 client_set_cur_dir(saved_curdir);
-                return;
+                return map_nt_error_from_unix(errno);
         }
 
@@ -1215 +1297 @@
                 d_printf("failed to chdir to directory %s\n",finfo->name);
                 client_set_cur_dir(saved_curdir);
-                return;
+                return map_nt_error_from_unix(errno);
         }
 
@@ -1223 +1305 @@
 
         if (!mget_mask) {
-                return;
-        }
-
-        do_list(mget_mask, aSYSTEM | aHIDDEN | aDIR,do_mget,false, true);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        status = do_list(mget_mask, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,do_mget,false, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
         if (chdir("..") == -1) {
                 d_printf("do_mget: failed to chdir to .. (error %s)\n",
                         strerror(errno) );
+                return map_nt_error_from_unix(errno);
         }
         client_set_cur_dir(saved_curdir);
@@ -1235 +1322 @@
         TALLOC_FREE(saved_curdir);
         TALLOC_FREE(new_cd);
+        return NT_STATUS_OK;
 }
 
@@ -1309 +1397 @@
 {
         TALLOC_CTX *ctx = talloc_tos();
-        uint16 attribute = aSYSTEM | aHIDDEN;
+        uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
         char *mget_mask = NULL;
         char *buf = NULL;
+        NTSTATUS status = NT_STATUS_OK;
 
         if (recurse) {
-                attribute |= aDIR;
+                attribute |= FILE_ATTRIBUTE_DIRECTORY;
         }
 
@@ -1320 +1409 @@
 
         while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+
                 mget_mask = talloc_strdup(ctx, client_get_cur_dir());
                 if (!mget_mask) {
@@ -1333 +1423 @@
                         return 1;
                 }
-                do_list(mget_mask, attribute, do_mget, false, true);
+                status = do_list(mget_mask, attribute, do_mget, false, true);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return 1;
+                }
         }
 
@@ -1348 +1441 @@
                         return 1;
                 }
-                do_list(mget_mask, attribute, do_mget, false, true);
+                status = do_list(mget_mask, attribute, do_mget, false, true);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return 1;
+                }
         }
 
@@ -1363 +1459 @@
         struct cli_state *targetcli;
         char *targetname = NULL;
+        NTSTATUS status;
 
         if (!cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli, &targetname)) {
@@ -1369 +1466 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_mkdir(targetcli, targetname))) {
+        status = cli_mkdir(targetcli, targetname);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s making remote directory %s\n",
-                         cli_errstr(targetcli),name);
+                         nt_errstr(status),name);
                 return false;
         }
@@ -1385 +1483 @@
 {
         fstring altname;
-
-        if (!NT_STATUS_IS_OK(cli_qpathinfo_alt_name(cli, name, altname))) {
+        NTSTATUS status;
+
+        status = cli_qpathinfo_alt_name(cli, name, altname);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s getting alt name for %s\n",
-                         cli_errstr(cli),name);
+                         nt_errstr(status),name);
                 return false;
         }
@@ -1505 +1605 @@
 }
 
+static char *attr_str(TALLOC_CTX *mem_ctx, uint16_t mode)
+{
+        char *attrs = TALLOC_ZERO_ARRAY(mem_ctx, char, 17);
+        int i = 0;
+
+        if (!(mode & FILE_ATTRIBUTE_NORMAL)) {
+                if (mode & FILE_ATTRIBUTE_ENCRYPTED) {
+                        attrs[i++] = 'E';
+                }
+                if (mode & FILE_ATTRIBUTE_NONINDEXED) {
+                        attrs[i++] = 'N';
+                }
+                if (mode & FILE_ATTRIBUTE_OFFLINE) {
+                        attrs[i++] = 'O';
+                }
+                if (mode & FILE_ATTRIBUTE_COMPRESSED) {
+                        attrs[i++] = 'C';
+                }
+                if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
+                        attrs[i++] = 'r';
+                }
+                if (mode & FILE_ATTRIBUTE_SPARSE) {
+                        attrs[i++] = 's';
+                }
+                if (mode & FILE_ATTRIBUTE_TEMPORARY) {
+                        attrs[i++] = 'T';
+                }
+                if (mode & FILE_ATTRIBUTE_NORMAL) {
+                        attrs[i++] = 'N';
+                }
+                if (mode & FILE_ATTRIBUTE_READONLY) {
+                        attrs[i++] = 'R';
+                }
+                if (mode & FILE_ATTRIBUTE_HIDDEN) {
+                        attrs[i++] = 'H';
+                }
+                if (mode & FILE_ATTRIBUTE_SYSTEM) {
+                        attrs[i++] = 'S';
+                }
+                if (mode & FILE_ATTRIBUTE_DIRECTORY) {
+                        attrs[i++] = 'D';
+                }
+                if (mode & FILE_ATTRIBUTE_ARCHIVE) {
+                        attrs[i++] = 'A';
+                }
+        }
+        return attrs;
+}
+
 /****************************************************************************
  Show all info we can get
@@ -1517 +1666 @@
         SMB_INO_T ino;
         NTTIME tmp;
+        uint16_t fnum;
         unsigned int num_streams;
         struct stream_struct *streams;
+        int num_snapshots;
+        char **snapshots;
         unsigned int i;
-
-        if (!NT_STATUS_IS_OK(cli_qpathinfo_alt_name(cli, name, altname))) {
-                d_printf("%s getting alt name for %s\n",
-                         cli_errstr(cli),name);
+        NTSTATUS status;
+
+        status = cli_qpathinfo_alt_name(cli, name, altname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("%s getting alt name for %s\n", nt_errstr(status),
+                         name);
                 return false;
         }
         d_printf("altname: %s\n", altname);
 
-        if (!cli_qpathinfo2(cli, name, &b_time, &a_time, &m_time, &c_time,
-                            &size, &mode, &ino)) {
-                d_printf("%s getting pathinfo for %s\n",
-                         cli_errstr(cli),name);
+        status = cli_qpathinfo2(cli, name, &b_time, &a_time, &m_time, &c_time,
+                                &size, &mode, &ino);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("%s getting pathinfo for %s\n", nt_errstr(status),
+                         name);
                 return false;
         }
@@ -1547 +1702 @@
         d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
 
-        if (!cli_qpathinfo_streams(cli, name, talloc_tos(), &num_streams,
-                                   &streams)) {
-                d_printf("%s getting streams for %s\n",
-                         cli_errstr(cli),name);
+        d_printf("attributes: %s (%x)\n", attr_str(talloc_tos(), mode), mode);
+
+        status = cli_qpathinfo_streams(cli, name, talloc_tos(), &num_streams,
+                                       &streams);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("%s getting streams for %s\n", nt_errstr(status),
+                         name);
                 return false;
         }
@@ -1558 +1716 @@
                          (unsigned long long)streams[i].size);
         }
+
+        status = cli_ntcreate(cli, name, 0,
+                              CREATE_ACCESS_READ, 0,
+                              FILE_SHARE_READ|FILE_SHARE_WRITE
+                              |FILE_SHARE_DELETE,
+                              FILE_OPEN, 0x0, 0x0, &fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                /*
+                 * Ignore failure, it does not hurt if we can't list
+                 * snapshots
+                 */
+                return 0;
+        }
+        status = cli_shadow_copy_data(talloc_tos(), cli, fnum,
+                                      true, &snapshots, &num_snapshots);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_close(cli, fnum);
+                return 0;
+        }
+
+        for (i=0; i<num_snapshots; i++) {
+                char *snap_name;
+
+                d_printf("%s\n", snapshots[i]);
+                snap_name = talloc_asprintf(talloc_tos(), "%s%s",
+                                            snapshots[i], name);
+                status = cli_qpathinfo2(cli, snap_name, &b_time, &a_time,
+                                        &m_time, &c_time, &size,
+                                        NULL, NULL);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_fprintf(stderr, "pathinfo(%s) failed: %s\n",
+                                  snap_name, nt_errstr(status));
+                        TALLOC_FREE(snap_name);
+                        continue;
+                }
+                unix_timespec_to_nt_time(&tmp, b_time);
+                d_printf("create_time:    %s\n", nt_time_string(talloc_tos(), tmp));
+                unix_timespec_to_nt_time(&tmp, a_time);
+                d_printf("access_time:    %s\n", nt_time_string(talloc_tos(), tmp));
+                unix_timespec_to_nt_time(&tmp, m_time);
+                d_printf("write_time:     %s\n", nt_time_string(talloc_tos(), tmp));
+                unix_timespec_to_nt_time(&tmp, c_time);
+                d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
+                d_printf("size: %d\n", (int)size);
+        }
+
+        TALLOC_FREE(snapshots);
 
         return 0;
@@ -1602 +1807 @@
         SMB_OFF_T start = 0;
         int rc = 0;
-        struct timeval tp_start;
+        struct timespec tp_start;
         struct cli_state *targetcli;
         char *targetname = NULL;
@@ -1613 +1818 @@
         }
 
-        GetTimeOfDay(&tp_start);
+        clock_gettime_mono(&tp_start);
 
         if (reput) {
                 status = cli_open(targetcli, targetname, O_RDWR|O_CREAT, DENY_NONE, &fnum);
                 if (NT_STATUS_IS_OK(status)) {
-                        if (!cli_qfileinfo(targetcli, fnum, NULL, &start, NULL, NULL, NULL, NULL, NULL) &&
-                            !NT_STATUS_IS_OK(cli_getattrE(targetcli, fnum, NULL, &start, NULL, NULL, NULL))) {
-                                d_printf("getattrib: %s\n",cli_errstr(cli));
+                        if (!NT_STATUS_IS_OK(status = cli_qfileinfo_basic(
+                                                     targetcli, fnum, NULL,
+                                                     &start, NULL, NULL,
+                                                     NULL, NULL, NULL)) &&
+                            !NT_STATUS_IS_OK(status = cli_getattrE(
+                                                     targetcli, fnum, NULL,
+                                                     &start, NULL, NULL,
+                                                     NULL))) {
+                                d_printf("getattrib: %s\n", nt_errstr(status));
                                 return 1;
                         }
@@ -1629 +1840 @@
 
         if (!NT_STATUS_IS_OK(status)) {
-                d_printf("%s opening remote file %s\n",cli_errstr(targetcli),rname);
+                d_printf("%s opening remote file %s\n", nt_errstr(status),
+                         rname);
                 return 1;
         }
@@ -1669 +1881 @@
         if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, "cli_push returned %s\n", nt_errstr(status));
-        }
-
-        if (!NT_STATUS_IS_OK(cli_close(targetcli, fnum))) {
-                d_printf("%s closing remote file %s\n",cli_errstr(cli),rname);
+                rc = 1;
+        }
+
+        status = cli_close(targetcli, fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("%s closing remote file %s\n", nt_errstr(status),
+                         rname);
                 if (f != x_stdin) {
                         x_fclose(f);
@@ -1684 +1899 @@
 
         {
-                struct timeval tp_end;
+                struct timespec tp_end;
                 int this_time;
 
-                GetTimeOfDay(&tp_end);
-                this_time =
-                        (tp_end.tv_sec - tp_start.tv_sec)*1000 +
-                        (tp_end.tv_usec - tp_start.tv_usec)/1000;
+                clock_gettime_mono(&tp_end);
+                this_time = nsec_time_diff(&tp_end,&tp_start)/1000000;
                 put_total_time_ms += this_time;
                 put_total_size += state.nread;
@@ -2079 +2292 @@
 ****************************************************************************/
 
-static void do_del(file_info *finfo, const char *dir)
+static NTSTATUS do_del(struct cli_state *cli_state, struct file_info *finfo,
+                   const char *dir)
 {
         TALLOC_CTX *ctx = talloc_tos();
         char *mask = NULL;
+        NTSTATUS status;
 
         mask = talloc_asprintf(ctx,
@@ -2090 +2305 @@
                                 finfo->name);
         if (!mask) {
-                return;
-        }
-
-        if (finfo->mode & aDIR) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
                 TALLOC_FREE(mask);
-                return;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_unlink(finfo->cli, mask, aSYSTEM | aHIDDEN))) {
+                return NT_STATUS_OK;
+        }
+
+        status = cli_unlink(cli_state, mask, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s deleting remote file %s\n",
-                                cli_errstr(finfo->cli),mask);
+                         nt_errstr(status), mask);
         }
         TALLOC_FREE(mask);
+        return status;
 }
 
@@ -2114 +2331 @@
         char *mask = NULL;
         char *buf = NULL;
-        uint16 attribute = aSYSTEM | aHIDDEN;
+        NTSTATUS status = NT_STATUS_OK;
+        uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
 
         if (recurse) {
-                attribute |= aDIR;
+                attribute |= FILE_ATTRIBUTE_DIRECTORY;
         }
 
@@ -2133 +2351 @@
         }
 
-        do_list(mask,attribute,do_del,false,false);
+        status = do_list(mask,attribute,do_del,false,false);
+        if (!NT_STATUS_IS_OK(status)) {
+                return 1;
+        }
         return 0;
 }
@@ -2149 +2370 @@
         struct cli_state *targetcli;
         char *targetname = NULL;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2174 +2396 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_unlink(targetcli, targetname, attribute))) {
-                d_printf("%s deleting remote files %s\n",cli_errstr(targetcli),targetname);
+        status = cli_unlink(targetcli, targetname, attribute);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("%s deleting remote files %s\n", nt_errstr(status),
+                         targetname);
         }
         return 0;
@@ -2533 +2757 @@
         d_printf("Server supports CIFS capabilities %s\n", caps);
 
-        if (!cli_set_unix_extensions_capabilities(cli, major, minor, caplow, caphigh)) {
-                d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n", cli_errstr(cli));
+        status = cli_set_unix_extensions_capabilities(cli, major, minor,
+                                                      caplow, caphigh);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n",
+                         nt_errstr(status));
                 return 1;
         }
@@ -2778 +3005 @@
         char *buf = NULL;
         char *buf2 = NULL;
-        char *targetname = NULL;
-        struct cli_state *targetcli;
+        struct cli_state *newcli;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
@@ -2786 +3012 @@
                 return 1;
         }
-        oldname = talloc_asprintf(ctx,
-                        "%s%s",
-                        client_get_cur_dir(),
-                        buf);
-        if (!oldname) {
-                return 1;
-        }
+        /* Oldname (link target) must be an untouched blob. */
+        oldname = buf;
+
         newname = talloc_asprintf(ctx,
                         "%s%s",
@@ -2801 +3023 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, oldname, &targetcli, &targetname)) {
+        /* New name must be present in share namespace. */
+        if (!cli_resolve_path(ctx, "", auth_info, cli, newname, &newcli, &newname)) {
                 d_printf("link %s: %s\n", oldname, cli_errstr(cli));
                 return 1;
         }
 
-        if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
+        if (!SERVER_HAS_UNIX_CIFS(newcli)) {
                 d_printf("Server doesn't support UNIX CIFS calls.\n");
                 return 1;
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_symlink(targetcli, targetname, newname))) {
+        if (!NT_STATUS_IS_OK(cli_posix_symlink(newcli, oldname, newname))) {
                 d_printf("%s symlinking files (%s -> %s)\n",
-                        cli_errstr(targetcli), newname, targetname);
+                        cli_errstr(newcli), newname, newname);
                 return 1;
         }
@@ -3140 +3363 @@
 }
 
+static void printf_cb(const char *buf, void *private_data)
+{
+        printf("%s", buf);
+}
+
+/****************************************************************************
+ Get the EA list of a file
+****************************************************************************/
+
+static int cmd_geteas(void)
+{
+        TALLOC_CTX *ctx = talloc_tos();
+        char *src = NULL;
+        char *name = NULL;
+        char *targetname = NULL;
+        struct cli_state *targetcli;
+        NTSTATUS status;
+        size_t i, num_eas;
+        struct ea_struct *eas;
+
+        if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
+                d_printf("geteas filename\n");
+                return 1;
+        }
+        src = talloc_asprintf(ctx,
+                        "%s%s",
+                        client_get_cur_dir(),
+                        name);
+        if (!src) {
+                return 1;
+        }
+
+        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                              &targetname)) {
+                d_printf("stat %s: %s\n", src, cli_errstr(cli));
+                return 1;
+        }
+
+        status = cli_get_ea_list_path(targetcli, targetname, talloc_tos(),
+                                      &num_eas, &eas);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("cli_get_ea_list_path: %s\n", nt_errstr(status));
+                return 1;
+        }
+
+        for (i=0; i<num_eas; i++) {
+                d_printf("%s (%d) =\n", eas[i].name, (int)eas[i].flags);
+                dump_data_cb(eas[i].value.data, eas[i].value.length, false,
+                             printf_cb, NULL);
+                d_printf("\n");
+        }
+
+        TALLOC_FREE(eas);
+
+        return 0;
+}
+
+/****************************************************************************
+ Set an EA of a file
+****************************************************************************/
+
+static int cmd_setea(void)
+{
+        TALLOC_CTX *ctx = talloc_tos();
+        char *src = NULL;
+        char *name = NULL;
+        char *eaname = NULL;
+        char *eavalue = NULL;
+        char *targetname = NULL;
+        struct cli_state *targetcli;
+        NTSTATUS status;
+
+        if (!next_token_talloc(ctx, &cmd_ptr, &name, NULL)
+            || !next_token_talloc(ctx, &cmd_ptr, &eaname, NULL)) {
+                d_printf("setea filename eaname value\n");
+                return 1;
+        }
+        if (!next_token_talloc(ctx, &cmd_ptr, &eavalue, NULL)) {
+                eavalue = talloc_strdup(ctx, "");
+        }
+        src = talloc_asprintf(ctx,
+                        "%s%s",
+                        client_get_cur_dir(),
+                        name);
+        if (!src) {
+                return 1;
+        }
+
+        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                              &targetname)) {
+                d_printf("stat %s: %s\n", src, cli_errstr(cli));
+                return 1;
+        }
+
+        status =  cli_set_ea_path(targetcli, targetname, eaname, eavalue,
+                                  strlen(eavalue));
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("set_ea %s: %s\n", src, nt_errstr(status));
+                return 1;
+        }
+
+        return 0;
+}
+
 /****************************************************************************
  UNIX stat.
@@ -3356 +3683 @@
         uint32 serial_num;
         time_t create_date;
-
-        if (!cli_get_fs_volume_info(cli, volname, &serial_num, &create_date)) {
-                d_printf("Errr %s getting volume info\n",cli_errstr(cli));
+        NTSTATUS status;
+
+        status = cli_get_fs_volume_info(cli, volname, &serial_num,
+                                        &create_date);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Error %s getting volume info\n", nt_errstr(status));
                 return 1;
         }
@@ -3685 +4015 @@
         uint32_t total_entries = 0;
         int i;
+        struct dcerpc_binding_handle *b;
 
         status = cli_rpc_pipe_open_noauth(cli, &ndr_table_srvsvc.syntax_id,
@@ -3696 +4027 @@
         }
 
+        b = pipe_hnd->binding_handle;
+
         ZERO_STRUCT(info_ctr);
         ZERO_STRUCT(ctr1);
@@ -3702 +4035 @@
         info_ctr.ctr.ctr1 = &ctr1;
 
-        status = rpccli_srvsvc_NetShareEnumAll(pipe_hnd, frame,
+        status = dcerpc_srvsvc_NetShareEnumAll(b, frame,
                                               pipe_hnd->desthost,
                                               &info_ctr,
@@ -3819 +4152 @@
         TALLOC_CTX *ctx = talloc_tos();
         char *l_username, *l_password;
+        NTSTATUS nt_status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&l_username,NULL)) {
@@ -3835 +4169 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_session_setup(cli, l_username,
-                                               l_password, strlen(l_password),
-                                               l_password, strlen(l_password),
-                                               lp_workgroup()))) {
-                d_printf("session setup failed: %s\n", cli_errstr(cli));
+        nt_status = cli_session_setup(cli, l_username,
+                                      l_password, strlen(l_password),
+                                      l_password, strlen(l_password),
+                                      lp_workgroup());
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                d_printf("session setup failed: %s\n", nt_errstr(nt_status));
                 return -1;
         }
@@ -3919 +4254 @@
 }
 
+/****************************************************************************
+history
+****************************************************************************/
+static int cmd_history(void)
+{
+#if defined(HAVE_LIBREADLINE) && defined(HAVE_HISTORY_LIST)
+        HIST_ENTRY **hlist;
+        int i;
+
+        hlist = history_list();
+
+        for (i = 0; hlist && hlist[i]; i++) {
+                DEBUG(0, ("%d: %s\n", i, hlist[i]->line));
+        }
+#else
+        DEBUG(0,("no history without readline support\n"));
+#endif
+
+        return 0;
+}
 
 /* Some constants for completing filename arguments */
@@ -3956 +4311 @@
   {"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},
   {"getfacl",cmd_getfacl,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE,COMPL_LOCAL}},
+  {"geteas", cmd_geteas, "<file name> get the EA list of a file",
+   {COMPL_REMOTE, COMPL_LOCAL}},
   {"hardlink",cmd_hardlink,"<src> <dest> create a Windows hard link",{COMPL_REMOTE,COMPL_REMOTE}},
   {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
@@ -3996 +4353 @@
   {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
   {"showacls",cmd_showacls,"toggle if ACLs are shown or not",{COMPL_NONE,COMPL_NONE}},  
+  {"setea", cmd_setea, "<file name> <eaname> <eaval> Set an EA of a file",
+   {COMPL_REMOTE, COMPL_LOCAL}},
   {"setmode",cmd_setmode,"filename <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},
   {"stat",cmd_stat,"filename Do a UNIX extensions stat call on a file",{COMPL_REMOTE,COMPL_REMOTE}},
@@ -4134 +4493 @@
 #define MAX_COMPLETIONS 100
 
-typedef struct {
+struct completion_remote {
         char *dirmask;
         char **matches;
@@ -4140 +4499 @@
         const char *text;
         int len;
-} completion_remote_t;
-
-static void completion_remote_filter(const char *mnt,
-                                file_info *f,
+};
+
+static NTSTATUS completion_remote_filter(const char *mnt,
+                                struct file_info *f,
                                 const char *mask,
                                 void *state)
 {
-        completion_remote_t *info = (completion_remote_t *)state;
-
-        if ((info->count < MAX_COMPLETIONS - 1) &&
-                        (strncmp(info->text, f->name, info->len) == 0) &&
-                        (strcmp(f->name, ".") != 0) &&
-                        (strcmp(f->name, "..") != 0)) {
-                if ((info->dirmask[0] == 0) && !(f->mode & aDIR))
-                        info->matches[info->count] = SMB_STRDUP(f->name);
-                else {
-                        TALLOC_CTX *ctx = talloc_stackframe();
-                        char *tmp;
-
-                        tmp = talloc_strdup(ctx,info->dirmask);
-                        if (!tmp) {
-                                TALLOC_FREE(ctx);
-                                return;
-                        }
-                        tmp = talloc_asprintf_append(tmp, "%s", f->name);
-                        if (!tmp) {
-                                TALLOC_FREE(ctx);
-                                return;
-                        }
-                        if (f->mode & aDIR) {
-                                tmp = talloc_asprintf_append(tmp, "%s", CLI_DIRSEP_STR);
-                        }
-                        if (!tmp) {
-                                TALLOC_FREE(ctx);
-                                return;
-                        }
-                        info->matches[info->count] = SMB_STRDUP(tmp);
+        struct completion_remote *info = (struct completion_remote *)state;
+
+        if (info->count >= MAX_COMPLETIONS - 1) {
+                return NT_STATUS_OK;
+        }
+        if (strncmp(info->text, f->name, info->len) != 0) {
+                return NT_STATUS_OK;
+        }
+        if (ISDOT(f->name) || ISDOTDOT(f->name)) {
+                return NT_STATUS_OK;
+        }
+
+        if ((info->dirmask[0] == 0) && !(f->mode & FILE_ATTRIBUTE_DIRECTORY))
+                info->matches[info->count] = SMB_STRDUP(f->name);
+        else {
+                TALLOC_CTX *ctx = talloc_stackframe();
+                char *tmp;
+
+                tmp = talloc_strdup(ctx,info->dirmask);
+                if (!tmp) {
                         TALLOC_FREE(ctx);
-                }
-                if (info->matches[info->count] == NULL) {
-                        return;
-                }
-                if (f->mode & aDIR) {
-                        smb_readline_ca_char(0);
-                }
-                if (info->count == 1) {
-                        info->samelen = strlen(info->matches[info->count]);
-                } else {
-                        while (strncmp(info->matches[info->count],
-                                                info->matches[info->count-1],
-                                                info->samelen) != 0) {
-                                info->samelen--;
-                        }
-                }
-                info->count++;
-        }
+                        return NT_STATUS_NO_MEMORY;
+                }
+                tmp = talloc_asprintf_append(tmp, "%s", f->name);
+                if (!tmp) {
+                        TALLOC_FREE(ctx);
+                        return NT_STATUS_NO_MEMORY;
+                }
+                if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
+                        tmp = talloc_asprintf_append(tmp, "%s",
+                                                     CLI_DIRSEP_STR);
+                }
+                if (!tmp) {
+                        TALLOC_FREE(ctx);
+                        return NT_STATUS_NO_MEMORY;
+                }
+                info->matches[info->count] = SMB_STRDUP(tmp);
+                TALLOC_FREE(ctx);
+        }
+        if (info->matches[info->count] == NULL) {
+                return NT_STATUS_OK;
+        }
+        if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
+                smb_readline_ca_char(0);
+        }
+        if (info->count == 1) {
+                info->samelen = strlen(info->matches[info->count]);
+        } else {
+                while (strncmp(info->matches[info->count],
+                               info->matches[info->count-1],
+                               info->samelen) != 0) {
+                        info->samelen--;
+                }
+        }
+        info->count++;
+        return NT_STATUS_OK;
 }
 
@@ -4205 +4571 @@
         struct cli_state *targetcli = NULL;
         int i;
-        completion_remote_t info = { NULL, NULL, 1, 0, NULL, 0 };
-
-        /* can't have non-static intialisation on Sun CC, so do it
+        struct completion_remote info = { NULL, NULL, 1, 0, NULL, 0 };
+        NTSTATUS status;
+
+        /* can't have non-static initialisation on Sun CC, so do it
            at run time here */
         info.samelen = len;
@@ -4264 +4631 @@
                 goto cleanup;
         }
-        if (cli_list(targetcli, targetpath, aDIR | aSYSTEM | aHIDDEN,
-                                completion_remote_filter, (void *)&info) < 0) {
+        status = cli_list(targetcli, targetpath, FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
+                          completion_remote_filter, (void *)&info);
+        if (!NT_STATUS_IS_OK(status)) {
                 goto cleanup;
         }
@@ -4407 +4775 @@
 static void readline_callback(void)
 {
-        fd_set fds;
-        struct timeval timeout;
         static time_t last_t;
+        struct timespec now;
         time_t t;
-
-        t = time(NULL);
+        int ret, revents;
+
+        clock_gettime_mono(&now);
+        t = now.tv_sec;
 
         if (t - last_t < 5)
@@ -4421 +4790 @@
  again:
 
-        if (cli->fd < 0 || cli->fd >= FD_SETSIZE) {
-                errno = EBADF;
+        if (cli->fd == -1)
                 return;
-        }
-
-        FD_ZERO(&fds);
-        FD_SET(cli->fd,&fds);
-
-        timeout.tv_sec = 0;
-        timeout.tv_usec = 0;
-        sys_select_intr(cli->fd+1,&fds,NULL,NULL,&timeout);
 
         /* We deliberately use receive_smb_raw instead of
@@ -4437 +4797 @@
            session keepalives and then drop them here.
         */
-        if (FD_ISSET(cli->fd,&fds)) {
+
+        ret = poll_intr_one_fd(cli->fd, POLLIN|POLLHUP, 0, &revents);
+
+        if ((ret > 0) && (revents & (POLLIN|POLLHUP|POLLERR))) {
                 NTSTATUS status;
                 size_t len;
@@ -4591 +4954 @@
 {
         cli = cli_cm_open(talloc_tos(), NULL,
-                        query_host, "IPC$", auth_info, true, smb_encrypt,
+                        have_ip ? dest_ss_str : query_host, "IPC$", auth_info, true, smb_encrypt,
                         max_protocol, port, name_type);
         if (!cli)
@@ -4617 +4980 @@
                 cli_shutdown(cli);
                 cli = cli_cm_open(talloc_tos(), NULL,
-                                query_host, "IPC$", auth_info, true, smb_encrypt,
+                                have_ip ? dest_ss_str : query_host, "IPC$",
+                                auth_info, true, smb_encrypt,
                                 max_protocol, 139, name_type);
         }
@@ -4771 +5135 @@
 
         /* set default debug level to 1 regardless of what smb.conf sets */
-        setup_logging( "smbclient", true );
-        DEBUGLEVEL_CLASS[DBGC_ALL] = 1;
-        if ((dbf = x_fdup(x_stderr))) {
-                x_setbuf( dbf, NULL );
-        }
-
+        setup_logging( "smbclient", DEBUG_DEFAULT_STDERR );
         load_case_tables();
+
+        lp_set_cmdline("log level", "1");
 
         auth_info = user_auth_info_init(frame);
@@ -4844 +5205 @@
                         break;
                 case 'E':
-                        if (dbf) {
-                                x_fclose(dbf);
-                        }
-                        dbf = x_stderr;
+                        setup_logging("smbclient", DEBUG_STDERR );
                         display_set_stderr();
                         break;
@@ -4921 +5279 @@
         }
 
-        /*
-         * Don't load debug level from smb.conf. It should be
-         * set by cmdline arg or remain default (0)
-         */
-        AllowDebugChange = false;
-
         /* save the workgroup...
 
@@ -4940 +5292 @@
 
         if ( override_logfile )
-                setup_logging( lp_logfile(), false );
+                setup_logging( lp_logfile(), DEBUG_FILE );
 
         if (!lp_load(get_dyn_CONFIGFILE(),true,false,false,true)) {

vendor/current/source3/client/client_proto.h

@@ -24 +24 @@
 #define _CLIENT_PROTO_H_
 
+struct cli_state;
+struct file_info;
 
 /* The following definitions come from client/client.c  */
@@ -29 +31 @@
 const char *client_get_cur_dir(void);
 const char *client_set_cur_dir(const char *newdir);
-void do_list(const char *mask,
+NTSTATUS do_list(const char *mask,
                         uint16 attribute,
-                        void (*fn)(file_info *, const char *dir),
+                        NTSTATUS (*fn)(struct cli_state *cli_state, struct file_info *,
+                                   const char *dir),
                         bool rec,
                         bool dirs);

vendor/current/source3/client/clitar.c

@@ -36 +36 @@
 
 #include "includes.h"
+#include "system/filesys.h"
 #include "clitar.h"
 #include "client/client_proto.h"
+#include "libsmb/libsmb.h"
 
 static int clipfind(char **aret, int ret, char *tok);
@@ -70 +72 @@
 #define ATTRRESET 0
 
-static uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
+static uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
 
 #ifndef CLIENT_TIMEOUT
@@ -115 +117 @@
 static void writetarheader(int f,  const char *aname, uint64_t size, time_t mtime,
                            const char *amode, unsigned char ftype);
-static void do_atar(const char *rname_in,char *lname,file_info *finfo1);
-static void do_tar(file_info *finfo, const char *dir);
+static NTSTATUS do_atar(const char *rname_in, char *lname,
+                    struct file_info *finfo1);
+static NTSTATUS do_tar(struct cli_state *cli_state, struct file_info *finfo,
+                   const char *dir);
 static void oct_it(uint64_t value, int ndgs, char *p);
 static void fixtarname(char *tptr, const char *fp, size_t l);
@@ -292 +296 @@
         if ((unoct(hb->dbuf.mode, sizeof(hb->dbuf.mode)) & S_IFDIR) ||
                                 (*(finfo->name+strlen(finfo->name)-1) == '\\')) {
-                finfo->mode=aDIR;
+                finfo->mode=FILE_ATTRIBUTE_DIRECTORY;
         } else {
                 finfo->mode=0; /* we don't care about mode at the moment, we'll
@@ -487 +491 @@
         char *s1_0=s1;
 
-        while(*s1 && *s2 && (*s1 == *s2 || tolower_ascii(*s1) == tolower_ascii(*s2) ||
+        while(*s1 && *s2 && (*s1 == *s2 || tolower_m(*s1) == tolower_m(*s2) ||
                                 (*s1 == '\\' && *s2=='/') || (*s1 == '/' && *s2=='\\'))) {
                 s1++; s2++;
@@ -614 +618 @@
 ***************************************************************************/
 
-static void do_atar(const char *rname_in,char *lname,file_info *finfo1)
+static NTSTATUS do_atar(const char *rname_in, char *lname,
+                    struct file_info *finfo1)
 {
         uint16_t fnum = (uint16_t)-1;
@@ -626 +631 @@
         char *rname = NULL;
         TALLOC_CTX *ctx = talloc_stackframe();
-
-        struct timeval tp_start;
-
-        GetTimeOfDay(&tp_start);
+        NTSTATUS status = NT_STATUS_OK;
+        struct timespec tp_start;
+
+        clock_gettime_mono(&tp_start);
 
         data = SMB_MALLOC_ARRAY(char, read_size);
         if (!data) {
                 DEBUG(0,("do_atar: out of memory.\n"));
+                status = NT_STATUS_NO_MEMORY;
                 goto cleanup;
         }
@@ -660 +666 @@
         rname = clean_name(ctx, rname_in);
         if (!rname) {
+                status = NT_STATUS_NO_MEMORY;
                 goto cleanup;
         }
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, rname, O_RDONLY, DENY_NONE, &fnum))) {
+        status = cli_open(cli, rname, O_RDONLY, DENY_NONE, &fnum);
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("%s opening remote file %s (%s)\n",
                                 cli_errstr(cli),rname, client_get_cur_dir()));
@@ -672 +680 @@
         if (finfo.name == NULL) {
                 DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n"));
+                status = NT_STATUS_NO_MEMORY;
                 goto cleanup;
         }
@@ -679 +688 @@
         DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
 
-        if (tar_inc && !(finfo.mode & aARCH)) {
+        if (tar_inc && !(finfo.mode & FILE_ATTRIBUTE_ARCHIVE)) {
                 DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name));
                 shallitime=0;
-        } else if (!tar_system && (finfo.mode & aSYSTEM)) {
+        } else if (!tar_system && (finfo.mode & FILE_ATTRIBUTE_SYSTEM)) {
                 DEBUG(4, ("skipping %s - system bit is set\n", finfo.name));
                 shallitime=0;
-        } else if (!tar_hidden && (finfo.mode & aHIDDEN)) {
+        } else if (!tar_hidden && (finfo.mode & FILE_ATTRIBUTE_HIDDEN)) {
                 DEBUG(4, ("skipping %s - hidden bit is set\n", finfo.name));
                 shallitime=0;
@@ -702 +711 @@
                         if (datalen == -1) {
                                 DEBUG(0,("Error reading file %s : %s\n", rname, cli_errstr(cli)));
+                                status = cli_nt_error(cli);
                                 break;
                         }
@@ -730 +740 @@
                         if (dotarbuf(tarhandle,data,datalen) != datalen) {
                                 DEBUG(0,("Error writing to tar file - %s\n", strerror(errno)));
+                                status = map_nt_error_from_unix(errno);
                                 break;
                         }
 
                         if ( (datalen == 0) && (finfo.size != 0) ) {
+                                status = NT_STATUS_UNSUCCESSFUL;
                                 DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
                                 break;
@@ -746 +758 @@
                                 DEBUG(0, ("Didn't get entire file. size=%.0f, nread=%d\n",
                                                         (double)finfo.size, (int)nread));
-                                if (padit(data, (uint64_t)sizeof(data), finfo.size - nread))
+                                if (padit(data, (uint64_t)sizeof(data), finfo.size - nread)) {
+                                        status = map_nt_error_from_unix(errno);
                                         DEBUG(0,("Error writing tar file - %s\n", strerror(errno)));
+                                }
                         }
 
@@ -759 +773 @@
                         DEBUG(4, ("skipping %s - initial read failed (file was locked ?)\n", finfo.name));
                         shallitime=0;
+                        status = NT_STATUS_UNSUCCESSFUL;
                 }
         }
@@ -766 +781 @@
 
         if (shallitime) {
-                struct timeval tp_end;
+                struct timespec tp_end;
                 int this_time;
 
                 /* if shallitime is true then we didn't skip */
                 if (tar_reset && !dry_run)
-                        (void) do_setrattr(finfo.name, aARCH, ATTRRESET);
-
-                GetTimeOfDay(&tp_end);
-                this_time = (tp_end.tv_sec - tp_start.tv_sec)*1000 + (tp_end.tv_usec - tp_start.tv_usec)/1000;
+                        (void) do_setrattr(finfo.name, FILE_ATTRIBUTE_ARCHIVE, ATTRRESET);
+
+                clock_gettime_mono(&tp_end);
+                this_time = (tp_end.tv_sec - tp_start.tv_sec)*1000 + (tp_end.tv_nsec - tp_start.tv_nsec)/1000000;
                 get_total_time_ms += this_time;
                 get_total_size += finfo.size;
@@ -798 +813 @@
         TALLOC_FREE(ctx);
         SAFE_FREE(data);
+        return status;
 }
 
@@ -804 +820 @@
 ***************************************************************************/
 
-static void do_tar(file_info *finfo, const char *dir)
+static NTSTATUS do_tar(struct cli_state *cli_state, struct file_info *finfo,
+                   const char *dir)
 {
         TALLOC_CTX *ctx = talloc_stackframe();
+        NTSTATUS status = NT_STATUS_OK;
 
         if (strequal(finfo->name,"..") || strequal(finfo->name,"."))
-                return;
+                return NT_STATUS_OK;
 
         /* Is it on the exclude list ? */
@@ -822 +840 @@
                                 finfo->name);
                 if (!exclaim) {
-                        return;
+                        return NT_STATUS_NO_MEMORY;
                 }
 
@@ -831 +849 @@
                         DEBUG(3,("Skipping file %s\n", exclaim));
                         TALLOC_FREE(exclaim);
-                        return;
+                        return NT_STATUS_OK;
                 }
                 TALLOC_FREE(exclaim);
         }
 
-        if (finfo->mode & aDIR) {
+        if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
                 char *saved_curdir = NULL;
                 char *new_cd = NULL;
@@ -843 +861 @@
                 saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
                 if (!saved_curdir) {
-                        return;
+                        return NT_STATUS_NO_MEMORY;
                 }
 
@@ -856 +874 @@
                                 finfo->name);
                 if (!new_cd) {
-                        return;
+                        return NT_STATUS_NO_MEMORY;
                 }
                 client_set_cur_dir(new_cd);
@@ -875 +893 @@
                                 client_get_cur_dir());
                 if (!mtar_mask) {
-                        return;
+                        return NT_STATUS_NO_MEMORY;
                 }
                 DEBUG(5, ("Doing list with mtar_mask: %s\n", mtar_mask));
-                do_list(mtar_mask, attribute, do_tar, False, True);
+                status = do_list(mtar_mask, attribute, do_tar, False, True);
                 client_set_cur_dir(saved_curdir);
                 TALLOC_FREE(saved_curdir);
@@ -889 +907 @@
                                         finfo->name);
                 if (!rname) {
-                        return;
-                }
-                do_atar(rname,finfo->name,finfo);
+                        return NT_STATUS_NO_MEMORY;
+                }
+                status = do_atar(rname,finfo->name,finfo);
                 TALLOC_FREE(rname);
         }
+        return status;
 }
 
@@ -999 +1018 @@
 static int get_file(file_info2 finfo)
 {
-        uint16_t fnum;
+        uint16_t fnum = (uint16_t) -1;
         int pos = 0, dsize = 0, bpos = 0;
         uint64_t rsize = 0;
+        NTSTATUS status;
 
         DEBUG(5, ("get_file: file: %s, size %.0f\n", finfo.name, (double)finfo.size));
 
-        if (ensurepath(finfo.name) &&
-                        (!NT_STATUS_IS_OK(cli_open(cli, finfo.name, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE,&fnum)))) {
+        if (!ensurepath(finfo.name)) {
                 DEBUG(0, ("abandoning restore\n"));
-                return(False);
+                return False;
+        }
+
+        status = cli_open(cli, finfo.name, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("abandoning restore\n"));
+                return False;
         }
 
@@ -1022 +1047 @@
                 DEBUG(5, ("writing %i bytes, bpos = %i ...\n", dsize, bpos));
 
-                if (cli_write(cli, fnum, 0, buffer_p + bpos, pos, dsize) != dsize) {
-                        DEBUG(0, ("Error writing remote file\n"));
+                status = cli_writeall(cli, fnum, 0,
+                                      (uint8_t *)(buffer_p + bpos), pos,
+                                      dsize, NULL);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("Error writing remote file: %s\n",
+                                  nt_errstr(status)));
                         return 0;
                 }
@@ -1156 +1185 @@
 {
         file_info2 finfo;
-        struct timeval tp_start;
+        struct timespec tp_start;
         char *longfilename = NULL, linkflag;
         int skip = False;
@@ -1162 +1191 @@
         ZERO_STRUCT(finfo);
 
-        GetTimeOfDay(&tp_start);
+        clock_gettime_mono(&tp_start);
         DEBUG(5, ("RJS do_tarput called ...\n"));
 
@@ -1184 +1213 @@
                                 if ((next_block(tarbuf, &buffer_p, tbufsiz) <= 0) && !skip_file(finfo.size)) {
                                         DEBUG(0, ("Short file, bailing out...\n"));
+                                        SAFE_FREE(longfilename);
                                         return;
                                 }
@@ -1190 +1220 @@
                         case -1:
                                 DEBUG(0, ("abandoning restore, -1 from read tar header\n"));
+                                SAFE_FREE(longfilename);
                                 return;
 
                         case 0: /* chksum is zero - looks like an EOF */
                                 DEBUG(0, ("tar: restored %d files and directories\n", ntarf));
+                                SAFE_FREE(longfilename);
                                 return;        /* Hmmm, bad here ... */
 
@@ -1375 +1407 @@
                                         break;
                                 case 'r':
-                                        attra[direct]|=aRONLY;
+                                        attra[direct]|=FILE_ATTRIBUTE_READONLY;
                                         break;
                                 case 'h':
-                                        attra[direct]|=aHIDDEN;
+                                        attra[direct]|=FILE_ATTRIBUTE_HIDDEN;
                                         break;
                                 case 's':
-                                        attra[direct]|=aSYSTEM;
+                                        attra[direct]|=FILE_ATTRIBUTE_SYSTEM;
                                         break;
                                 case 'a':
-                                        attra[direct]|=aARCH;
+                                        attra[direct]|=FILE_ATTRIBUTE_ARCHIVE;
                                         break;
                                 default:
@@ -1924 +1956 @@
                  */
                 if (tarhandle == 1)  {
-                        dbf = x_stderr;
+                        setup_logging("smbclient", DEBUG_STDERR);
                 }
                 if (!argv[Optind]) {

vendor/current/source3/client/dnsbrowse.c

@@ -24 +24 @@
 
 #include <dns_sd.h>
+#include "system/select.h"
 
 /* Holds service instances found during DNS browse */
@@ -61 +62 @@
         int fdsetsz;
         int ret;
-        fd_set *fdset = NULL;
         struct timeval tv;
         DNSServiceErrorType err;
@@ -78 +78 @@
         mdnsfd = DNSServiceRefSockFD(mdns_conn_sdref);
         for (;;)  {
-                if (fdset != NULL) {
-                        TALLOC_FREE(fdset);
-                }
-
-                if (mdnsfd < 0 || mdnsfd >= FD_SETSIZE) {
-                        errno = EBADF;
-                        break;
-                }
-
-                fdsetsz = howmany(mdnsfd + 1, NFDBITS) * sizeof(fd_mask);
-                fdset = TALLOC_ZERO(ctx, fdsetsz);
-                FD_SET(mdnsfd, fdset);
-
-                tv.tv_sec = 1;
-                tv.tv_usec = 0;
-
-                /* Wait until response received from mDNS daemon */
-                ret = sys_select(mdnsfd + 1, fdset, NULL, NULL, &tv);
+                int revents;
+
+                ret = poll_one_fd(mdnsfd, POLLIN|POLLHUP, 1000, &revents);
                 if (ret <= 0 && errno != EINTR) {
                         break;
                 }
 
-                if (FD_ISSET(mdnsfd, fdset)) {
+                if (revents & (POLLIN|POLLHUP|POLLERR)) {
                         /* Invoke callback function */
                         DNSServiceProcessResult(mdns_conn_sdref);
@@ -161 +146 @@
         int fdsetsz;
         int ret;
-        fd_set *fdset = NULL;
         struct mdns_browse_state bstate;
         struct mdns_smbsrv_result *resptr;
@@ -183 +167 @@
         mdnsfd = DNSServiceRefSockFD(mdns_conn_sdref);
         for (;;)  {
-                if (fdset != NULL) {
-                        TALLOC_FREE(fdset);
-                }
-
-                if (mdnsfd < 0 || mdnsfd >= FD_SETSIZE) {
-                        errno = EBADF;
-                        TALLOC_FREE(ctx);
-                        return 1;
-                }
-
-                fdsetsz = howmany(mdnsfd + 1, NFDBITS) * sizeof(fd_mask);
-                fdset = TALLOC_ZERO(ctx, fdsetsz);
-                FD_SET(mdnsfd, fdset);
-
-                tv.tv_sec = 1;
-                tv.tv_usec = 0;
-
-                /* Wait until response received from mDNS daemon */
-                ret = sys_select(mdnsfd + 1, fdset, NULL, NULL, &tv);
+                int revents;
+
+                ret = poll_one_fd(mdnsfd, POLLIN|POLLHUP, &revents, 1000);
                 if (ret <= 0 && errno != EINTR) {
                         break;
                 }
 
-                if (FD_ISSET(mdnsfd, fdset)) {
+                if (revents & (POLLIN|POLLHUP|POLLERR)) {
                         /* Invoke callback function */
                         if (DNSServiceProcessResult(mdns_conn_sdref)) {

vendor/current/source3/client/smbspool.c

@@ -24 +24 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "system/passwd.h"
+#include "libsmb/libsmb.h"
 
 /*
@@ -241 +244 @@
          */
 
-        setup_logging("smbspool", True);
+        setup_logging("smbspool", DEBUG_STDOUT);
 
         lp_set_in_client(True); /* Make sure that we tell lp_load we are */
@@ -402 +405 @@
         *need_auth = false;
         nt_status = cli_start_connection(&cli, myname, server, NULL, port,
-                                         Undefined, flags, NULL);
+                                         Undefined, flags);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 fprintf(stderr, "ERROR: Connection failed: %s\n", nt_errstr(nt_status));
@@ -559 +562 @@
         char            buffer[8192],   /* Buffer for copy */
                        *ptr;    /* Pointer into title */
+        NTSTATUS nt_status;
 
 
@@ -575 +579 @@
          */
 
-        if (!NT_STATUS_IS_OK(cli_open(cli, title, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum))) {
+        nt_status = cli_open(cli, title, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE,
+                          &fnum);
+        if (!NT_STATUS_IS_OK(nt_status)) {
                 fprintf(stderr, "ERROR: %s opening remote spool %s\n",
-                        cli_errstr(cli), title);
-                return (get_exit_code(cli, cli_nt_error(cli)));
+                        nt_errstr(nt_status), title);
+                return get_exit_code(cli, nt_status);
         }
 
@@ -591 +597 @@
 
         while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
-                if (cli_write(cli, fnum, 0, buffer, tbytes, nbytes) != nbytes) {
-                        int status = get_exit_code(cli, cli_nt_error(cli));
-
-                        fprintf(stderr, "ERROR: Error writing spool: %s\n", cli_errstr(cli));
-                        fprintf(stderr, "DEBUG: Returning status %d...\n", status);
+                NTSTATUS status;
+
+                status = cli_writeall(cli, fnum, 0, (uint8_t *)buffer,
+                                      tbytes, nbytes, NULL);
+                if (!NT_STATUS_IS_OK(status)) {
+                        int ret = get_exit_code(cli, status);
+                        fprintf(stderr, "ERROR: Error writing spool: %s\n",
+                                nt_errstr(status));
+                        fprintf(stderr, "DEBUG: Returning status %d...\n",
+                                ret);
                         cli_close(cli, fnum);
 
-                        return (status);
+                        return (ret);
                 }
                 tbytes += nbytes;
         }
 
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum))) {
+        nt_status = cli_close(cli, fnum);
+        if (!NT_STATUS_IS_OK(nt_status)) {
                 fprintf(stderr, "ERROR: %s closing remote spool %s\n",
-                        cli_errstr(cli), title);
-                return (get_exit_code(cli, cli_nt_error(cli)));
+                        nt_errstr(nt_status), title);
+                return get_exit_code(cli, nt_status);
         } else {
                 return (0);