Changeset 988 for vendor/current/source3/client

Timestamp:

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

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source3/client

Files:

• README.smbspool (added)
• client.c (modified) (159 diffs)
• client_proto.h (modified) (2 diffs)
• clitar.c (modified) (2 diffs)
• clitar_proto.h (added)
• dnsbrowse.c (modified) (2 diffs)
• smbspool.c (modified) (5 diffs)
• smbspool_krb5_wrapper.c (added)
• tree.c (modified) (2 diffs)

vendor/current/source3/client/client.c

@@ -27 +27 @@
 #include "rpc_client/cli_pipe.h"
 #include "client/client_proto.h"
+#include "client/clitar_proto.h"
 #include "../librpc/gen_ndr/ndr_srvsvc_c.h"
 #include "../lib/util/select.h"
@@ -37 +38 @@
 #include "trans2.h"
 #include "libsmb/nmblib.h"
+#include "include/ntioctl.h"
+#include "../libcli/smb/smbXcli_base.h"
 
 #ifndef REGISTER
@@ -45 +48 @@
 
 extern bool override_logfile;
-extern char tar_type;
 
 static int port = 0;
 static char *service;
 static char *desthost;
-static char *calling_name;
 static bool grepable = false;
 static char *cmdstr = NULL;
 const char *cmd_ptr = NULL;
 
-static int io_bufsize = 524288;
+static int io_bufsize = 0; /* we use the default size */
+static int io_timeout = (CLIENT_TIMEOUT/1000); /* Per operation timeout (in seconds). */
 
 static int name_type = 0x20;
-static int max_protocol = PROTOCOL_NT1;
+static int max_protocol = -1;
 
 static int process_tok(char *tok);
@@ -65 +67 @@
 #define CREATE_ACCESS_READ READ_CONTROL_ACCESS
 
-/* 30 second timeout on most commands */
-#define CLIENT_TIMEOUT (30*1000)
-#define SHORT_TIMEOUT (5*1000)
-
 /* value for unused fid field in trans2 secondary request */
 #define FID_UNUSED (0xFFFF)
@@ -77 +75 @@
 static bool translation = false;
 static bool have_ip;
-
-/* clitar bits insert */
-extern int blocksize;
-extern bool tar_inc;
-extern bool tar_reset;
-/* clitar bits end */
 
 static bool prompt = true;
@@ -89 +81 @@
 static bool showacls = false;
 bool lowercase = false;
+static bool backup_intent = false;
 
 static struct sockaddr_storage dest_ss;
@@ -234 +227 @@
 
         i = 0;
-        while (i < (n - 1) && (i < BUFFER_SIZE)) {
+        while (i < (n - 1)) {
                 if ((c = x_getc(f)) == EOF) {
                         break;
@@ -251 +244 @@
 struct push_state {
         XFILE *f;
-        SMB_OFF_T nread;
+        off_t nread;
 };
 
@@ -306 +299 @@
 static int do_dskattr(void)
 {
-        int total, bsize, avail;
+        uint64_t total, bsize, avail;
         struct cli_state *targetcli = NULL;
         char *targetpath = NULL;
@@ -312 +305 @@
         NTSTATUS status;
 
-        if ( !cli_resolve_path(ctx, "", auth_info, cli, client_get_cur_dir(), &targetcli, &targetpath)) {
-                d_printf("Error in dskattr: %s\n", cli_errstr(cli));
-                return 1;
-        }
-
-        status = cli_dskattr(targetcli, &bsize, &total, &avail);
+        status = cli_resolve_path(ctx, "", auth_info, cli,
+                                  client_get_cur_dir(), &targetcli,
+                                  &targetpath);
         if (!NT_STATUS_IS_OK(status)) {
                 d_printf("Error in dskattr: %s\n", nt_errstr(status));
@@ -323 +313 @@
         }
 
-        d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
-                 total, bsize, avail);
+        status = cli_disk_size(targetcli, targetpath, &bsize, &total, &avail);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Error in dskattr: %s\n", nt_errstr(status));
+                return 1;
+        }
+
+        d_printf("\n\t\t%" PRIu64
+                " blocks of size %" PRIu64
+                ". %" PRIu64 " blocks available\n",
+                total, bsize, avail);
 
         return 0;
@@ -363 +361 @@
         struct cli_state *targetcli = NULL;
         SMB_STRUCT_STAT sbuf;
-        uint32 attributes;
+        uint32_t attributes;
         int ret = 1;
         TALLOC_CTX *ctx = talloc_stackframe();
+        NTSTATUS status;
 
         newdir = talloc_strdup(ctx, new_dir);
@@ -407 +406 @@
         client_set_cur_dir(new_cd);
 
-        if ( !cli_resolve_path(ctx, "", auth_info, cli, new_cd, &targetcli, &targetpath)) {
-                d_printf("cd %s: %s\n", new_cd, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, new_cd,
+                                  &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;
@@ -421 +422 @@
            Except Win9x doesn't support the qpathinfo_basic() call..... */
 
-        if (targetcli->protocol > PROTOCOL_LANMAN2 && !targetcli->win95) {
-                NTSTATUS status;
+        if (smbXcli_conn_protocol(targetcli->conn) > PROTOCOL_LANMAN2 && !targetcli->win95) {
 
                 status = cli_qpathinfo_basic(targetcli, targetpath, &sbuf,
@@ -438 +438 @@
                 }
         } else {
-                NTSTATUS status;
 
                 targetpath = talloc_asprintf(ctx,
@@ -549 +548 @@
                 d_printf("  %-30s%7.7s %8.0f  %s",
                          finfo->name,
-                         attrib_string(finfo->mode),
+                         attrib_string(talloc_tos(), finfo->mode),
                         (double)finfo->size,
                         time_to_asc(t));
@@ -571 +570 @@
                 /* print file meta date header */
                 d_printf( "FILENAME:%s\n", finfo->name);
-                d_printf( "MODE:%s\n", attrib_string(finfo->mode));
+                d_printf( "MODE:%s\n", attrib_string(talloc_tos(), finfo->mode));
                 d_printf( "SIZE:%.0f\n", (double)finfo->size);
                 d_printf( "MTIME:%s", time_to_asc(t));
@@ -577 +576 @@
                                       CREATE_ACCESS_READ, 0,
                                       FILE_SHARE_READ|FILE_SHARE_WRITE,
-                                      FILE_OPEN, 0x0, 0x0, &fnum);
+                                      FILE_OPEN, 0x0, 0x0, &fnum, NULL);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
@@ -583 +582 @@
                 } else {
                         struct security_descriptor *sd = NULL;
-                        sd = cli_query_secdesc(cli_state, fnum, ctx);
-                        if (!sd) {
+                        status = cli_query_secdesc(cli_state, fnum,
+                                                   ctx, &sd);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 DEBUG( 0, ("display_finfo() failed to "
-                                        "get security descriptor: %s",
-                                        cli_errstr(cli_state)));
-                                status = cli_nt_error(cli_state);
+                                           "get security descriptor: %s",
+                                           nt_errstr(status)));
                         } else {
                                 display_sec_desc(sd);
@@ -704 +703 @@
         }
         if (do_list_queue) {
-                safe_strcpy_base(do_list_queue + do_list_queue_end,
+                strlcpy_base(do_list_queue + do_list_queue_end,
                                  entry, do_list_queue, do_list_queue_size);
                 do_list_queue_end = new_end;
@@ -815 +814 @@
 
 NTSTATUS do_list(const char *mask,
-                        uint16 attribute,
+                        uint16_t attribute,
                         NTSTATUS (*fn)(struct cli_state *cli_state, struct file_info *,
                                    const char *dir),
@@ -859 +858 @@
                         /* check for dfs */
 
-                        if ( !cli_resolve_path(ctx, "", auth_info, cli, head, &targetcli, &targetpath ) ) {
-                                d_printf("do_list: [%s] %s\n", head, cli_errstr(cli));
+                        status = cli_resolve_path(ctx, "", auth_info, cli,
+                                                  head, &targetcli,
+                                                  &targetpath);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                d_printf("do_list: [%s] %s\n", head,
+                                         nt_errstr(status));
                                 remove_do_list_queue_head();
                                 continue;
@@ -898 +901 @@
         } else {
                 /* check for dfs */
-                if (cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetpath)) {
-
+                status = cli_resolve_path(ctx, "", auth_info, cli, mask,
+                                          &targetcli, &targetpath);
+                if (NT_STATUS_IS_OK(status)) {
                         status = cli_list(targetcli, targetpath, attribute,
                                           do_list_helper, targetcli);
@@ -909 +913 @@
                         TALLOC_FREE(targetpath);
                 } else {
-                        d_printf("do_list: [%s] %s\n", mask, cli_errstr(cli));
-                        ret_status = cli_nt_error(cli);
+                        d_printf("do_list: [%s] %s\n", mask, nt_errstr(status));
+                        ret_status = status;
                 }
         }
@@ -926 +930 @@
 {
         TALLOC_CTX *ctx = talloc_tos();
-        uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+        uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
         char *mask = NULL;
         char *buf = NULL;
@@ -976 +980 @@
 {
         TALLOC_CTX *ctx = talloc_tos();
-        uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+        uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
         char *mask = NULL;
         char *buf = NULL;
@@ -1060 +1064 @@
         bool newhandle = false;
         struct timespec tp_start;
-        uint16 attr;
-        SMB_OFF_T size;
+        uint16_t attr;
+        off_t size;
         off_t start = 0;
-        SMB_OFF_T nread = 0;
+        off_t nread = 0;
         int rc = 0;
         struct cli_state *targetcli = NULL;
@@ -1076 +1080 @@
 
         if (lowercase) {
-                strlower_m(lname);
-        }
-
-        if (!cli_resolve_path(ctx, "", auth_info, cli, rname, &targetcli, &targetname ) ) {
-                d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
+                if (!strlower_m(lname)) {
+                        d_printf("strlower_m %s failed\n", lname);
+                        return 1;
+                }
+        }
+
+        status = cli_resolve_path(ctx, "", auth_info, cli, rname, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Failed to open %s: %s\n", rname, nt_errstr(status));
                 return 1;
         }
@@ -1097 +1106 @@
         } else {
                 if (reget) {
-                        handle = sys_open(lname, O_WRONLY|O_CREAT, 0644);
+                        handle = open(lname, O_WRONLY|O_CREAT, 0644);
                         if (handle >= 0) {
-                                start = sys_lseek(handle, 0, SEEK_END);
+                                start = lseek(handle, 0, SEEK_END);
                                 if (start == -1) {
                                         d_printf("Error seeking local file\n");
@@ -1106 +1115 @@
                         }
                 } else {
-                        handle = sys_open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
+                        handle = open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
                 }
                 newhandle = true;
@@ -1150 +1159 @@
 
         if (archive_level >= 2 && (attr & FILE_ATTRIBUTE_ARCHIVE)) {
-                cli_setatr(cli, rname, attr & ~(uint16)FILE_ATTRIBUTE_ARCHIVE, 0);
+                cli_setatr(cli, rname, attr & ~(uint16_t)FILE_ATTRIBUTE_ARCHIVE, 0);
         }
 
@@ -1284 +1293 @@
         string_replace(finfo->name,'\\','/');
         if (lowercase) {
-                strlower_m(finfo->name);
+                if (!strlower_m(finfo->name)) {
+                        return NT_STATUS_INVALID_PARAMETER;
+                }
         }
 
@@ -1348 +1359 @@
         int fd;
         int rc = 0;
+        mode_t mask;
 
         rname = talloc_strdup(ctx, client_get_cur_dir());
@@ -1358 +1370 @@
                 return 1;
         }
+        mask = umask(S_IRWXO | S_IRWXG);
         fd = mkstemp(lname);
+        umask(mask);
         if (fd == -1) {
                 d_printf("failed to create temporary file for more\n");
@@ -1406 +1420 @@
 {
         TALLOC_CTX *ctx = talloc_tos();
-        uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+        uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
         char *mget_mask = NULL;
         char *buf = NULL;
@@ -1470 +1484 @@
         NTSTATUS status;
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli, &targetname)) {
-                d_printf("mkdir %s: %s\n", name, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("mkdir %s: %s\n", name, nt_errstr(status));
                 return false;
         }
@@ -1526 +1542 @@
         char *mask = NULL;
         char *buf = NULL;
+        NTSTATUS status;
 
         mask = talloc_strdup(ctx, client_get_cur_dir());
@@ -1556 +1573 @@
                 }
 
-                if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
+                status = cli_resolve_path(ctx, "", auth_info, cli, mask,
+                                          &targetcli, &targetname);
+                if (!NT_STATUS_IS_OK(status)) {
                         return 1;
                 }
@@ -1616 +1635 @@
 static char *attr_str(TALLOC_CTX *mem_ctx, uint16_t mode)
 {
-        char *attrs = TALLOC_ZERO_ARRAY(mem_ctx, char, 17);
+        char *attrs = talloc_zero_array(mem_ctx, char, 17);
         int i = 0;
 
@@ -1671 +1690 @@
         fstring altname;
         struct timespec b_time, a_time, m_time, c_time;
-        SMB_OFF_T size;
+        off_t size;
         uint16_t mode;
-        SMB_INO_T ino;
         NTTIME tmp;
         uint16_t fnum;
@@ -1687 +1705 @@
                 d_printf("%s getting alt name for %s\n", nt_errstr(status),
                          name);
-                return false;
+                /*
+                 * Ignore not supported or not implemented, it does not
+                 * hurt if we can't list alternate names.
+                 */
+                if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED) ||
+                    NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
+                        altname[0] = '\0';
+                } else {
+                        return false;
+                }
         }
         d_printf("altname: %s\n", altname);
 
-        status = cli_qpathinfo2(cli, name, &b_time, &a_time, &m_time, &c_time,
-                                &size, &mode, &ino);
+        status = cli_qpathinfo3(cli, name, &b_time, &a_time, &m_time, &c_time,
+                                &size, &mode, NULL);
         if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s getting pathinfo for %s\n", nt_errstr(status),
@@ -1699 +1726 @@
         }
 
-        unix_timespec_to_nt_time(&tmp, b_time);
+        tmp = unix_timespec_to_nt_time(b_time);
         d_printf("create_time:    %s\n", nt_time_string(talloc_tos(), tmp));
 
-        unix_timespec_to_nt_time(&tmp, a_time);
+        tmp = unix_timespec_to_nt_time(a_time);
         d_printf("access_time:    %s\n", nt_time_string(talloc_tos(), tmp));
 
-        unix_timespec_to_nt_time(&tmp, m_time);
+        tmp = unix_timespec_to_nt_time(m_time);
         d_printf("write_time:     %s\n", nt_time_string(talloc_tos(), tmp));
 
-        unix_timespec_to_nt_time(&tmp, c_time);
+        tmp = unix_timespec_to_nt_time(c_time);
         d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
 
@@ -1724 +1751 @@
                 d_printf("stream: [%s], %lld bytes\n", streams[i].name,
                          (unsigned long long)streams[i].size);
+        }
+
+        if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
+                char *subst, *print;
+                uint32_t flags;
+
+                status = cli_readlink(cli, name, talloc_tos(), &subst, &print,
+                                      &flags);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_fprintf(stderr, "cli_readlink returned %s\n",
+                                  nt_errstr(status));
+                } else {
+                        d_printf("symlink: subst=[%s], print=[%s], flags=%x\n",
+                                 subst, print, flags);
+                        TALLOC_FREE(subst);
+                        TALLOC_FREE(print);
+                }
         }
 
@@ -1731 +1775 @@
                               FILE_SHARE_READ|FILE_SHARE_WRITE
                               |FILE_SHARE_DELETE,
-                              FILE_OPEN, 0x0, 0x0, &fnum);
+                              FILE_OPEN, 0x0, 0x0, &fnum, NULL);
         if (!NT_STATUS_IS_OK(status)) {
                 /*
@@ -1752 +1796 @@
                 snap_name = talloc_asprintf(talloc_tos(), "%s%s",
                                             snapshots[i], name);
-                status = cli_qpathinfo2(cli, snap_name, &b_time, &a_time,
+                status = cli_qpathinfo3(cli, snap_name, &b_time, &a_time,
                                         &m_time, &c_time, &size,
                                         NULL, NULL);
@@ -1761 +1805 @@
                         continue;
                 }
-                unix_timespec_to_nt_time(&tmp, b_time);
+                tmp = unix_timespec_to_nt_time(b_time);
                 d_printf("create_time:    %s\n", nt_time_string(talloc_tos(), tmp));
-                unix_timespec_to_nt_time(&tmp, a_time);
+                tmp = unix_timespec_to_nt_time(a_time);
                 d_printf("access_time:    %s\n", nt_time_string(talloc_tos(), tmp));
-                unix_timespec_to_nt_time(&tmp, m_time);
+                tmp =unix_timespec_to_nt_time(m_time);
                 d_printf("write_time:     %s\n", nt_time_string(talloc_tos(), tmp));
-                unix_timespec_to_nt_time(&tmp, c_time);
+                tmp = unix_timespec_to_nt_time(c_time);
                 d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
                 d_printf("size: %d\n", (int)size);
@@ -1773 +1817 @@
 
         TALLOC_FREE(snapshots);
+        cli_close(cli, fnum);
 
         return 0;
@@ -1815 +1860 @@
         uint16_t fnum;
         XFILE *f;
-        SMB_OFF_T start = 0;
+        off_t start = 0;
         int rc = 0;
         struct timespec tp_start;
@@ -1823 +1868 @@
         NTSTATUS status;
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, rname, &targetcli, &targetname)) {
-                d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, rname,
+                                  &targetcli, &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Failed to open %s: %s\n", rname, nt_errstr(status));
                 return 1;
         }
@@ -2049 +2096 @@
                       const char *expression, bool match)
 {
-        SMB_STRUCT_DIR *dir;
+        DIR *dir;
         struct file_list *entry;
         struct stat statbuf;
@@ -2057 +2104 @@
         const char *dname;
 
-        dir = sys_opendir(directory);
+        dir = opendir(directory);
         if (!dir)
                 return -1;
@@ -2086 +2133 @@
                                 if (ret == -1) {
                                         SAFE_FREE(path);
-                                        sys_closedir(dir);
+                                        closedir(dir);
                                         return -1;
                                 }
@@ -2093 +2140 @@
                         if (!entry) {
                                 d_printf("Out of memory in file_find\n");
-                                sys_closedir(dir);
+                                closedir(dir);
                                 return -1;
                         }
@@ -2104 +2151 @@
         }
 
-        sys_closedir(dir);
+        closedir(dir);
         return 0;
 }
@@ -2213 +2260 @@
                 return 0;
         } else {
-                d_printf("Error cancelling job %d : %s\n",job,cli_errstr(cli));
+                NTSTATUS status = cli_nt_error(cli);
+                d_printf("Error cancelling job %d : %s\n",
+                         job, nt_errstr(status));
                 return 1;
         }
@@ -2265 +2314 @@
                                         "%s-%d",
                                         p+1,
-                                        (int)sys_getpid());
+                                        (int)getpid());
         }
         if (strequal(lname,"-")) {
                 rname = talloc_asprintf(ctx,
                                 "stdin-%d",
-                                (int)sys_getpid());
+                                (int)getpid());
         }
         if (!rname) {
@@ -2342 +2391 @@
         char *buf = NULL;
         NTSTATUS status = NT_STATUS_OK;
-        uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+        uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
 
         if (recurse) {
@@ -2377 +2426 @@
         char *mask = NULL;
         char *buf = NULL;
-        uint16 attribute;
+        uint16_t attribute;
         struct cli_state *targetcli;
         char *targetname = NULL;
@@ -2387 +2436 @@
         }
 
-        attribute = (uint16)strtol(buf, (char **)NULL, 16);
+        attribute = (uint16_t)strtol(buf, (char **)NULL, 16);
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2401 +2450 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
-                d_printf("cmd_wdel %s: %s\n", mask, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("cmd_wdel %s: %s\n", mask, nt_errstr(status));
                 return 1;
         }
@@ -2425 +2476 @@
         struct cli_state *targetcli;
         uint16_t fnum = (uint16_t)-1;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2438 +2490 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
-                d_printf("open %s: %s\n", mask, cli_errstr(cli));
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(targetcli, targetname, 0,
+        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("open %s: %s\n", mask, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_ntcreate(targetcli, targetname, 0,
                         FILE_READ_DATA|FILE_WRITE_DATA, 0,
-                        FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
-                if (NT_STATUS_IS_OK(cli_ntcreate(targetcli, targetname, 0,
+                        FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN,
+                        0x0, 0x0, &fnum, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                status = cli_ntcreate(targetcli, targetname, 0,
                                 FILE_READ_DATA, 0,
-                                FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
+                                FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN,
+                                0x0, 0x0, &fnum, NULL);
+                if (NT_STATUS_IS_OK(status)) {
                         d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
                 } else {
-                        d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
+                        d_printf("Failed to open file %s. %s\n",
+                                 targetname, nt_errstr(status));
                 }
         } else {
@@ -2514 +2573 @@
         mode_t mode;
         uint16_t fnum;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2533 +2593 @@
         mode = (mode_t)strtol(buf, (char **)NULL, 8);
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
-                d_printf("posix_open %s: %s\n", mask, cli_errstr(cli));
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_posix_open(targetcli, targetname, O_CREAT|O_RDWR, mode, &fnum))) {
-                if (NT_STATUS_IS_OK(cli_posix_open(targetcli, targetname, O_CREAT|O_RDONLY, mode, &fnum))) {
-                        d_printf("posix_open file %s: for readonly fnum %d\n", targetname, fnum);
+        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("posix_open %s: %s\n", mask, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_posix_open(targetcli, targetname, O_CREAT|O_RDWR, mode,
+                                &fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                status = cli_posix_open(targetcli, targetname,
+                                        O_CREAT|O_RDONLY, mode, &fnum);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_printf("Failed to open file %s. %s\n", targetname,
+                                 nt_errstr(status));
                 } else {
-                        d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
+                        d_printf("posix_open file %s: for readonly fnum %d\n",
+                                 targetname, fnum);
                 }
         } else {
-                d_printf("posix_open file %s: for read/write fnum %d\n", targetname, fnum);
+                d_printf("posix_open file %s: for read/write fnum %d\n",
+                         targetname, fnum);
         }
 
@@ -2559 +2628 @@
         struct cli_state *targetcli;
         mode_t mode;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2578 +2648 @@
         mode = (mode_t)strtol(buf, (char **)NULL, 8);
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
-                d_printf("posix_mkdir %s: %s\n", mask, cli_errstr(cli));
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_posix_mkdir(targetcli, targetname, mode))) {
-                d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("posix_mkdir %s: %s\n", mask, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_posix_mkdir(targetcli, targetname, mode);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Failed to open file %s. %s\n",
+                         targetname, nt_errstr(status));
         } else {
                 d_printf("posix_mkdir created directory %s\n", targetname);
@@ -2598 +2672 @@
         char *targetname = NULL;
         struct cli_state *targetcli;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2611 +2686 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
-                d_printf("posix_unlink %s: %s\n", mask, cli_errstr(cli));
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_posix_unlink(targetcli, targetname))) {
-                d_printf("Failed to unlink file %s. %s\n", targetname, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("posix_unlink %s: %s\n", mask, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_posix_unlink(targetcli, targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Failed to unlink file %s. %s\n",
+                         targetname, nt_errstr(status));
         } else {
                 d_printf("posix_unlink deleted file %s\n", targetname);
@@ -2632 +2711 @@
         char *targetname = NULL;
         struct cli_state *targetcli;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2645 +2725 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
-                d_printf("posix_rmdir %s: %s\n", mask, cli_errstr(cli));
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_posix_rmdir(targetcli, targetname))) {
-                d_printf("Failed to unlink directory %s. %s\n", targetname, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("posix_rmdir %s: %s\n", mask, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_posix_rmdir(targetcli, targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Failed to unlink directory %s. %s\n",
+                         targetname, nt_errstr(status));
         } else {
                 d_printf("posix_rmdir deleted directory %s\n", targetname);
@@ -2664 +2748 @@
         char *buf = NULL;
         int fnum;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2672 +2757 @@
         fnum = atoi(buf);
         /* We really should use the targetcli here.... */
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum))) {
-                d_printf("close %d: %s\n", fnum, cli_errstr(cli));
+        status = cli_close(cli, fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("close %d: %s\n", fnum, nt_errstr(status));
                 return 1;
         }
@@ -2682 +2768 @@
 {
         TALLOC_CTX *ctx = talloc_tos();
-        uint16 major, minor;
-        uint32 caplow, caphigh;
+        uint16_t major, minor;
+        uint32_t caplow, caphigh;
         char *caps;
         NTSTATUS status;
@@ -2791 +2877 @@
         enum brl_type lock_type;
         int fnum;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2826 +2913 @@
         len = (uint64_t)strtol(buf, (char **)NULL, 16);
 
-        if (!NT_STATUS_IS_OK(cli_posix_lock(cli, fnum, start, len, true, lock_type))) {
-                d_printf("lock failed %d: %s\n", fnum, cli_errstr(cli));
+        status = cli_posix_lock(cli, fnum, start, len, true, lock_type);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("lock failed %d: %s\n", fnum, nt_errstr(status));
         }
 
@@ -2839 +2927 @@
         uint64_t start, len;
         int fnum;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2860 +2949 @@
         len = (uint64_t)strtol(buf, (char **)NULL, 16);
 
-        if (!NT_STATUS_IS_OK(cli_posix_unlock(cli, fnum, start, len))) {
-                d_printf("unlock failed %d: %s\n", fnum, cli_errstr(cli));
+        status = cli_posix_unlock(cli, fnum, start, len);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("unlock failed %d: %s\n", fnum, nt_errstr(status));
         }
 
@@ -2879 +2969 @@
         char *targetname = NULL;
         struct cli_state *targetcli;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2892 +2983 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
-                d_printf("rmdir %s: %s\n", mask, cli_errstr(cli));
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_rmdir(targetcli, targetname))) {
+        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("rmdir %s: %s\n", mask, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_rmdir(targetcli, targetname);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s removing remote directory file %s\n",
-                         cli_errstr(targetcli),mask);
+                         nt_errstr(status), mask);
         }
 
@@ -2918 +3012 @@
         char *targetname = NULL;
         struct cli_state *targetcli;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
@@ -2939 +3034 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, oldname, &targetcli, &targetname)) {
-                d_printf("link %s: %s\n", oldname, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, oldname, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("link %s: %s\n", oldname, nt_errstr(status));
                 return 1;
         }
@@ -2949 +3046 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_hardlink(targetcli, targetname, newname))) {
-                d_printf("%s linking files (%s -> %s)\n", cli_errstr(targetcli), newname, oldname);
+        status = cli_posix_hardlink(targetcli, targetname, newname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("%s linking files (%s -> %s)\n",
+                         nt_errstr(status), newname, oldname);
                 return 1;
         }
@@ -2968 +3067 @@
         char linkname[PATH_MAX+1];
         struct cli_state *targetcli;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
@@ -2981 +3081 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli, &targetname)) {
-                d_printf("readlink %s: %s\n", name, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("readlink %s: %s\n", name, nt_errstr(status));
                 return 1;
         }
@@ -2991 +3093 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_readlink(targetcli, name,
-                        linkname, PATH_MAX+1))) {
+        status = cli_posix_readlink(targetcli, name, linkname, PATH_MAX+1);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s readlink on file %s\n",
-                        cli_errstr(targetcli), name);
+                         nt_errstr(status), name);
                 return 1;
         }
@@ -3016 +3118 @@
         char *buf2 = NULL;
         struct cli_state *newcli;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
@@ -3025 +3128 @@
         oldname = buf;
 
-        newname = talloc_asprintf(ctx,
-                        "%s%s",
-                        client_get_cur_dir(),
-                        buf2);
-        if (!newname) {
-                return 1;
-        }
-
-        /* 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(newcli)) {
-                d_printf("Server doesn't support UNIX CIFS calls.\n");
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_posix_symlink(newcli, oldname, newname))) {
+        if (SERVER_HAS_UNIX_CIFS(cli)) {
+                newname = talloc_asprintf(ctx, "%s%s", client_get_cur_dir(),
+                                          buf2);
+                if (!newname) {
+                        return 1;
+                }
+                /* New name must be present in share namespace. */
+                status = cli_resolve_path(ctx, "", auth_info, cli, newname,
+                                          &newcli, &newname);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_printf("link %s: %s\n", oldname, nt_errstr(status));
+                        return 1;
+                }
+                status = cli_posix_symlink(newcli, oldname, newname);
+        } else {
+                status = cli_symlink(
+                        cli, oldname, buf2,
+                        buf2[0] == '\\' ? 0 : SYMLINK_FLAG_RELATIVE);
+        }
+
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s symlinking files (%s -> %s)\n",
-                        cli_errstr(newcli), newname, newname);
+                         nt_errstr(status), oldname, newname);
                 return 1;
         }
@@ -3066 +3170 @@
         struct cli_state *targetcli;
         mode_t mode;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
@@ -3082 +3187 @@
         mode = (mode_t)strtol(buf, NULL, 8);
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
-                d_printf("chmod %s: %s\n", src, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("chmod %s: %s\n", src, nt_errstr(status));
                 return 1;
         }
@@ -3092 +3199 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_chmod(targetcli, targetname, mode))) {
+        status = cli_posix_chmod(targetcli, targetname, mode);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s chmod file %s 0%o\n",
-                        cli_errstr(targetcli), src, (unsigned int)mode);
+                         nt_errstr(status), src, (unsigned int)mode);
                 return 1;
         }
@@ -3214 +3322 @@
         char *targetname = NULL;
         struct cli_state *targetcli;
-        uint16 major, minor;
-        uint32 caplow, caphigh;
+        uint16_t major, minor;
+        uint32_t caplow, caphigh;
         char *retbuf = NULL;
         size_t rb_size = 0;
         SMB_STRUCT_STAT sbuf;
-        uint16 num_file_acls = 0;
-        uint16 num_dir_acls = 0;
-        uint16 i;
+        uint16_t num_file_acls = 0;
+        uint16_t num_dir_acls = 0;
+        uint16_t i;
         NTSTATUS status;
 
@@ -3236 +3344 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
-                d_printf("stat %s: %s\n", src, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("stat %s: %s\n", src, nt_errstr(status));
                 return 1;
         }
@@ -3260 +3370 @@
         }
 
+        status = cli_posix_stat(targetcli, targetname, &sbuf);
         if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli, targetname, &sbuf))) {
                 d_printf("%s getfacl doing a stat on file %s\n",
-                        cli_errstr(targetcli), src);
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_posix_getfacl(targetcli, targetname, ctx, &rb_size, &retbuf))) {
+                         nt_errstr(status), src);
+                return 1;
+        }
+
+        status = cli_posix_getacl(targetcli, targetname, ctx, &rb_size, &retbuf);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s getfacl file %s\n",
-                        cli_errstr(targetcli), src);
+                         nt_errstr(status), src);
                 return 1;
         }
@@ -3297 +3409 @@
 
         for (i = 0; i < num_file_acls; i++) {
-                uint32 uorg;
+                uint32_t uorg;
                 fstring permstring;
                 unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE));
@@ -3334 +3446 @@
 
         for (i = 0; i < num_dir_acls; i++) {
-                uint32 uorg;
+                uint32_t uorg;
                 fstring permstring;
                 unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE));
@@ -3373 +3485 @@
 }
 
-static void printf_cb(const char *buf, void *private_data)
-{
-        printf("%s", buf);
-}
-
 /****************************************************************************
  Get the EA list of a file
@@ -3405 +3512 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
-                              &targetname)) {
-                d_printf("stat %s: %s\n", src, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("stat %s: %s\n", src, nt_errstr(status));
                 return 1;
         }
@@ -3420 +3528 @@
         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);
+                dump_data_file(eas[i].value.data, eas[i].value.length, false,
+                               stdout);
                 d_printf("\n");
         }
@@ -3461 +3569 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
-                              &targetname)) {
-                d_printf("stat %s: %s\n", src, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("stat %s: %s\n", src, nt_errstr(status));
                 return 1;
         }
@@ -3492 +3601 @@
         struct tm *lt;
         time_t tmp_time;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
@@ -3505 +3615 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
-                d_printf("stat %s: %s\n", src, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("stat %s: %s\n", src, nt_errstr(status));
                 return 1;
         }
@@ -3515 +3627 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli, targetname, &sbuf))) {
+        status = cli_posix_stat(targetcli, targetname, &sbuf);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s stat file %s\n",
-                        cli_errstr(targetcli), src);
+                         nt_errstr(status), src);
                 return 1;
         }
@@ -3591 +3704 @@
         struct cli_state *targetcli;
         char *targetname = NULL;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
@@ -3609 +3723 @@
                 return 1;
         }
-        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname) ) {
-                d_printf("chown %s: %s\n", src, cli_errstr(cli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("chown %s: %s\n", src, nt_errstr(status));
                 return 1;
         }
@@ -3619 +3735 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_posix_chown(targetcli, targetname, uid, gid))) {
+        status = cli_posix_chown(targetcli, targetname, uid, gid);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s chown file %s uid=%d, gid=%d\n",
-                        cli_errstr(targetcli), src, (int)uid, (int)gid);
+                         nt_errstr(status), src, (int)uid, (int)gid);
                 return 1;
         }
@@ -3640 +3757 @@
         char *targetsrc;
         char *targetdest;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
@@ -3663 +3781 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetsrc)) {
-                d_printf("rename %s: %s\n", src, cli_errstr(cli));
-                return 1;
-        }
-
-        if (!cli_resolve_path(ctx, "", auth_info, cli, dest, &targetcli, &targetdest)) {
-                d_printf("rename %s: %s\n", dest, cli_errstr(cli));
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_rename(targetcli, targetsrc, targetdest))) {
+        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                                  &targetsrc);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("rename %s: %s\n", src, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_resolve_path(ctx, "", auth_info, cli, dest, &targetcli,
+                                  &targetdest);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("rename %s: %s\n", dest, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_rename(targetcli, targetsrc, targetdest);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("%s renaming files %s -> %s \n",
-                        cli_errstr(targetcli),
+                        nt_errstr(status),
                         targetsrc,
                         targetdest);
@@ -3684 +3807 @@
 }
 
-/****************************************************************************
- Print the volume name.
-****************************************************************************/
-
-static int cmd_volume(void)
-{
-        fstring volname;
-        uint32 serial_num;
-        time_t create_date;
-        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;
-        }
-
-        d_printf("Volume: |%s| serial number 0x%x\n",
-                        volname, (unsigned int)serial_num);
-        return 0;
-}
-
-/****************************************************************************
- Hard link files using the NT call.
-****************************************************************************/
-
-static int cmd_hardlink(void)
+struct scopy_timing {
+        struct timespec tp_start;
+};
+
+static int scopy_status(off_t written, void *priv)
+{
+        struct timespec tp_end;
+        unsigned int scopy_total_time_ms;
+        struct scopy_timing *st = priv;
+
+        clock_gettime_mono(&tp_end);
+        scopy_total_time_ms = nsec_time_diff(&tp_end,&st->tp_start)/1000000;
+
+        DEBUG(5,("Copied %jd bytes at an average %3.1f kb/s\n",
+                 (intmax_t)written, written / (1.024*scopy_total_time_ms)));
+
+        return true;
+}
+
+/****************************************************************************
+ Server-Side copy some file.
+****************************************************************************/
+
+static int cmd_scopy(void)
 {
         TALLOC_CTX *ctx = talloc_tos();
@@ -3717 +3836 @@
         char *buf, *buf2;
         struct cli_state *targetcli;
-        char *targetname;
+        char *targetsrc;
+        char *targetdest;
+        uint32_t DesiredAccess, ShareAccess, CreateDisposition, CreateOptions;
+        struct smb_create_returns cr;
+        uint16_t destfnum = (uint16_t)-1;
+        uint16_t srcfnum = (uint16_t)-1;
+        off_t written = 0;
+        struct scopy_timing st;
+        int rc = 0;
+        NTSTATUS status;
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
-            !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
-                d_printf("hardlink <src> <dest>\n");
+                        !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
+                d_printf("scopy <src> <dest>\n");
                 return 1;
         }
@@ -3741 +3869 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
-                d_printf("hardlink %s: %s\n", src, cli_errstr(cli));
-                return 1;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_nt_hardlink(targetcli, targetname, dest))) {
-                d_printf("%s doing an NT hard link of files\n",cli_errstr(targetcli));
+        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                        &targetsrc);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("scopy %s: %s\n", src, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_resolve_path(ctx, "", auth_info, cli, dest, &targetcli,
+                        &targetdest);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("scopy %s: %s\n", dest, nt_errstr(status));
+                return 1;
+        }
+
+
+        DesiredAccess = (FILE_READ_DATA|FILE_READ_EA|FILE_READ_ATTRIBUTES|
+                        READ_CONTROL_ACCESS|SYNCHRONIZE_ACCESS);
+        ShareAccess = FILE_SHARE_READ|FILE_SHARE_DELETE;
+        CreateDisposition = FILE_OPEN;
+        CreateOptions = (FILE_SEQUENTIAL_ONLY|FILE_NON_DIRECTORY_FILE|
+                        FILE_OPEN_REPARSE_POINT);
+        status = cli_ntcreate(targetcli, targetsrc, 0, DesiredAccess, 0,
+                        ShareAccess, CreateDisposition, CreateOptions, 0x0,
+                        &srcfnum, &cr);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Failed to open file %s. %s\n",
+                                targetsrc, nt_errstr(status));
+                return 1;
+        }
+
+        DesiredAccess = (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_READ_EA|
+                        FILE_WRITE_EA|FILE_READ_ATTRIBUTES|FILE_WRITE_ATTRIBUTES|
+                        DELETE_ACCESS|READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|SYNCHRONIZE_ACCESS);
+        ShareAccess = FILE_SHARE_NONE;
+        CreateDisposition = FILE_CREATE;
+        CreateOptions = FILE_SEQUENTIAL_ONLY|FILE_NON_DIRECTORY_FILE;
+        status = cli_ntcreate(targetcli, targetdest, 0, DesiredAccess,
+                        FILE_ATTRIBUTE_ARCHIVE, ShareAccess, CreateDisposition,
+                        CreateOptions, 0x0, &destfnum, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Failed to create file %s. %s\n",
+                                targetdest, nt_errstr(status));
+                cli_close(targetcli, srcfnum);
+                return 1;
+        }
+
+        clock_gettime_mono(&st.tp_start);
+        status = cli_splice(targetcli, targetcli, srcfnum, destfnum,
+                        cr.end_of_file, 0, 0, &written, scopy_status, &st);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("%s copying file %s -> %s \n",
+                                nt_errstr(status),
+                                targetsrc,
+                                targetdest);
+                rc = 1;
+        }
+
+        status = cli_close(targetcli, srcfnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Error %s closing remote source file\n", nt_errstr(status));
+                rc = 1;
+        }
+        status = cli_close(targetcli, destfnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Error %s closing remote dest file\n", nt_errstr(status));
+                rc = 1;
+        }
+
+        return rc;
+}
+
+/****************************************************************************
+ Print the volume name.
+****************************************************************************/
+
+static int cmd_volume(void)
+{
+        char *volname;
+        uint32_t serial_num;
+        time_t create_date;
+        NTSTATUS status;
+
+        status = cli_get_fs_volume_info(cli, talloc_tos(),
+                                        &volname, &serial_num,
+                                        &create_date);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Error %s getting volume info\n", nt_errstr(status));
+                return 1;
+        }
+
+        d_printf("Volume: |%s| serial number 0x%x\n",
+                        volname, (unsigned int)serial_num);
+        return 0;
+}
+
+/****************************************************************************
+ Hard link files using the NT call.
+****************************************************************************/
+
+static int cmd_hardlink(void)
+{
+        TALLOC_CTX *ctx = talloc_tos();
+        char *src, *dest;
+        char *buf, *buf2;
+        struct cli_state *targetcli;
+        char *targetname;
+        NTSTATUS status;
+
+        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
+            !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
+                d_printf("hardlink <src> <dest>\n");
+                return 1;
+        }
+
+        src = talloc_asprintf(ctx,
+                        "%s%s",
+                        client_get_cur_dir(),
+                        buf);
+        if (!src) {
+                return 1;
+        }
+
+        dest = talloc_asprintf(ctx,
+                        "%s%s",
+                        client_get_cur_dir(),
+                        buf2);
+        if (!dest) {
+                return 1;
+        }
+
+        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+                                  &targetname);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("hardlink %s: %s\n", src, nt_errstr(status));
+                return 1;
+        }
+
+        status = cli_nt_hardlink(targetcli, targetname, dest);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("%s doing an NT hard link of files\n",
+                         nt_errstr(status));
                 return 1;
         }
@@ -3794 +4056 @@
 
 /****************************************************************************
+ Watch directory changes
+****************************************************************************/
+
+static int cmd_notify(void)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        char *name, *buf;
+        NTSTATUS status;
+        uint16_t fnum;
+
+        name = talloc_strdup(talloc_tos(), client_get_cur_dir());
+        if (name == NULL) {
+                goto fail;
+        }
+        if (!next_token_talloc(talloc_tos(), &cmd_ptr, &buf, NULL)) {
+                goto usage;
+        }
+        name = talloc_asprintf_append(name, "%s", buf);
+        if (name == NULL) {
+                goto fail;
+        }
+        status = cli_ntcreate(
+                cli, name, 0, FILE_READ_DATA, 0,
+                FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+                FILE_OPEN, 0, 0, &fnum, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("Could not open file: %s\n", nt_errstr(status));
+                goto fail;
+        }
+
+        while (1) {
+                uint32_t i, num_changes;
+                struct notify_change *changes;
+
+                status = cli_notify(cli, fnum, 1000, FILE_NOTIFY_CHANGE_ALL,
+                                    true,
+                                    talloc_tos(), &num_changes, &changes);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_printf("notify returned %s\n",
+                                 nt_errstr(status));
+                        goto fail;
+                }
+                for (i=0; i<num_changes; i++) {
+                        printf("%4.4x %s\n", changes[i].action,
+                               changes[i].name);
+                }
+                TALLOC_FREE(changes);
+        }
+usage:
+        d_printf("notify <file>\n");
+fail:
+        TALLOC_FREE(frame);
+        return 1;
+}
+
+/****************************************************************************
  Set the archive level.
 ****************************************************************************/
@@ -3812 +4130 @@
 
 /****************************************************************************
+ Toggle the backup_intent state.
+****************************************************************************/
+
+static int cmd_backup(void)
+{
+        backup_intent = !backup_intent;
+        cli_set_backup_intent(cli, backup_intent);
+        DEBUG(2,("backup intent is now %s\n",backup_intent?"on":"off"));
+        return 1;
+}
+
+/****************************************************************************
  Toggle the lowercaseflag.
 ****************************************************************************/
@@ -3887 +4217 @@
                 }
         }
-        d = TALLOC_ARRAY(ctx, char, PATH_MAX+1);
+        d = sys_getwd();
         if (!d) {
                 return 1;
         }
-        DEBUG(2,("the local directory is now %s\n",sys_getwd(d)));
+        DEBUG(2,("the local directory is now %s\n",d));
+        SAFE_FREE(d);
         return 0;
 }
@@ -3984 +4315 @@
  ****************************************************************************/
 
-static void browse_fn(const char *name, uint32 m,
+static void browse_fn(const char *name, uint32_t m,
                       const char *comment, void *state)
 {
@@ -4027 +4358 @@
         struct dcerpc_binding_handle *b;
 
-        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_srvsvc.syntax_id,
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_srvsvc,
                                           &pipe_hnd);
 
@@ -4085 +4416 @@
         }
 
-        if((ret = cli_RNetShareEnum(cli, browse_fn, NULL)) == -1)
-                d_printf("Error returning browse list: %s\n", cli_errstr(cli));
+        if((ret = cli_RNetShareEnum(cli, browse_fn, NULL)) == -1) {
+                NTSTATUS status = cli_nt_error(cli);
+                d_printf("Error returning browse list: %s\n",
+                         nt_errstr(status));
+        }
 
         return (ret != -1);
@@ -4095 +4429 @@
 ****************************************************************************/
 
-static void server_fn(const char *name, uint32 m,
+static void server_fn(const char *name, uint32_t m,
                       const char *comment, void *state)
 {
@@ -4146 +4480 @@
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
-                d_printf("Current VUID is %d\n", cli->vuid);
+                d_printf("Current VUID is %d\n",
+                         cli_state_get_uid(cli));
                 return 0;
         }
 
-        cli->vuid = atoi(buf);
+        cli_state_set_uid(cli, atoi(buf));
         return 0;
 }
@@ -4170 +4505 @@
 
         if (!next_token_talloc(ctx, &cmd_ptr,&l_password,NULL)) {
-                char *pass = getpass("Password: ");
-                if (pass) {
-                        l_password = talloc_strdup(ctx,pass);
+                char pwd[256] = {0};
+                int rc;
+
+                rc = samba_getpass("Password: ", pwd, sizeof(pwd), false, false);
+                if (rc == 0) {
+                        l_password = talloc_strdup(ctx, pwd);
                 }
         }
@@ -4188 +4526 @@
         }
 
-        d_printf("Current VUID is %d\n", cli->vuid);
+        d_printf("Current VUID is %d\n", cli_state_get_uid(cli));
+        return 0;
+}
+
+/**
+ * close the session
+ */
+
+static int cmd_logoff(void)
+{
+        NTSTATUS status;
+
+        status = cli_ulogoff(cli);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("logoff failed: %s\n", nt_errstr(status));
+                return -1;
+        }
+
+        d_printf("logoff successful\n");
+        return 0;
+}
+
+
+/**
+ * tree connect (connect to a share)
+ */
+
+static int cmd_tcon(void)
+{
+        TALLOC_CTX *ctx = talloc_tos();
+        char *sharename;
+        NTSTATUS status;
+
+        if (!next_token_talloc(ctx, &cmd_ptr, &sharename, NULL)) {
+                d_printf("tcon <sharename>\n");
+                return 0;
+        }
+
+        if (!sharename) {
+                return 1;
+        }
+
+        status = cli_tree_connect(cli, sharename, "?????", "", 0);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("tcon failed: %s\n", nt_errstr(status));
+                return -1;
+        }
+
+        talloc_free(sharename);
+
+        d_printf("tcon to %s successful, tid: %u\n", sharename,
+                 cli_state_get_tid(cli));
+        return 0;
+}
+
+/**
+ * tree disconnect (disconnect from a share)
+ */
+
+static int cmd_tdis(void)
+{
+        NTSTATUS status;
+
+        status = cli_tdis(cli);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("tdis failed: %s\n", nt_errstr(status));
+                return -1;
+        }
+
+        d_printf("tdis successful\n");
+        return 0;
+}
+
+
+/**
+ * get or set tid
+ */
+
+static int cmd_tid(void)
+{
+        TALLOC_CTX *ctx = talloc_tos();
+        char *tid_str;
+
+        if (!next_token_talloc(ctx, &cmd_ptr, &tid_str, NULL)) {
+                if (cli_state_has_tcon(cli)) {
+                        d_printf("current tid is %d\n", cli_state_get_tid(cli));
+                } else {
+                        d_printf("no tcon currently\n");
+                }
+        } else {
+                uint16_t tid = atoi(tid_str);
+                cli_state_set_tid(cli, tid);
+        }
+
         return 0;
 }
@@ -4212 +4643 @@
         struct cli_state *targetcli;
         char *targetpath;
-
-        if (!cli_resolve_path(ctx, "", auth_info, cli, client_get_cur_dir(),
-                                &targetcli, &targetpath ) ) {
-                d_printf("showconnect %s: %s\n", cur_dir, cli_errstr(cli));
-                return 1;
-        }
-
-        d_printf("//%s/%s\n", targetcli->desthost, targetcli->share);
-        return 0;
+        NTSTATUS status;
+
+        status = cli_resolve_path(ctx, "", auth_info, cli,
+                                  client_get_cur_dir(), &targetcli,
+                                  &targetpath);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("showconnect %s: %s\n", cur_dir, nt_errstr(status));
+                return 1;
+        }
+
+        d_printf("//%s/%s\n", smbXcli_conn_remote_name(targetcli->conn), targetcli->share);
+        return 0;
+}
+
+/**
+ * set_remote_attr - set DOS attributes of a remote file
+ * @filename: path to the file name
+ * @new_attr: attribute bit mask to use
+ * @mode: one of ATTR_SET or ATTR_UNSET
+ *
+ * Update the file attributes with the one provided.
+ */
+int set_remote_attr(const char *filename, uint16_t new_attr, int mode)
+{
+        extern struct cli_state *cli;
+        uint16_t old_attr;
+        NTSTATUS status;
+
+        status = cli_getatr(cli, filename, &old_attr, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("cli_getatr failed: %s\n", nt_errstr(status));
+                return 1;
+        }
+
+        if (mode == ATTR_SET) {
+                new_attr |= old_attr;
+        } else {
+                new_attr = old_attr & ~new_attr;
+        }
+
+        status = cli_setatr(cli, filename, new_attr, 0);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf("cli_setatr failed: %s\n", nt_errstr(status));
+                return 1;
+        }
+
+        return 0;
+}
+
+/**
+ * cmd_setmode - interactive command to set DOS attributes
+ *
+ * Read a filename and mode from the client command line and update
+ * the file DOS attributes.
+ */
+int cmd_setmode(void)
+{
+        const extern char *cmd_ptr;
+        char *buf;
+        char *fname = NULL;
+        uint16_t attr[2] = {0};
+        int mode = ATTR_SET;
+        int err = 0;
+        bool ok;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        ok = next_token_talloc(ctx, &cmd_ptr, &buf, NULL);
+        if (!ok) {
+                d_printf("setmode <filename> <[+|-]rsha>\n");
+                err = 1;
+                goto out;
+        }
+
+        fname = talloc_asprintf(ctx,
+                                "%s%s",
+                                client_get_cur_dir(),
+                                buf);
+        if (fname == NULL) {
+                err = 1;
+                goto out;
+        }
+
+        while (next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
+                const char *s = buf;
+
+                while (*s) {
+                        switch (*s++) {
+                        case '+':
+                                mode = ATTR_SET;
+                                break;
+                        case '-':
+                                mode = ATTR_UNSET;
+                                break;
+                        case 'r':
+                                attr[mode] |= FILE_ATTRIBUTE_READONLY;
+                                break;
+                        case 'h':
+                                attr[mode] |= FILE_ATTRIBUTE_HIDDEN;
+                                break;
+                        case 's':
+                                attr[mode] |= FILE_ATTRIBUTE_SYSTEM;
+                                break;
+                        case 'a':
+                                attr[mode] |= FILE_ATTRIBUTE_ARCHIVE;
+                                break;
+                        default:
+                                d_printf("setmode <filename> <perm=[+|-]rsha>\n");
+                                err = 1;
+                                goto out;
+                        }
+                }
+        }
+
+        if (attr[ATTR_SET] == 0 && attr[ATTR_UNSET] == 0) {
+                d_printf("setmode <filename> <[+|-]rsha>\n");
+                err = 1;
+                goto out;
+        }
+
+        DEBUG(2, ("perm set %d %d\n", attr[ATTR_SET], attr[ATTR_UNSET]));
+
+        /* ignore return value: server might not store DOS attributes */
+        set_remote_attr(fname, attr[ATTR_SET], ATTR_SET);
+        set_remote_attr(fname, attr[ATTR_UNSET], ATTR_UNSET);
+out:
+        talloc_free(ctx);
+        return err;
 }
 
@@ -4234 +4786 @@
 
         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
-                if (!smb_encrypt) {
-                        d_printf("iosize <n> or iosize 0x<n>. "
-                                "Minimum is 16384 (0x4000), "
-                                "max is 16776960 (0xFFFF00)\n");
+                if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
+                        if (!smb_encrypt) {
+                                d_printf("iosize <n> or iosize 0x<n>. "
+                                        "Minimum is 0 (default), "
+                                        "max is 16776960 (0xFFFF00)\n");
+                        } else {
+                                d_printf("iosize <n> or iosize 0x<n>. "
+                                        "(Encrypted connection) ,"
+                                        "Minimum is 0 (default), "
+                                        "max is 130048 (0x1FC00)\n");
+                        }
                 } else {
-                        d_printf("iosize <n> or iosize 0x<n>. "
-                                "(Encrypted connection) ,"
-                                "Minimum is 16384 (0x4000), "
-                                "max is 130048 (0x1FC00)\n");
+                        d_printf("iosize <n> or iosize 0x<n>.\n");
                 }
                 return 1;
@@ -4248 +4804 @@
 
         iosize = strtol(buf,NULL,0);
-        if (smb_encrypt && (iosize < 0x4000 || iosize > 0xFC00)) {
-                d_printf("iosize out of range for encrypted "
-                        "connection (min = 16384 (0x4000), "
-                        "max = 130048 (0x1FC00)");
-                return 1;
-        } else if (!smb_encrypt && (iosize < 0x4000 || iosize > 0xFFFF00)) {
-                d_printf("iosize out of range (min = 16384 (0x4000), "
-                        "max = 16776960 (0xFFFF00)");
-                return 1;
+        if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
+                if (smb_encrypt && (iosize < 0 || iosize > 0xFC00)) {
+                        d_printf("iosize out of range for encrypted "
+                                "connection (min = 0 (default), "
+                                "max = 130048 (0x1FC00)\n");
+                        return 1;
+                } else if (!smb_encrypt && (iosize < 0 || iosize > 0xFFFF00)) {
+                        d_printf("iosize out of range (min = 0 (default), "
+                                "max = 16776960 (0xFFFF00)\n");
+                        return 1;
+                }
         }
 
@@ -4263 +4821 @@
         return 0;
 }
+
+/****************************************************************************
+ timeout command
+***************************************************************************/
+
+static int cmd_timeout(void)
+{
+        TALLOC_CTX *ctx = talloc_tos();
+        char *buf;
+
+        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+                unsigned int old_timeout = cli_set_timeout(cli, 0);
+                cli_set_timeout(cli, old_timeout);
+                d_printf("timeout <n> (per-operation timeout "
+                        "in seconds - currently %u).\n",
+                        old_timeout/1000);
+                return 1;
+        }
+
+        io_timeout = strtol(buf,NULL,0);
+        cli_set_timeout(cli, io_timeout*1000);
+        d_printf("io_timeout per operation is now %d\n", io_timeout);
+        return 0;
+}
+
 
 /****************************************************************************
@@ -4307 +4890 @@
   {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}},
   {"archive",cmd_archive,"<level>\n0=ignore archive bit\n1=only get archive files\n2=only get archive files and reset archive bit\n3=get all files and reset archive bit",{COMPL_NONE,COMPL_NONE}},
+  {"backup",cmd_backup,"toggle backup intent state",{COMPL_NONE,COMPL_NONE}},
   {"blocksize",cmd_block,"blocksize <number> (default 20)",{COMPL_NONE,COMPL_NONE}},
   {"cancel",cmd_cancel,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}},
   {"case_sensitive",cmd_setcase,"toggle the case sensitive flag to server",{COMPL_NONE,COMPL_NONE}},
   {"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}},
-  {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_REMOTE}},
-  {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_REMOTE}},
-  {"close",cmd_close,"<fid> close a file given a fid",{COMPL_REMOTE,COMPL_REMOTE}},
+  {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_NONE}},
+  {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_NONE}},
+  {"close",cmd_close,"<fid> close a file given a fid",{COMPL_REMOTE,COMPL_NONE}},
   {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
   {"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
@@ -4320 +4904 @@
   {"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
   {"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}},
+  {"getfacl",cmd_getfacl,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE,COMPL_NONE}},
   {"geteas", cmd_geteas, "<file name> get the EA list of a file",
-   {COMPL_REMOTE, COMPL_LOCAL}},
+   {COMPL_REMOTE, COMPL_NONE}},
   {"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}},
@@ -4330 +4914 @@
   {"link",cmd_link,"<oldname> <newname> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},
   {"lock",cmd_lock,"lock <fnum> [r|w] <hex-start> <hex-len> : set a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},
-  {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},  
+  {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},
   {"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
   {"l",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
@@ -4337 +4921 @@
   {"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}},
   {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
-  {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},  
+  {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},
   {"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}},
   {"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}},
+  {"notify",cmd_notify,"<file>Get notified of dir changes",{COMPL_REMOTE,COMPL_NONE}},
   {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}},
   {"posix", cmd_posix, "turn on all POSIX capabilities", {COMPL_REMOTE,COMPL_NONE}},
@@ -4348 +4933 @@
   {"posix_unlink",cmd_posix_unlink,"<name> removes a file using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
   {"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}},
-  {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},  
+  {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},
   {"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}},
   {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}},
@@ -4356 +4941 @@
   {"readlink",cmd_readlink,"filename Do a UNIX extensions readlink call on a symlink",{COMPL_REMOTE,COMPL_REMOTE}},
   {"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
-  {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},  
+  {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},
   {"reget",cmd_reget,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE,COMPL_LOCAL}},
   {"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}},
   {"reput",cmd_reput,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL,COMPL_REMOTE}},
   {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
-  {"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}},  
+  {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_REMOTE,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}},
+  {"setmode",cmd_setmode,"<file name> <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},
+  {"scopy",cmd_scopy,"<src> <dest> server-side copy file",{COMPL_REMOTE,COMPL_REMOTE}},
+  {"stat",cmd_stat,"<file name> Do a UNIX extensions stat call on a file",{COMPL_REMOTE,COMPL_NONE}},
   {"symlink",cmd_symlink,"<oldname> <newname> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},
   {"tar",cmd_tar,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE,COMPL_NONE}},
   {"tarmode",cmd_tarmode,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE,COMPL_NONE}},
+  {"timeout",cmd_timeout,"timeout <number> - set the per-operation timeout in seconds (default 20)",{COMPL_NONE,COMPL_NONE}},
   {"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},
   {"unlock",cmd_unlock,"unlock <fnum> <hex-start> <hex-len> : remove a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},
@@ -4378 +4965 @@
   {"listconnect",cmd_list_connect,"list open connections",{COMPL_NONE,COMPL_NONE}},
   {"showconnect",cmd_show_connect,"display the current active connection",{COMPL_NONE,COMPL_NONE}},
+  {"tcon",cmd_tcon,"connect to a share" ,{COMPL_NONE,COMPL_NONE}},
+  {"tdis",cmd_tdis,"disconnect from a share",{COMPL_NONE,COMPL_NONE}},
+  {"tid",cmd_tid,"show or set the current tid (tree-id)",{COMPL_NONE,COMPL_NONE}},
+  {"logoff",cmd_logoff,"log off (close the session)",{COMPL_NONE,COMPL_NONE}},
   {"..",cmd_cd_oneup,"change the remote directory (up one level)",{COMPL_REMOTE,COMPL_NONE}},
 
@@ -4458 +5049 @@
 
         if (!cli) {
-                cli = cli_cm_open(talloc_tos(), NULL,
-                                have_ip ? dest_ss_str : desthost,
-                                service, auth_info,
-                                true, smb_encrypt,
-                                max_protocol, port, name_type);
-                if (!cli) {
+                NTSTATUS status;
+
+                status = cli_cm_open(talloc_tos(), NULL,
+                                     have_ip ? dest_ss_str : desthost,
+                                     service, auth_info,
+                                     true, smb_encrypt,
+                                     max_protocol, port, name_type,
+                                     &cli);
+                if (!NT_STATUS_IS_OK(status)) {
                         return 1;
                 }
+                cli_set_timeout(cli, io_timeout*1000);
         }
 
@@ -4638 +5233 @@
         }
 
-        if (!cli_resolve_path(ctx, "", auth_info, cli, dirmask, &targetcli, &targetpath)) {
+        status = cli_resolve_path(ctx, "", auth_info, cli, dirmask, &targetcli,
+                                  &targetpath);
+        if (!NT_STATUS_IS_OK(status)) {
                 goto cleanup;
         }
@@ -4676 +5273 @@
         info.matches[0] = SMB_STRNDUP(info.matches[1], info.samelen);
         info.matches[info.count] = NULL;
+        TALLOC_FREE(ctx);
         return info.matches;
 
@@ -4788 +5386 @@
         struct timespec now;
         time_t t;
-        int ret, revents;
+        NTSTATUS status;
+        unsigned char garbage[16];
 
         clock_gettime_mono(&now);
@@ -4798 +5397 @@
         last_t = t;
 
- again:
-
-        if (cli->fd == -1)
+        /* Ping the server to keep the connection alive using SMBecho. */
+        memset(garbage, 0xf0, sizeof(garbage));
+        status = cli_echo(cli, 1, data_blob_const(garbage, sizeof(garbage)));
+        if (NT_STATUS_IS_OK(status)) {
                 return;
-
-        /* We deliberately use receive_smb_raw instead of
-           client_receive_smb as we want to receive
-           session keepalives and then drop them here.
-        */
-
-        ret = poll_intr_one_fd(cli->fd, POLLIN|POLLHUP, 0, &revents);
-
-        if ((ret > 0) && (revents & (POLLIN|POLLHUP|POLLERR))) {
-                NTSTATUS status;
-                size_t len;
-
-                set_smb_read_error(&cli->smb_rw_error, SMB_READ_OK);
-
-                status = receive_smb_raw(cli->fd, cli->inbuf, cli->bufsize, 0, 0, &len);
-
-                if (!NT_STATUS_IS_OK(status)) {
-                        DEBUG(0, ("Read from server failed, maybe it closed "
-                                  "the connection\n"));
-
-                        finished = true;
-                        smb_readline_done();
-                        if (NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE)) {
-                                set_smb_read_error(&cli->smb_rw_error,
-                                                   SMB_READ_EOF);
-                                return;
-                        }
-
-                        if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
-                                set_smb_read_error(&cli->smb_rw_error,
-                                                   SMB_READ_TIMEOUT);
-                                return;
-                        }
-
-                        set_smb_read_error(&cli->smb_rw_error, SMB_READ_ERROR);
-                        return;
-                }
-                if(CVAL(cli->inbuf,0) != SMBkeepalive) {
-                        DEBUG(0, ("Read from server "
-                                "returned unexpected packet!\n"));
-                        return;
-                }
-
-                goto again;
-        }
-
-        /* Ping the server to keep the connection alive using SMBecho. */
-        {
-                NTSTATUS status;
-                unsigned char garbage[16];
-                memset(garbage, 0xf0, sizeof(garbage));
-                status = cli_echo(cli, 1, data_blob_const(garbage, sizeof(garbage)));
-
-                if (NT_STATUS_IS_OK(status)) {
-                        return;
-                }
-
-                if (!cli_state_is_connected(cli)) {
-                        DEBUG(0, ("SMBecho failed (%s). The connection is "
-                                "disconnected now\n", nt_errstr(status)));
-                        finished = true;
-                        smb_readline_done();
-                }
+        }
+
+        if (!cli_state_is_connected(cli)) {
+                DEBUG(0,("SMBecho failed (%s). The connection is "
+                         "disconnected now\n", nt_errstr(status)));
+                finished = true;
+                smb_readline_done();
         }
 }
@@ -4934 +5478 @@
 {
         int rc = 0;
-
-        cli = cli_cm_open(talloc_tos(), NULL,
-                        have_ip ? dest_ss_str : desthost,
-                        service, auth_info, true, smb_encrypt,
-                        max_protocol, port, name_type);
-        if (!cli) {
-                return 1;
-        }
+        NTSTATUS status;
+
+        status = cli_cm_open(talloc_tos(), NULL,
+                             have_ip ? dest_ss_str : desthost,
+                             service, auth_info, true, smb_encrypt,
+                             max_protocol, port, name_type, &cli);
+        if (!NT_STATUS_IS_OK(status)) {
+                return 1;
+        }
+
+        cli_set_timeout(cli, io_timeout*1000);
 
         if (base_directory && *base_directory) {
@@ -4967 +5514 @@
 static int do_host_query(const char *query_host)
 {
-        cli = cli_cm_open(talloc_tos(), NULL,
-                        have_ip ? dest_ss_str : query_host, "IPC$", auth_info, true, smb_encrypt,
-                        max_protocol, port, name_type);
-        if (!cli)
-                return 1;
-
+        NTSTATUS status;
+
+        status = cli_cm_open(talloc_tos(), NULL,
+                             have_ip ? dest_ss_str : query_host,
+                             "IPC$", auth_info, true, smb_encrypt,
+                             max_protocol, port, name_type, &cli);
+        if (!NT_STATUS_IS_OK(status)) {
+                return 1;
+        }
+
+        cli_set_timeout(cli, io_timeout*1000);
         browse_host(true);
 
@@ -4987 +5539 @@
         }
 
-        if (port != 139) {
+        if (port != NBT_SMB_PORT) {
 
                 /* Workgroups simply don't make sense over anything
@@ -4993 +5545 @@
 
                 cli_shutdown(cli);
-                cli = cli_cm_open(talloc_tos(), NULL,
-                                have_ip ? dest_ss_str : query_host, "IPC$",
-                                auth_info, true, smb_encrypt,
-                                max_protocol, 139, name_type);
+                status = cli_cm_open(talloc_tos(), NULL,
+                                     have_ip ? dest_ss_str : query_host,
+                                     "IPC$", auth_info, true, smb_encrypt,
+                                     max_protocol, NBT_SMB_PORT, name_type,
+                                     &cli);
+                if (!NT_STATUS_IS_OK(status)) {
+                        cli = NULL;
+                }
         }
 
         if (cli == NULL) {
                 d_printf("NetBIOS over TCP disabled -- no workgroup available\n");
-                return 1;
-        }
-
+                return 0;
+        }
+
+        cli_set_timeout(cli, io_timeout*1000);
         list_servers(lp_workgroup());
 
@@ -5017 +5574 @@
 static int do_tar_op(const char *base_directory)
 {
-        int ret;
+        struct tar *tar_ctx = tar_get_ctx();
+        int ret = 0;
 
         /* do we already have a connection? */
         if (!cli) {
-                cli = cli_cm_open(talloc_tos(), NULL,
-                        have_ip ? dest_ss_str : desthost,
-                        service, auth_info, true, smb_encrypt,
-                        max_protocol, port, name_type);
-                if (!cli)
-                        return 1;
-        }
-
-        recurse=true;
+                NTSTATUS status;
+
+                status = cli_cm_open(talloc_tos(), NULL,
+                                     have_ip ? dest_ss_str : desthost,
+                                     service, auth_info, true, smb_encrypt,
+                                     max_protocol, port, name_type, &cli);
+                if (!NT_STATUS_IS_OK(status)) {
+            ret = 1;
+            goto out;
+                }
+                cli_set_timeout(cli, io_timeout*1000);
+        }
+
+        recurse = true;
 
         if (base_directory && *base_directory)  {
                 ret = do_cd(base_directory);
                 if (ret) {
-                        cli_shutdown(cli);
-                        return ret;
-                }
-        }
-
-        ret=process_tar();
-
+            goto out_cli;
+                }
+        }
+
+        ret = tar_process(tar_ctx);
+
+ out_cli:
         cli_shutdown(cli);
-
-        return(ret);
+ out:
+        return ret;
 }
 
@@ -5052 +5615 @@
 static int do_message_op(struct user_auth_info *a_info)
 {
-        struct sockaddr_storage ss;
-        struct nmb_name called, calling;
-        fstring server_name;
-        char name_type_hex[10];
-        int msg_port;
         NTSTATUS status;
 
-        make_nmb_name(&calling, calling_name, 0x0);
-        make_nmb_name(&called , desthost, name_type);
-
-        fstrcpy(server_name, desthost);
-        snprintf(name_type_hex, sizeof(name_type_hex), "#%X", name_type);
-        fstrcat(server_name, name_type_hex);
-
-        zero_sockaddr(&ss);
-        if (have_ip)
-                ss = dest_ss;
-
-        /* we can only do messages over port 139 (to windows clients at least) */
-
-        msg_port = port ? port : 139;
-
-        if (!(cli=cli_initialise())) {
-                d_printf("Connection to %s failed\n", desthost);
-                return 1;
-        }
-        cli_set_port(cli, msg_port);
-
-        status = cli_connect(cli, server_name, &ss);
+        status = cli_connect_nb(desthost, have_ip ? &dest_ss : NULL,
+                                port ? port : NBT_SMB_PORT, name_type,
+                                lp_netbios_name(), SMB_SIGNING_DEFAULT, 0, &cli);
         if (!NT_STATUS_IS_OK(status)) {
                 d_printf("Connection to %s failed. Error %s\n", desthost, nt_errstr(status));
@@ -5086 +5625 @@
         }
 
-        if (!cli_session_request(cli, &calling, &called)) {
-                d_printf("session request failed\n");
-                cli_shutdown(cli);
-                return 1;
-        }
-
+        cli_set_timeout(cli, io_timeout*1000);
         send_message(get_cmdline_auth_info_username(a_info));
         cli_shutdown(cli);
@@ -5102 +5636 @@
 ****************************************************************************/
 
- int main(int argc,char *argv[])
-{
+int main(int argc,char *argv[])
+{
+        const char **const_argv = discard_const_p(const char *, argv);
         char *base_directory = NULL;
         int opt;
@@ -5112 +5647 @@
         char *p;
         int rc = 0;
-        fstring new_workgroup;
         bool tar_opt = false;
         bool service_opt = false;
+        struct tar *tar_ctx = tar_get_ctx();
+
         struct poptOption long_options[] = {
                 POPT_AUTOHELP
@@ -5126 +5662 @@
                 { "tar", 'T', POPT_ARG_STRING, NULL, 'T', "Command line tar", "<c|x>IXFqgbNan" },
                 { "directory", 'D', POPT_ARG_STRING, NULL, 'D', "Start from directory", "DIR" },
-                { "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" }, 
+                { "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" },
                 { "send-buffer", 'b', POPT_ARG_INT, &io_bufsize, 'b', "Changes the transmit/send buffer", "BYTES" },
+                { "timeout", 't', POPT_ARG_INT, &io_timeout, 'b', "Changes the per-operation timeout", "SECONDS" },
                 { "port", 'p', POPT_ARG_INT, &port, 'p', "Port to connect to", "PORT" },
                 { "grepable", 'g', POPT_ARG_NONE, NULL, 'g', "Produce grepable output" },
@@ -5142 +5679 @@
         }
 
-        /* initialize the workgroup name so we can determine whether or
-           not it was set by a command line option */
-
-        set_global_myworkgroup( "" );
-        set_global_myname( "" );
-
         /* set default debug level to 1 regardless of what smb.conf sets */
         setup_logging( "smbclient", DEBUG_DEFAULT_STDERR );
-        load_case_tables();
+        smb_init_locale();
 
         lp_set_cmdline("log level", "1");
@@ -5161 +5692 @@
 
         /* skip argv(0) */
-        pc = poptGetContext("smbclient", argc, (const char **) argv, long_options, 0);
+        pc = poptGetContext("smbclient", argc, const_argv, long_options, 0);
         poptSetOtherOptionHelp(pc, "service <password>");
-
-        lp_set_in_client(true); /* Make sure that we tell lp_load we are */
 
         while ((opt = poptGetNextOpt(pc)) != -1) {
@@ -5193 +5722 @@
                                                        poptGetArg(pc));
                 }
+
 
                 switch (opt) {
@@ -5206 +5736 @@
                         }
                         if( !port )
-                                port = 139;
+                                port = NBT_SMB_PORT;
                         message = true;
                         break;
@@ -5230 +5760 @@
                         break;
                 case 'm':
-                        max_protocol = interpret_protocol(poptGetOptArg(pc), max_protocol);
+                        lp_set_cmdline("client max protocol", poptGetOptArg(pc));
                         break;
                 case 'T':
@@ -5237 +5767 @@
                         {
                                 int i;
+
                                 for (i = 1; i < argc; i++) {
                                         if (strncmp("-T", argv[i],2)==0)
@@ -5242 +5773 @@
                                 }
                                 i++;
-                                if (!tar_parseargs(argc, argv, poptGetOptArg(pc), i)) {
+                                if (tar_parse_args(tar_ctx, poptGetOptArg(pc),
+                                                   const_argv + i, argc - i)) {
                                         poptPrintUsage(pc, stderr, 0);
                                         exit(1);
@@ -5293 +5825 @@
         }
 
-        /* save the workgroup...
-
-           FIXME!! do we need to do this for other options as well
-           (or maybe a generic way to keep lp_load() from overwriting
-           everything)?  */
-
-        fstrcpy( new_workgroup, lp_workgroup() );
-        calling_name = talloc_strdup(frame, global_myname() );
-        if (!calling_name) {
-                exit(ENOMEM);
-        }
-
         if ( override_logfile )
-                setup_logging( lp_logfile(), DEBUG_FILE );
-
-        if (!lp_load(get_dyn_CONFIGFILE(),true,false,false,true)) {
+                setup_logging( lp_logfile(talloc_tos()), DEBUG_FILE );
+
+        if (!lp_load_client(get_dyn_CONFIGFILE())) {
                 fprintf(stderr, "%s: Can't load %s - run testparm to debug it\n",
                         argv[0], get_dyn_CONFIGFILE());
@@ -5338 +5858 @@
         }
 
-        if ( strlen(new_workgroup) != 0 ) {
-                set_global_myworkgroup( new_workgroup );
-        }
-
-        if ( strlen(calling_name) != 0 ) {
-                set_global_myname( calling_name );
-        } else {
-                TALLOC_FREE(calling_name);
-                calling_name = talloc_strdup(frame, global_myname() );
-        }
-
         smb_encrypt = get_cmdline_auth_info_smb_encrypt(auth_info);
         if (!init_names()) {
@@ -5356 +5865 @@
 
         if(new_name_resolve_order)
-                lp_set_name_resolve_order(new_name_resolve_order);
-
-        if (!tar_type && !query_host && !service && !message) {
+                lp_set_cmdline("name resolve order", new_name_resolve_order);
+
+        if (!tar_to_process(tar_ctx) && !query_host && !service && !message) {
                 poptPrintUsage(pc, stderr, 0);
                 exit(1);
@@ -5364 +5873 @@
 
         poptFreeContext(pc);
+        popt_burn_cmdline_password(argc, argv);
 
         DEBUG(3,("Client started (version %s).\n", samba_version_string()));
@@ -5370 +5880 @@
         set_cmdline_auth_info_getpass(auth_info);
 
-        if (tar_type) {
+        max_protocol = lp_client_max_protocol();
+
+        if (tar_to_process(tar_ctx)) {
                 if (cmdstr)
                         process_command_string(cmdstr);
-                return do_tar_op(base_directory);
-        }
-
-        if (query_host && *query_host) {
+                rc = do_tar_op(base_directory);
+        } else if (query_host && *query_host) {
                 char *qhost = query_host;
                 char *slash;
@@ -5394 +5904 @@
                 }
 
-                return do_host_query(qhost);
-        }
-
-        if (message) {
-                return do_message_op(auth_info);
-        }
-
-        if (process(base_directory)) {
-                return 1;
+                rc = do_host_query(qhost);
+        } else if (message) {
+                rc = do_message_op(auth_info);
+        } else if (process(base_directory)) {
+                rc = 1;
         }
 

vendor/current/source3/client/client_proto.h

@@ -27 +27 @@
 struct file_info;
 
+enum {
+        ATTR_UNSET,
+        ATTR_SET,
+};
+
 /* The following definitions come from client/client.c  */
 
@@ -32 +37 @@
 const char *client_set_cur_dir(const char *newdir);
 NTSTATUS do_list(const char *mask,
-                        uint16 attribute,
+                        uint16_t attribute,
                         NTSTATUS (*fn)(struct cli_state *cli_state, struct file_info *,
                                    const char *dir),
                         bool rec,
                         bool dirs);
+int set_remote_attr(const char *filename, uint16_t new_attr, int mode);
 int cmd_iosize(void);
-
-/* The following definitions come from client/clitar.c  */
-
-int cmd_block(void);
-int cmd_tarmode(void);
-int cmd_setmode(void);
-int cmd_tar(void);
-int process_tar(void);
-int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind);
 
 /* The following definitions come from client/dnsbrowse.c  */

vendor/current/source3/client/clitar.c

@@ -1 +1 @@
 /*
    Unix SMB/CIFS implementation.
-   Tar Extensions
-   Copyright (C) Ricky Poulten 1995-1998
-   Copyright (C) Richard Sharpe 1998
+   Tar backup command extension
+   Copyright (C) Aurélien Aptel 2013
 
    This program is free software; you can redistribute it and/or modify
@@ -18 +17 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-/* The following changes developed by Richard Sharpe for Canon Information
-   Systems Research Australia (CISRA)
-
-   1. Restore can now restore files with long file names
-   2. Save now saves directory information so that we can restore
-      directory creation times
-   3. tar now accepts both UNIX path names and DOS path names. I prefer
-      those lovely /'s to those UGLY \'s :-)
-   4. the files to exclude can be specified as a regular expression by adding
-      an r flag to the other tar flags. Eg:
-
-         -TcrX file.tar "*.(obj|exe)"
-
-      will skip all .obj and .exe files
-*/
-
+
+/**
+ * # General overview of the tar extension
+ *
+ * All tar_xxx() functions work on a `struct tar` which store most of
+ * the context of the backup process.
+ *
+ * The current tar context can be accessed via the global variable
+ * `tar_ctx`. It's publicly exported as an opaque handle via
+ * tar_get_ctx().
+ *
+ * A tar context is first configured through tar_parse_args() which
+ * can be called from either the CLI (in client.c) or the interactive
+ * session (via the cmd_tar() callback).
+ *
+ * Once the configuration is done (successfully), the context is ready
+ * for processing and tar_to_process() returns true.
+ *
+ * The next step is to call tar_process() which dispatch the
+ * processing to either tar_create() or tar_extract(), depending on
+ * the context.
+ *
+ * ## Archive creation
+ *
+ * tar_create() creates an archive using the libarchive API then
+ *
+ * - iterates on the requested paths if the context is in inclusion
+ *   mode with tar_create_from_list()
+ *
+ * - or iterates on the whole share (starting from the current dir) if
+ *   in exclusion mode or if no specific path were requested
+ *
+ * The do_list() function from client.c is used to list recursively
+ * the share. In particular it takes a DOS path mask (eg. \mydir\*)
+ * and a callback function which will be called with each file name
+ * and attributes. The tar callback function is get_file_callback().
+ *
+ * The callback function checks whether the file should be skipped
+ * according the the configuration via tar_create_skip_path(). If it's
+ * not skipped it's downloaded and written to the archive in
+ * tar_get_file().
+ *
+ * ## Archive extraction
+ *
+ * tar_extract() opens the archive and iterates on each file in
+ * it. For each file tar_extract_skip_path() checks whether it should
+ * be skipped according to the config. If it's not skipped it's
+ * uploaded on the server in tar_send_file().
+ */
 
 #include "includes.h"
 #include "system/filesys.h"
-#include "clitar.h"
 #include "client/client_proto.h"
+#include "client/clitar_proto.h"
 #include "libsmb/libsmb.h"
 
-static int clipfind(char **aret, int ret, char *tok);
-
-typedef struct file_info_struct file_info2;
-
-struct file_info_struct {
-        SMB_OFF_T size;
-        uint16 mode;
-        uid_t uid;
-        gid_t gid;
-        /* These times are normally kept in GMT */
-        struct timespec mtime_ts;
-        struct timespec atime_ts;
-        struct timespec ctime_ts;
-        char *name;     /* This is dynamically allocated */
-        file_info2 *next, *prev;  /* Used in the stack ... */
+#ifdef HAVE_LIBARCHIVE
+
+#include <archive.h>
+#include <archive_entry.h>
+
+/* prepend module name and line number to debug messages */
+#define DBG(a, b) (DEBUG(a, ("tar:%-4d ", __LINE__)), DEBUG(a, b))
+
+/* preprocessor magic to stringify __LINE__ (int) */
+#define STR1(x) #x
+#define STR2(x) STR1(x)
+
+/**
+ * Number of byte in a block unit.
+ */
+#define TAR_BLOCK_UNIT 512
+
+/**
+ * Default tar block size in TAR_BLOCK_UNIT.
+ */
+#define TAR_DEFAULT_BLOCK_SIZE 20
+
+/**
+ * Maximum value for the blocksize field
+ */
+#define TAR_MAX_BLOCK_SIZE 0xffff
+
+/**
+ * Size of the buffer used when downloading a file
+ */
+#define TAR_CLI_READ_SIZE 0xff00
+
+#define TAR_DO_LIST_ATTR (FILE_ATTRIBUTE_DIRECTORY \
+                          | FILE_ATTRIBUTE_SYSTEM  \
+                          | FILE_ATTRIBUTE_HIDDEN)
+
+
+enum tar_operation {
+        TAR_NO_OPERATION,
+        TAR_CREATE,    /* c flag */
+        TAR_EXTRACT,   /* x flag */
 };
 
-typedef struct {
-        file_info2 *top;
-        int items;
-} stack;
-
-#define SEPARATORS " \t\n\r"
-extern time_t newer_than;
-extern struct cli_state *cli;
-
-/* These defines are for the do_setrattr routine, to indicate
- * setting and reseting of file attributes in the function call */
-#define ATTRSET 1
-#define ATTRRESET 0
-
-static uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
-
-#ifndef CLIENT_TIMEOUT
-#define CLIENT_TIMEOUT (30*1000)
-#endif
-
-static char *tarbuf, *buffer_p;
-static int tp, ntarf, tbufsiz;
-static double ttarf;
-/* Incremental mode */
-static bool tar_inc=False;
-/* Reset archive bit */
-static bool tar_reset=False;
-/* Include / exclude mode (true=include, false=exclude) */
-static bool tar_excl=True;
-/* use regular expressions for search on file names */
-static bool tar_re_search=False;
-/* Do not dump anything, just calculate sizes */
-static bool dry_run=False;
-/* Dump files with System attribute */
-static bool tar_system=True;
-/* Dump files with Hidden attribute */
-static bool tar_hidden=True;
-/* Be noisy - make a catalogue */
-static bool tar_noisy=True;
-static bool tar_real_noisy=False;  /* Don't want to be really noisy by default */
-
-char tar_type='\0';
-static char **cliplist=NULL;
-static int clipn=0;
-static bool must_free_cliplist = False;
-extern const char *cmd_ptr;
-
-extern bool lowercase;
-extern uint16 cnum;
-extern bool readbraw_supported;
-extern int max_xmit;
-extern int get_total_time_ms;
-extern int get_total_size;
-
-static int blocksize=20;
-static int tarhandle;
-
-static void writetarheader(int f,  const char *aname, uint64_t size, time_t mtime,
-                           const char *amode, unsigned char ftype);
-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);
-static int dotarbuf(int f, char *b, int n);
-static void dozerobuf(int f, int n);
-static void dotareof(int f);
-static void initarbuf(void);
-
-/* restore functions */
-static long readtarheader(union hblock *hb, file_info2 *finfo, const char *prefix);
-static long unoct(char *p, int ndgs);
-static void do_tarput(void);
-static void unfixtarname(char *tptr, char *fp, int l, bool first);
-
-/*
- * tar specific utitlities
- */
-
-/*******************************************************************
-Create  a string of size size+1 (for the null)
-*******************************************************************/
-
-static char *string_create_s(int size)
-{
-        char *tmp;
-
-        tmp = (char *)SMB_MALLOC(size+1);
-
-        if (tmp == NULL) {
-                DEBUG(0, ("Out of memory in string_create_s\n"));
-        }
-
-        return(tmp);
-}
-
-/****************************************************************************
-Write a tar header to buffer
-****************************************************************************/
-
-static void writetarheader(int f, const char *aname, uint64_t size, time_t mtime,
-                           const char *amode, unsigned char ftype)
-{
-        union hblock hb;
-        int i, chk, l;
-        char *jp;
-
-        DEBUG(5, ("WriteTarHdr, Type = %c, Size= %.0f, Name = %s\n", ftype, (double)size, aname));
-
-        memset(hb.dummy, 0, sizeof(hb.dummy));
-
-        l=strlen(aname);
-        /* We will be prepending a '.' in fixtarheader so use +2 to
-         * take care of the . and terminating zero. JRA.
-         */
-        if (l+2 >= NAMSIZ) {
-                /* write a GNU tar style long header */
-                char *b;
-                b = (char *)SMB_MALLOC(l+TBLOCK+100);
-                if (!b) {
-                        DEBUG(0,("out of memory\n"));
-                        exit(1);
-                }
-                writetarheader(f, "/./@LongLink", l+2, 0, "     0 \0", 'L');
-                memset(b, 0, l+TBLOCK+100);
-                fixtarname(b, aname, l+2);
-                i = strlen(b)+1;
-                DEBUG(5, ("File name in tar file: %s, size=%d, \n", b, (int)strlen(b)));
-                dotarbuf(f, b, TBLOCK*(((i-1)/TBLOCK)+1));
-                SAFE_FREE(b);
-        }
-
-        fixtarname(hb.dbuf.name, aname, (l+2 >= NAMSIZ) ? NAMSIZ : l + 2);
-
-        if (lowercase)
-                strlower_m(hb.dbuf.name);
-
-        /* write out a "standard" tar format header */
-
-        hb.dbuf.name[NAMSIZ-1]='\0';
-        safe_strcpy(hb.dbuf.mode, amode, sizeof(hb.dbuf.mode)-1);
-        oct_it((uint64_t)0, 8, hb.dbuf.uid);
-        oct_it((uint64_t)0, 8, hb.dbuf.gid);
-        oct_it((uint64_t) size, 13, hb.dbuf.size);
-        if (size > (uint64_t)077777777777LL) {
-                /* This is a non-POSIX compatible extention to store files
-                        greater than 8GB. */
-
-                memset(hb.dbuf.size, 0, 4);
-                hb.dbuf.size[0]=128;
-                for (i = 8; i; i--) {
-                        hb.dbuf.size[i+3] = size & 0xff;
-                        size >>= 8;
-                }
-        }
-        oct_it((uint64_t) mtime, 13, hb.dbuf.mtime);
-        memcpy(hb.dbuf.chksum, "        ", sizeof(hb.dbuf.chksum));
-        memset(hb.dbuf.linkname, 0, NAMSIZ);
-        hb.dbuf.linkflag=ftype;
-
-        for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;)
-                chk+=(0xFF & *jp++);
-
-        oct_it((uint64_t) chk, 8, hb.dbuf.chksum);
-        hb.dbuf.chksum[6] = '\0';
-
-        (void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
-}
-
-/****************************************************************************
-Read a tar header into a hblock structure, and validate
-***************************************************************************/
-
-static long readtarheader(union hblock *hb, file_info2 *finfo, const char *prefix)
-{
-        long chk, fchk;
+enum tar_selection {
+        TAR_NO_SELECTION,
+        TAR_INCLUDE,       /* I and F flag, default */
+        TAR_EXCLUDE,       /* X flag */
+};
+
+struct tar {
+        TALLOC_CTX *talloc_ctx;
+
+        /* in state that needs/can be processed? */
+        bool to_process;
+
+        /* flags */
+        struct tar_mode {
+                enum tar_operation operation; /* create, extract */
+                enum tar_selection selection; /* include, exclude */
+                int blocksize;    /* size in TAR_BLOCK_UNIT of a tar file block */
+                bool hidden;      /* backup hidden file? */
+                bool system;      /* backup system file? */
+                bool incremental; /* backup _only_ archived file? */
+                bool reset;       /* unset archive bit? */
+                bool dry;         /* don't write tar file? */
+                bool regex;       /* XXX: never actually using regex... */
+                bool verbose;     /* XXX: ignored */
+        } mode;
+
+        /* nb of bytes received */
+        uint64_t total_size;
+
+        /* path to tar archive name */
+        char *tar_path;
+
+        /* list of path to include or exclude */
+        char **path_list;
+        int path_list_size;
+
+        /* archive handle */
+        struct archive *archive;
+};
+
+/**
+ * Global context imported in client.c when needed.
+ *
+ * Default options.
+ */
+struct tar tar_ctx = {
+        .mode.selection   = TAR_INCLUDE,
+        .mode.blocksize   = TAR_DEFAULT_BLOCK_SIZE,
+        .mode.hidden      = true,
+        .mode.system      = true,
+        .mode.incremental = false,
+        .mode.reset       = false,
+        .mode.dry         = false,
+        .mode.regex       = false,
+        .mode.verbose     = false,
+};
+
+/* tar, local function */
+static int tar_create(struct tar* t);
+static int tar_create_from_list(struct tar *t);
+static int tar_extract(struct tar *t);
+static int tar_read_inclusion_file(struct tar *t, const char* filename);
+static int tar_send_file(struct tar *t, struct archive_entry *entry);
+static int tar_set_blocksize(struct tar *t, int size);
+static int tar_set_newer_than(struct tar *t, const char *filename);
+static NTSTATUS tar_add_selection_path(struct tar *t, const char *path);
+static void tar_dump(struct tar *t);
+static NTSTATUS tar_extract_skip_path(struct tar *t,
+                                      struct archive_entry *entry,
+                                      bool *_skip);
+static TALLOC_CTX *tar_reset_mem_context(struct tar *t);
+static void tar_free_mem_context(struct tar *t);
+static NTSTATUS tar_create_skip_path(struct tar *t,
+                                     const char *fullpath,
+                                     const struct file_info *finfo,
+                                     bool *_skip);
+
+static NTSTATUS tar_path_in_list(struct tar *t, const char *path,
+                                 bool reverse, bool *_is_in_list);
+
+static int tar_get_file(struct tar *t,
+                        const char *full_dos_path,
+                        struct file_info *finfo);
+
+static NTSTATUS get_file_callback(struct cli_state *cli,
+                                  struct file_info *finfo,
+                                  const char *dir);
+
+/* utilities */
+static char *fix_unix_path(char *path, bool removeprefix);
+static NTSTATUS path_base_name(TALLOC_CTX *ctx, const char *path, char **_base);
+static const char* skip_useless_char_in_path(const char *p);
+static int make_remote_path(const char *full_path);
+static int max_token (const char *str);
+static NTSTATUS is_subpath(const char *sub, const char *full,
+                           bool *_subpath_match);
+
+/**
+ * tar_get_ctx - retrieve global tar context handle
+ */
+struct tar *tar_get_ctx()
+{
+        return &tar_ctx;
+}
+
+/**
+ * cmd_block - interactive command to change tar blocksize
+ *
+ * Read a size from the client command line and update the current
+ * blocksize.
+ */
+int cmd_block(void)
+{
+        /* XXX: from client.c */
+        const extern char *cmd_ptr;
+        char *buf;
+        int err = 0;
+        bool ok;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        ok = next_token_talloc(ctx, &cmd_ptr, &buf, NULL);
+        if (!ok) {
+                DBG(0, ("blocksize <n>\n"));
+                err = 1;
+                goto out;
+        }
+
+        ok = tar_set_blocksize(&tar_ctx, atoi(buf));
+        if (ok) {
+                DBG(0, ("invalid blocksize\n"));
+                err = 1;
+                goto out;
+        }
+
+        DBG(2, ("blocksize is now %d\n", tar_ctx.mode.blocksize));
+
+out:
+        talloc_free(ctx);
+        return err;
+}
+
+/**
+ * cmd_tarmode - interactive command to change tar behaviour
+ *
+ * Read one or more modes from the client command line and update the
+ * current tar mode.
+ */
+int cmd_tarmode(void)
+{
+        const extern char *cmd_ptr;
+        char *buf;
         int i;
-        char *jp;
-
-        /*
-         * read in a "standard" tar format header - we're not that interested
-         * in that many fields, though
-         */
-
-        /* check the checksum */
-        for (chk=0, i=sizeof(hb->dummy), jp=hb->dummy; --i>=0;)
-                chk+=(0xFF & *jp++);
-
-        if (chk == 0)
-                return chk;
-
-        /* compensate for blanks in chksum header */
-        for (i=sizeof(hb->dbuf.chksum), jp=hb->dbuf.chksum; --i>=0;)
-                chk-=(0xFF & *jp++);
-
-        chk += ' ' * sizeof(hb->dbuf.chksum);
-
-        fchk=unoct(hb->dbuf.chksum, sizeof(hb->dbuf.chksum));
-
-        DEBUG(5, ("checksum totals chk=%ld fchk=%ld chksum=%s\n",
-                        chk, fchk, hb->dbuf.chksum));
-
-        if (fchk != chk) {
-                DEBUG(0, ("checksums don't match %ld %ld\n", fchk, chk));
-                dump_data(5, (uint8 *)hb - TBLOCK, TBLOCK *3);
-                return -1;
-        }
-
-        if ((finfo->name = string_create_s(strlen(prefix) + strlen(hb -> dbuf.name) + 3)) == NULL) {
-                DEBUG(0, ("Out of space creating file_info2 for %s\n", hb -> dbuf.name));
-                return(-1);
-        }
-
-        safe_strcpy(finfo->name, prefix, strlen(prefix) + strlen(hb -> dbuf.name) + 3);
-
-        /* use l + 1 to do the null too; do prefix - prefcnt to zap leading slash */
-        unfixtarname(finfo->name + strlen(prefix), hb->dbuf.name,
-                strlen(hb->dbuf.name) + 1, True);
-
-        /* can't handle some links at present */
-        if ((hb->dbuf.linkflag != '0') && (hb -> dbuf.linkflag != '5')) {
-                if (hb->dbuf.linkflag == 0) {
-                        DEBUG(6, ("Warning: NULL link flag (gnu tar archive ?) %s\n",
-                                finfo->name));
-                } else {
-                        if (hb -> dbuf.linkflag == 'L') { /* We have a longlink */
-                                /* Do nothing here at the moment. do_tarput will handle this
-                                        as long as the longlink gets back to it, as it has to advance 
-                                        the buffer pointer, etc */
-                        } else {
-                                DEBUG(0, ("this tar file appears to contain some kind \
-of link other than a GNUtar Longlink - ignoring\n"));
-                                return -2;
-                        }
-                }
-        }
-
-        if ((unoct(hb->dbuf.mode, sizeof(hb->dbuf.mode)) & S_IFDIR) ||
-                                (*(finfo->name+strlen(finfo->name)-1) == '\\')) {
-                finfo->mode=FILE_ATTRIBUTE_DIRECTORY;
-        } else {
-                finfo->mode=0; /* we don't care about mode at the moment, we'll
-                                * just make it a regular file */
-        }
-
-        /*
-         * Bug fix by richard@sj.co.uk
-         *
-         * REC: restore times correctly (as does tar)
-         * We only get the modification time of the file; set the creation time
-         * from the mod. time, and the access time to current time
-         */
-        finfo->mtime_ts = finfo->ctime_ts =
-                convert_time_t_to_timespec((time_t)strtol(hb->dbuf.mtime, NULL, 8));
-        finfo->atime_ts = convert_time_t_to_timespec(time(NULL));
-        if ((hb->dbuf.size[0] & 0xff) == 0x80) {
-                /* This is a non-POSIX compatible extention to extract files
-                        greater than 8GB. */
-                finfo->size = 0;
-                for (i = 0; i < 8; i++) {
-                        finfo->size <<= 8;
-                        finfo->size |= hb->dbuf.size[i+4] & 0xff;
-                }
-        } else {
-                finfo->size = unoct(hb->dbuf.size, sizeof(hb->dbuf.size));
-        }
-
-        return True;
-}
-
-/****************************************************************************
-Write out the tar buffer to tape or wherever
-****************************************************************************/
-
-static int dotarbuf(int f, char *b, int n)
-{
-        int fail=1, writ=n;
-
-        if (dry_run) {
-                return writ;
-        }
-        /* This routine and the next one should be the only ones that do write()s */
-        if (tp + n >= tbufsiz) {
-                int diff;
-
-                diff=tbufsiz-tp;
-                memcpy(tarbuf + tp, b, diff);
-                fail=fail && (1+sys_write(f, tarbuf, tbufsiz));
-                n-=diff;
-                b+=diff;
-                tp=0;
-
-                while (n >= tbufsiz) {
-                        fail=fail && (1 + sys_write(f, b, tbufsiz));
-                        n-=tbufsiz;
-                        b+=tbufsiz;
-                }
-        }
-
-        if (n>0) {
-                memcpy(tarbuf+tp, b, n);
-                tp+=n;
-        }
-
-        return(fail ? writ : 0);
-}
-
-/****************************************************************************
-Write zeros to buffer / tape
-****************************************************************************/
-
-static void dozerobuf(int f, int n)
-{
-        /* short routine just to write out n zeros to buffer -
-         * used to round files to nearest block
-         * and to do tar EOFs */
-
-        if (dry_run)
-                return;
-
-        if (n+tp >= tbufsiz) {
-                memset(tarbuf+tp, 0, tbufsiz-tp);
-                if (sys_write(f, tarbuf, tbufsiz) != tbufsiz) {
-                        DEBUG(0, ("dozerobuf: sys_write fail\n"));
-                        return;
-                }
-                memset(tarbuf, 0, (tp+=n-tbufsiz));
-        } else {
-                memset(tarbuf+tp, 0, n);
-                tp+=n;
-        }
-}
-
-/****************************************************************************
-Malloc tape buffer
-****************************************************************************/
-
-static void initarbuf(void)
-{
-        /* initialize tar buffer */
-        tbufsiz=blocksize*TBLOCK;
-        tarbuf=(char *)SMB_MALLOC(tbufsiz);      /* FIXME: We might not get the buffer */
-
-        /* reset tar buffer pointer and tar file counter and total dumped */
-        tp=0; ntarf=0; ttarf=0;
-}
-
-/****************************************************************************
-Write two zero blocks at end of file
-****************************************************************************/
-
-static void dotareof(int f)
-{
-        SMB_STRUCT_STAT stbuf;
-        /* Two zero blocks at end of file, write out full buffer */
-
-        if (dry_run)
-                return;
-
-        (void) dozerobuf(f, TBLOCK);
-        (void) dozerobuf(f, TBLOCK);
-
-        if (sys_fstat(f, &stbuf, false) == -1) {
-                DEBUG(0, ("Couldn't stat file handle\n"));
-                return;
-        }
-
-        /* Could be a pipe, in which case S_ISREG should fail,
-                * and we should write out at full size */
-        if (tp > 0) {
-                size_t towrite = S_ISREG(stbuf.st_ex_mode) ? tp : tbufsiz;
-                if (sys_write(f, tarbuf, towrite) != towrite) {
-                        DEBUG(0,("dotareof: sys_write fail\n"));
-                }
-        }
-}
-
-/****************************************************************************
-(Un)mangle DOS pathname, make nonabsolute
-****************************************************************************/
-
-static void fixtarname(char *tptr, const char *fp, size_t l)
-{
-        /* add a '.' to start of file name, convert from ugly dos \'s in path
-         * to lovely unix /'s :-} */
-        *tptr++='.';
-        l--;
-
-        StrnCpy(tptr, fp, l-1);
-        string_replace(tptr, '\\', '/');
-}
-
-/****************************************************************************
-Convert from decimal to octal string
-****************************************************************************/
-
-static void oct_it (uint64_t value, int ndgs, char *p)
-{
-        /* Converts long to octal string, pads with leading zeros */
-
-        /* skip final null, but do final space */
-        --ndgs;
-        p[--ndgs] = ' ';
-
-        /* Loop does at least one digit */
-        do {
-                p[--ndgs] = '0' + (char) (value & 7);
-                value >>= 3;
-        } while (ndgs > 0 && value != 0);
-
-        /* Do leading zeros */
-        while (ndgs > 0)
-                p[--ndgs] = '0';
-}
-
-/****************************************************************************
-Convert from octal string to long
-***************************************************************************/
-
-static long unoct(char *p, int ndgs)
-{
-        long value=0;
-        /* Converts octal string to long, ignoring any non-digit */
-
-        while (--ndgs) {
-                if (isdigit((int)*p))
-                        value = (value << 3) | (long) (*p - '0');
-
-                p++;
-        }
-
-        return value;
-}
-
-/****************************************************************************
-Compare two strings in a slash insensitive way, allowing s1 to match s2
-if s1 is an "initial" string (up to directory marker).  Thus, if s2 is
-a file in any subdirectory of s1, declare a match.
-***************************************************************************/
-
-static int strslashcmp(char *s1, char *s2)
-{
-        char *s1_0=s1;
-
-        while(*s1 && *s2 && (*s1 == *s2 || tolower_m(*s1) == tolower_m(*s2) ||
-                                (*s1 == '\\' && *s2=='/') || (*s1 == '/' && *s2=='\\'))) {
-                s1++; s2++;
-        }
-
-        /* if s1 has a trailing slash, it compared equal, so s1 is an "initial" 
-                string of s2.
-        */
-        if (!*s1 && s1 != s1_0 && (*(s1-1) == '/' || *(s1-1) == '\\'))
-                return 0;
-
-        /* ignore trailing slash on s1 */
-        if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1))
-                return 0;
-
-        /* check for s1 is an "initial" string of s2 */
-        if ((*s2 == '/' || *s2 == '\\') && !*s1)
-                return 0;
-
-        return *s1-*s2;
-}
-
-/****************************************************************************
-Ensure a remote path exists (make if necessary)
-***************************************************************************/
-
-static bool ensurepath(const char *fname)
-{
-        /* *must* be called with buffer ready malloc'ed */
-        /* ensures path exists */
-
-        char *partpath, *ffname;
-        const char *p=fname;
-        char *basehack;
-        char *saveptr;
-
-        DEBUG(5, ( "Ensurepath called with: %s\n", fname));
-
-        partpath = string_create_s(strlen(fname));
-        ffname = string_create_s(strlen(fname));
-
-        if ((partpath == NULL) || (ffname == NULL)){
-                DEBUG(0, ("Out of memory in ensurepath: %s\n", fname));
-                SAFE_FREE(partpath);
-                SAFE_FREE(ffname);
-                return(False);
-        }
-
-        *partpath = 0;
-
-        /* fname copied to ffname so can strtok_r */
-
-        safe_strcpy(ffname, fname, strlen(fname));
-
-        /* do a `basename' on ffname, so don't try and make file name directory */
-        if ((basehack=strrchr_m(ffname, '\\')) == NULL) {
-                SAFE_FREE(partpath);
-                SAFE_FREE(ffname);
-                return True;
-        } else {
-                *basehack='\0';
-        }
-
-        p=strtok_r(ffname, "\\", &saveptr);
-
-        while (p) {
-                safe_strcat(partpath, p, strlen(fname) + 1);
-
-                if (!NT_STATUS_IS_OK(cli_chkpath(cli, partpath))) {
-                        if (!NT_STATUS_IS_OK(cli_mkdir(cli, partpath))) {
-                                SAFE_FREE(partpath);
-                                SAFE_FREE(ffname);
-                                DEBUG(0, ("Error mkdir %s\n", cli_errstr(cli)));
-                                return False;
-                        } else {
-                                DEBUG(3, ("mkdirhiering %s\n", partpath));
-                        }
-                }
-
-                safe_strcat(partpath, "\\", strlen(fname) + 1);
-                p = strtok_r(NULL, "/\\", &saveptr);
-        }
-
-        SAFE_FREE(partpath);
-        SAFE_FREE(ffname);
-        return True;
-}
-
-static int padit(char *buf, uint64_t bufsize, uint64_t padsize)
-{
-        int berr= 0;
-        int bytestowrite;
-
-        DEBUG(5, ("Padding with %0.f zeros\n", (double)padsize));
-        memset(buf, 0, (size_t)bufsize);
-        while( !berr && padsize > 0 ) {
-                bytestowrite= (int)MIN(bufsize, padsize);
-                berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite;
-                padsize -= bytestowrite;
-        }
-
-        return berr;
-}
-
-static void do_setrattr(char *name, uint16 attr, int set)
-{
-        uint16 oldattr;
-
-        if (!NT_STATUS_IS_OK(cli_getatr(cli, name, &oldattr, NULL, NULL))) {
-                return;
-        }
-
-        if (set == ATTRSET) {
-                attr |= oldattr;
-        } else {
-                attr = oldattr & ~attr;
-        }
-
-        if (!NT_STATUS_IS_OK(cli_setatr(cli, name, attr, 0))) {
-                DEBUG(1,("setatr failed: %s\n", cli_errstr(cli)));
-        }
-}
-
-/****************************************************************************
-append one remote file to the tar file
-***************************************************************************/
-
-static NTSTATUS do_atar(const char *rname_in, char *lname,
-                    struct file_info *finfo1)
-{
-        uint16_t fnum = (uint16_t)-1;
-        uint64_t nread=0;
-        char ftype;
-        file_info2 finfo;
-        bool shallitime=True;
-        char *data = NULL;
-        int read_size = 65520;
-        int datalen=0;
-        char *rname = NULL;
-        TALLOC_CTX *ctx = talloc_stackframe();
-        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;
-        }
-
-        ftype = '0'; /* An ordinary file ... */
-
-        ZERO_STRUCT(finfo);
-
-        finfo.size  = finfo1 -> size;
-        finfo.mode  = finfo1 -> mode;
-        finfo.uid   = finfo1 -> uid;
-        finfo.gid   = finfo1 -> gid;
-        finfo.mtime_ts = finfo1 -> mtime_ts;
-        finfo.atime_ts = finfo1 -> atime_ts;
-        finfo.ctime_ts = finfo1 -> ctime_ts;
-
-        if (dry_run) {
-                DEBUG(3,("skipping file %s of size %12.0f bytes\n", finfo1->name,
-                                (double)finfo.size));
-                shallitime=0;
-                ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
-                ntarf++;
-                goto cleanup;
-        }
-
-        rname = clean_name(ctx, rname_in);
-        if (!rname) {
-                status = NT_STATUS_NO_MEMORY;
-                goto cleanup;
-        }
-
-        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()));
-                goto cleanup;
-        }
-
-        finfo.name = string_create_s(strlen(rname));
-        if (finfo.name == NULL) {
-                DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n"));
-                status = NT_STATUS_NO_MEMORY;
-                goto cleanup;
-        }
-
-        safe_strcpy(finfo.name,rname, strlen(rname));
-
-        DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
-
-        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 & FILE_ATTRIBUTE_SYSTEM)) {
-                DEBUG(4, ("skipping %s - system bit is set\n", finfo.name));
-                shallitime=0;
-        } else if (!tar_hidden && (finfo.mode & FILE_ATTRIBUTE_HIDDEN)) {
-                DEBUG(4, ("skipping %s - hidden bit is set\n", finfo.name));
-                shallitime=0;
-        } else {
-                bool wrote_tar_header = False;
-
-                DEBUG(3,("getting file %s of size %.0f bytes as a tar file %s",
-                        finfo.name, (double)finfo.size, lname));
-
-                do {
-
-                        DEBUG(3,("nread=%.0f\n",(double)nread));
-
-                        datalen = cli_read(cli, fnum, data, nread, read_size);
-
-                        if (datalen == -1) {
-                                DEBUG(0,("Error reading file %s : %s\n", rname, cli_errstr(cli)));
-                                status = cli_nt_error(cli);
+        TALLOC_CTX *ctx;
+
+        struct {
+                const char *cmd;
+                bool *p;
+                bool value;
+        } table[] = {
+                {"full",      &tar_ctx.mode.incremental, false},
+                {"inc",       &tar_ctx.mode.incremental, true },
+                {"reset",     &tar_ctx.mode.reset,       true },
+                {"noreset",   &tar_ctx.mode.reset,       false},
+                {"system",    &tar_ctx.mode.system,      true },
+                {"nosystem",  &tar_ctx.mode.system,      false},
+                {"hidden",    &tar_ctx.mode.hidden,      true },
+                {"nohidden",  &tar_ctx.mode.hidden,      false},
+                {"verbose",   &tar_ctx.mode.verbose,     true },
+                {"noquiet",   &tar_ctx.mode.verbose,     true },
+                {"quiet",     &tar_ctx.mode.verbose,     false},
+                {"noverbose", &tar_ctx.mode.verbose,     false},
+        };
+
+        ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        while (next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
+                for (i = 0; i < ARRAY_SIZE(table); i++) {
+                        if (strequal(table[i].cmd, buf)) {
+                                *table[i].p = table[i].value;
                                 break;
                         }
-
-                        nread += datalen;
-
-                        /* Only if the first read succeeds, write out the tar header. */
-                        if (!wrote_tar_header) {
-                                /* write a tar header, don't bother with mode - just set to 100644 */
-                                writetarheader(tarhandle, rname, finfo.size,
-                                        finfo.mtime_ts.tv_sec, "100644 \0", ftype);
-                                wrote_tar_header = True;
+                }
+
+                if (i == ARRAY_SIZE(table))
+                        DBG(0, ("tarmode: unrecognised option %s\n", buf));
+        }
+
+        DBG(0, ("tarmode is now %s, %s, %s, %s, %s\n",
+                                tar_ctx.mode.incremental ? "incremental" : "full",
+                                tar_ctx.mode.system      ? "system"      : "nosystem",
+                                tar_ctx.mode.hidden      ? "hidden"      : "nohidden",
+                                tar_ctx.mode.reset       ? "reset"       : "noreset",
+                                tar_ctx.mode.verbose     ? "verbose"     : "quiet"));
+
+        talloc_free(ctx);
+        return 0;
+}
+
+/**
+ * cmd_tar - interactive command to start a tar backup/restoration
+ *
+ * Check presence of argument, parse them and handle the request.
+ */
+int cmd_tar(void)
+{
+        const extern char *cmd_ptr;
+        const char *flag;
+        const char **val;
+        char *buf;
+        int maxtok = max_token(cmd_ptr);
+        int i = 0;
+        int err = 0;
+        bool ok;
+        int rc;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        ok = next_token_talloc(ctx, &cmd_ptr, &buf, NULL);
+        if (!ok) {
+                DBG(0, ("tar <c|x>[IXFbganN] [options] <tar file> [path list]\n"));
+                err = 1;
+                goto out;
+        }
+
+        flag = buf;
+        val = talloc_array(ctx, const char *, maxtok);
+        if (val == NULL) {
+                err = 1;
+                goto out;
+        }
+
+        while (next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
+                val[i++] = buf;
+        }
+
+        rc = tar_parse_args(&tar_ctx, flag, val, i);
+        if (rc != 0) {
+                DBG(0, ("parse_args failed\n"));
+                err = 1;
+                goto out;
+        }
+
+        rc = tar_process(&tar_ctx);
+        if (rc != 0) {
+                DBG(0, ("tar_process failed\n"));
+                err = 1;
+                goto out;
+        }
+
+out:
+        talloc_free(ctx);
+        return err;
+}
+
+
+/**
+ * tar_parse_args - parse and set tar command line arguments
+ * @flag: string pointing to tar options
+ * @val: number of tar arguments
+ * @valsize: table of arguments after the flags (number of element in val)
+ *
+ * tar arguments work in a weird way. For each flag f that takes a
+ * value v, the user is supposed to type:
+ *
+ * on the CLI:
+ *   -Tf1f2f3 v1 v2 v3 TARFILE PATHS...
+ *
+ * in the interactive session:
+ *   tar f1f2f3 v1 v2 v3 TARFILE PATHS...
+ *
+ * @flag has only flags (eg. "f1f2f3") and @val has the arguments
+ * (values) following them (eg. ["v1", "v2", "v3", "TARFILE", "PATH1",
+ * "PATH2"]).
+ *
+ * There are only 2 flags that take an arg: b and N. The other flags
+ * just change the semantic of PATH or TARFILE.
+ *
+ * PATH can be a list of included/excluded paths, the path to a file
+ * containing a list of included/excluded paths to use (F flag). If no
+ * PATH is provided, the whole share is used (/).
+ */
+int tar_parse_args(struct tar* t,
+                   const char *flag,
+                   const char **val,
+                   int valsize)
+{
+        TALLOC_CTX *ctx;
+        bool do_read_list = false;
+        /* index of next value to use */
+        int ival = 0;
+        int rc;
+
+        if (t == NULL) {
+                DBG(0, ("Invalid tar context\n"));
+                return 1;
+        }
+
+        ctx = tar_reset_mem_context(t);
+        if (ctx == NULL) {
+                return 1;
+        }
+        /*
+         * Reset back some options - could be from interactive version
+         * all other modes are left as they are
+         */
+        t->mode.operation = TAR_NO_OPERATION;
+        t->mode.selection = TAR_NO_SELECTION;
+        t->mode.dry = false;
+        t->to_process = false;
+        t->total_size = 0;
+
+        while (flag[0] != '\0') {
+                switch(flag[0]) {
+                /* operation */
+                case 'c':
+                        if (t->mode.operation != TAR_NO_OPERATION) {
+                                printf("Tar must be followed by only one of c or x.\n");
+                                return 1;
                         }
-
-                        /* if file size has increased since we made file size query, truncate
-                                read so tar header for this file will be correct.
-                        */
-
-                        if (nread > finfo.size) {
-                                datalen -= nread - finfo.size;
-                                DEBUG(0,("File size change - truncating %s to %.0f bytes\n",
-                                                        finfo.name, (double)finfo.size));
+                        t->mode.operation = TAR_CREATE;
+                        break;
+                case 'x':
+                        if (t->mode.operation != TAR_NO_OPERATION) {
+                                printf("Tar must be followed by only one of c or x.\n");
+                                return 1;
                         }
-
-                        /* add received bits of file to buffer - dotarbuf will
-                        * write out in 512 byte intervals */
-
-                        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;
+                        t->mode.operation = TAR_EXTRACT;
+                        break;
+
+                        /* selection  */
+                case 'I':
+                        if (t->mode.selection != TAR_NO_SELECTION) {
+                                DBG(0,("Only one of I,X,F must be specified\n"));
+                                return 1;
                         }
-
-                        if ( (datalen == 0) && (finfo.size != 0) ) {
-                                status = NT_STATUS_UNSUCCESSFUL;
-                                DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
-                                break;
+                        t->mode.selection = TAR_INCLUDE;
+                        break;
+                case 'X':
+                        if (t->mode.selection != TAR_NO_SELECTION) {
+                                DBG(0,("Only one of I,X,F must be specified\n"));
+                                return 1;
                         }
-
-                        datalen=0;
-                } while ( nread < finfo.size );
-
-                if (wrote_tar_header) {
-                        /* pad tar file with zero's if we couldn't get entire file */
-                        if (nread < finfo.size) {
-                                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)) {
-                                        status = map_nt_error_from_unix(errno);
-                                        DEBUG(0,("Error writing tar file - %s\n", strerror(errno)));
-                                }
+                        t->mode.selection = TAR_EXCLUDE;
+                        break;
+                case 'F':
+                        if (t->mode.selection != TAR_NO_SELECTION) {
+                                DBG(0,("Only one of I,X,F must be specified\n"));
+                                return 1;
                         }
-
-                        /* round tar file to nearest block */
-                        if (finfo.size % TBLOCK)
-                                dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));
-
-                        ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
-                        ntarf++;
+                        t->mode.selection = TAR_INCLUDE;
+                        do_read_list = true;
+                        break;
+
+                        /* blocksize */
+                case 'b':
+                        if (ival >= valsize) {
+                                DBG(0, ("Option b must be followed by a blocksize\n"));
+                                return 1;
+                        }
+
+                        if (tar_set_blocksize(t, atoi(val[ival]))) {
+                                DBG(0, ("Option b must be followed by a valid blocksize\n"));
+                                return 1;
+                        }
+
+                        ival++;
+                        break;
+
+                        /* incremental mode */
+                case 'g':
+                        t->mode.incremental = true;
+                        break;
+
+                        /* newer than */
+                case 'N':
+                        if (ival >= valsize) {
+                                DBG(0, ("Option N must be followed by valid file name\n"));
+                                return 1;
+                        }
+
+                        if (tar_set_newer_than(t, val[ival])) {
+                                DBG(0,("Error setting newer-than time\n"));
+                                return 1;
+                        }
+
+                        ival++;
+                        break;
+
+                        /* reset mode */
+                case 'a':
+                        t->mode.reset = true;
+                        break;
+
+                        /* verbose */
+                case 'q':
+                        t->mode.verbose = true;
+                        break;
+
+                        /* regex match  */
+                case 'r':
+                        t->mode.regex = true;
+                        break;
+
+                        /* dry run mode */
+                case 'n':
+                        if (t->mode.operation != TAR_CREATE) {
+                                DBG(0, ("n is only meaningful when creating a tar-file\n"));
+                                return 1;
+                        }
+
+                        t->mode.dry = true;
+                        DBG(0, ("dry_run set\n"));
+                        break;
+
+                default:
+                        DBG(0,("Unknown tar option\n"));
+                        return 1;
+                }
+
+                flag++;
+        }
+
+        /* no selection given? default selection is include */
+        if (t->mode.selection == TAR_NO_SELECTION) {
+                t->mode.selection = TAR_INCLUDE;
+        }
+
+        if (valsize - ival < 1) {
+                DBG(0, ("No tar file given.\n"));
+                return 1;
+        }
+
+        /* handle TARFILE */
+        t->tar_path = talloc_strdup(ctx, val[ival]);
+        if (t->tar_path == NULL) {
+                return 1;
+        }
+        ival++;
+
+        /*
+         * Make sure that dbf points to stderr if we are using stdout for
+         * tar output
+         */
+        if (t->mode.operation == TAR_CREATE && strequal(t->tar_path, "-")) {
+                setup_logging("smbclient", DEBUG_STDERR);
+        }
+
+        /* handle PATHs... */
+
+        /* flag F -> read file list */
+        if (do_read_list) {
+                if (valsize - ival != 1) {
+                        DBG(0,("Option F must be followed by exactly one filename.\n"));
+                        return 1;
+                }
+
+                rc = tar_read_inclusion_file(t, val[ival]);
+                if (rc != 0) {
+                        return 1;
+                }
+                ival++;
+        /* otherwise store all the PATHs on the command line */
+        } else {
+                int i;
+                for (i = ival; i < valsize; i++) {
+                        NTSTATUS status;
+                        status = tar_add_selection_path(t, val[i]);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                return 1;
+                        }
+                }
+        }
+
+        t->to_process = true;
+        tar_dump(t);
+        return 0;
+}
+
+/**
+ * tar_process - start processing archive
+ *
+ * The talloc context of the fields is freed at the end of the call.
+ */
+int tar_process(struct tar *t)
+{
+        int rc = 0;
+
+        if (t == NULL) {
+                DBG(0, ("Invalid tar context\n"));
+                return 1;
+        }
+
+        switch(t->mode.operation) {
+        case TAR_EXTRACT:
+                rc = tar_extract(t);
+                break;
+        case TAR_CREATE:
+                rc = tar_create(t);
+                break;
+        default:
+                DBG(0, ("Invalid tar state\n"));
+                rc = 1;
+        }
+
+        t->to_process = false;
+        tar_free_mem_context(t);
+        DBG(5, ("tar_process done, err = %d\n", rc));
+        return rc;
+}
+
+/**
+ * tar_create - create archive and fetch files
+ */
+static int tar_create(struct tar* t)
+{
+        int r;
+        int err = 0;
+        NTSTATUS status;
+        const char *mask;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        t->archive = archive_write_new();
+
+        if (!t->mode.dry) {
+                const int bsize = t->mode.blocksize * TAR_BLOCK_UNIT;
+                r = archive_write_set_bytes_per_block(t->archive, bsize);
+                if (r != ARCHIVE_OK) {
+                        DBG(0, ("Can't use a block size of %d bytes", bsize));
+                        err = 1;
+                        goto out;
+                }
+
+                /*
+                 * Use PAX restricted format which is not the most
+                 * conservative choice but has useful extensions and is widely
+                 * supported
+                 */
+                r = archive_write_set_format_pax_restricted(t->archive);
+                if (r != ARCHIVE_OK) {
+                        DBG(0, ("Can't use pax restricted format: %s\n",
+                                                archive_error_string(t->archive)));
+                        err = 1;
+                        goto out;
+                }
+
+                if (strequal(t->tar_path, "-")) {
+                        r = archive_write_open_fd(t->archive, STDOUT_FILENO);
                 } else {
-                        DEBUG(4, ("skipping %s - initial read failed (file was locked ?)\n", finfo.name));
-                        shallitime=0;
+                        r = archive_write_open_filename(t->archive, t->tar_path);
+                }
+
+                if (r != ARCHIVE_OK) {
+                        DBG(0, ("Can't open %s: %s\n", t->tar_path,
+                                                archive_error_string(t->archive)));
+                        err = 1;
+                        goto out_close;
+                }
+        }
+
+        /*
+         * In inclusion mode, iterate on the inclusion list
+         */
+        if (t->mode.selection == TAR_INCLUDE && t->path_list_size > 0) {
+                if (tar_create_from_list(t)) {
+                        err = 1;
+                        goto out_close;
+                }
+        } else {
+                mask = talloc_asprintf(ctx, "%s\\*", client_get_cur_dir());
+                if (mask == NULL) {
+                        err = 1;
+                        goto out_close;
+                }
+                DBG(5, ("tar_process do_list with mask: %s\n", mask));
+                status = do_list(mask, TAR_DO_LIST_ATTR, get_file_callback, false, true);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DBG(0, ("do_list fail %s\n", nt_errstr(status)));
+                        err = 1;
+                        goto out_close;
+                }
+        }
+
+out_close:
+        DBG(0, ("Total bytes received: %" PRIu64 "\n", t->total_size));
+
+        if (!t->mode.dry) {
+                r = archive_write_close(t->archive);
+                if (r != ARCHIVE_OK) {
+                        DBG(0, ("Fatal: %s\n", archive_error_string(t->archive)));
+                        err = 1;
+                        goto out;
+                }
+        }
+out:
+#ifdef HAVE_ARCHIVE_READ_FREE
+        archive_write_free(t->archive);
+#else
+        archive_write_finish(t->archive);
+#endif
+        talloc_free(ctx);
+        return err;
+}
+
+/**
+ * tar_create_from_list - fetch from path list in include mode
+ */
+static int tar_create_from_list(struct tar *t)
+{
+        int err = 0;
+        NTSTATUS status;
+        char *base;
+        const char *path, *mask, *start_dir;
+        int i;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        start_dir = talloc_strdup(ctx, client_get_cur_dir());
+        if (start_dir == NULL) {
+                err = 1;
+                goto out;
+        }
+
+        for (i = 0; i < t->path_list_size; i++) {
+                path = t->path_list[i];
+                base = NULL;
+                status = path_base_name(ctx, path, &base);
+                if (!NT_STATUS_IS_OK(status)) {
+                        err = 1;
+                        goto out;
+                }
+                mask = talloc_asprintf(ctx, "%s\\%s",
+                                       client_get_cur_dir(), path);
+                if (mask == NULL) {
+                        err = 1;
+                        goto out;
+                }
+
+                DBG(5, ("incl. path='%s', base='%s', mask='%s'\n",
+                                        path, base ? base : "NULL", mask));
+
+                if (base != NULL) {
+                        base = talloc_asprintf(ctx, "%s%s\\",
+                                               client_get_cur_dir(), base);
+                        if (base == NULL) {
+                                err = 1;
+                                goto out;
+                        }
+                        DBG(5, ("cd '%s' before do_list\n", base));
+                        client_set_cur_dir(base);
+                }
+                status = do_list(mask, TAR_DO_LIST_ATTR, get_file_callback, false, true);
+                if (base != NULL) {
+                        client_set_cur_dir(start_dir);
+                }
+                if (!NT_STATUS_IS_OK(status)) {
+                        DBG(0, ("do_list failed on %s (%s)\n", path, nt_errstr(status)));
+                        err = 1;
+                        goto out;
+                }
+        }
+
+out:
+        talloc_free(ctx);
+        return err;
+}
+
+/**
+ * get_file_callback - do_list callback
+ *
+ * Callback for client.c do_list(). Called for each file found on the
+ * share matching do_list mask. Recursively call do_list() with itself
+ * as callback when the current file is a directory.
+ */
+static NTSTATUS get_file_callback(struct cli_state *cli,
+                                  struct file_info *finfo,
+                                  const char *dir)
+{
+        NTSTATUS status = NT_STATUS_OK;
+        char *remote_name;
+        const char *initial_dir = client_get_cur_dir();
+        bool skip = false;
+        int rc;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        remote_name = talloc_asprintf(ctx, "%s%s", initial_dir, finfo->name);
+        if (remote_name == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto out;
+        }
+
+        if (strequal(finfo->name, "..") || strequal(finfo->name, ".")) {
+                goto out;
+        }
+
+        status = tar_create_skip_path(&tar_ctx, remote_name, finfo, &skip);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto out;
+        }
+
+        if (skip) {
+                DBG(5, ("--- %s\n", remote_name));
+                status = NT_STATUS_OK;
+                goto out;
+        }
+
+        if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
+                char *old_dir;
+                char *new_dir;
+                char *mask;
+
+                old_dir = talloc_strdup(ctx, initial_dir);
+                new_dir = talloc_asprintf(ctx, "%s%s\\",
+                                          initial_dir, finfo->name);
+                if ((old_dir == NULL) || (new_dir == NULL)) {
+                        status = NT_STATUS_NO_MEMORY;
+                        goto out;
+                }
+                mask = talloc_asprintf(ctx, "%s*", new_dir);
+                if (mask == NULL) {
+                        status = NT_STATUS_NO_MEMORY;
+                        goto out;
+                }
+
+                rc = tar_get_file(&tar_ctx, remote_name, finfo);
+                if (rc != 0) {
                         status = NT_STATUS_UNSUCCESSFUL;
-                }
-        }
-
-        cli_close(cli, fnum);
-        fnum = -1;
-
-        if (shallitime) {
-                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, 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;
-
-                if (tar_noisy) {
-                        DEBUG(0, ("%12.0f (%7.1f kb/s) %s\n",
-                                (double)finfo.size, finfo.size / MAX(0.001, (1.024*this_time)),
-                                finfo.name));
-                }
-
-                /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
-                DEBUG(3,("(%g kb/s) (average %g kb/s)\n",
-                                finfo.size / MAX(0.001, (1.024*this_time)),
-                                get_total_size / MAX(0.001, (1.024*get_total_time_ms))));
-        }
-
-  cleanup:
-
-        if (fnum != (uint16_t)-1) {
-                cli_close(cli, fnum);
-                fnum = -1;
-        }
-        TALLOC_FREE(ctx);
-        SAFE_FREE(data);
+                        goto out;
+                }
+
+                client_set_cur_dir(new_dir);
+                do_list(mask, TAR_DO_LIST_ATTR, get_file_callback, false, true);
+                client_set_cur_dir(old_dir);
+        } else {
+                rc = tar_get_file(&tar_ctx, remote_name, finfo);
+                if (rc != 0) {
+                        status = NT_STATUS_UNSUCCESSFUL;
+                        goto out;
+                }
+        }
+
+out:
+        talloc_free(ctx);
         return status;
 }
 
-/****************************************************************************
-Append single file to tar file (or not)
-***************************************************************************/
-
-static NTSTATUS do_tar(struct cli_state *cli_state, struct file_info *finfo,
-                   const char *dir)
-{
-        TALLOC_CTX *ctx = talloc_stackframe();
+/**
+ * tar_get_file - fetch a remote file to the local archive
+ * @full_dos_path: path to the file to fetch
+ * @finfo: attributes of the file to fetch
+ */
+static int tar_get_file(struct tar *t,
+                        const char *full_dos_path,
+                        struct file_info *finfo)
+{
+        extern struct cli_state *cli;
+        NTSTATUS status;
+        struct archive_entry *entry;
+        char *full_unix_path;
+        char buf[TAR_CLI_READ_SIZE];
+        size_t len;
+        uint64_t off = 0;
+        uint16_t remote_fd = (uint16_t)-1;
+        int err = 0, r;
+        const bool isdir = finfo->mode & FILE_ATTRIBUTE_DIRECTORY;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        DBG(5, ("+++ %s\n", full_dos_path));
+
+        t->total_size += finfo->size;
+
+        if (t->mode.dry) {
+                goto out;
+        }
+
+        if (t->mode.reset) {
+                /* ignore return value: server might not store DOS attributes */
+                set_remote_attr(full_dos_path, FILE_ATTRIBUTE_ARCHIVE, ATTR_UNSET);
+        }
+
+        full_unix_path = talloc_asprintf(ctx, ".%s", full_dos_path);
+        if (full_unix_path == NULL) {
+                err = 1;
+                goto out;
+        }
+        string_replace(full_unix_path, '\\', '/');
+        entry = archive_entry_new();
+        archive_entry_copy_pathname(entry, full_unix_path);
+        archive_entry_set_filetype(entry, isdir ? AE_IFDIR : AE_IFREG);
+        archive_entry_set_atime(entry,
+                        finfo->atime_ts.tv_sec,
+                        finfo->atime_ts.tv_nsec);
+        archive_entry_set_mtime(entry,
+                        finfo->mtime_ts.tv_sec,
+                        finfo->mtime_ts.tv_nsec);
+        archive_entry_set_ctime(entry,
+                        finfo->ctime_ts.tv_sec,
+                        finfo->ctime_ts.tv_nsec);
+        archive_entry_set_perm(entry, isdir ? 0755 : 0644);
+        /*
+         * check if we can safely cast unsigned file size to libarchive
+         * signed size. Very unlikely problem (>9 exabyte file)
+         */
+        if (finfo->size > INT64_MAX) {
+                DBG(0, ("Remote file %s too big\n", full_dos_path));
+                goto out_entry;
+        }
+
+        archive_entry_set_size(entry, (int64_t)finfo->size);
+
+        r = archive_write_header(t->archive, entry);
+        if (r != ARCHIVE_OK) {
+                DBG(0, ("Fatal: %s\n", archive_error_string(t->archive)));
+                err = 1;
+                goto out_entry;
+        }
+
+        if (isdir) {
+                DBG(5, ("get_file skip dir %s\n", full_dos_path));
+                goto out_entry;
+        }
+
+        status = cli_open(cli, full_dos_path, O_RDONLY, DENY_NONE, &remote_fd);
+        if (!NT_STATUS_IS_OK(status)) {
+                DBG(0,("%s opening remote file %s\n",
+                                        nt_errstr(status), full_dos_path));
+                goto out_entry;
+        }
+
+        do {
+                status = cli_read(cli, remote_fd, buf, off, sizeof(buf), &len);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DBG(0,("Error reading file %s : %s\n",
+                                                full_dos_path, nt_errstr(status)));
+                        err = 1;
+                        goto out_close;
+                }
+
+                off += len;
+
+                r = archive_write_data(t->archive, buf, len);
+                if (r < 0) {
+                        DBG(0, ("Fatal: %s\n", archive_error_string(t->archive)));
+                        err = 1;
+                        goto out_close;
+                }
+
+        } while (off < finfo->size);
+
+out_close:
+        cli_close(cli, remote_fd);
+
+out_entry:
+        archive_entry_free(entry);
+
+out:
+        talloc_free(ctx);
+        return err;
+}
+
+/**
+ * tar_extract - open archive and send files.
+ */
+static int tar_extract(struct tar *t)
+{
+        int err = 0;
+        int r;
+        struct archive_entry *entry;
+        const size_t bsize = t->mode.blocksize * TAR_BLOCK_UNIT;
+        int rc;
+
+        t->archive = archive_read_new();
+        archive_read_support_format_all(t->archive);
+#ifdef HAVE_ARCHIVE_READ_SUPPORT_FILTER_ALL
+        archive_read_support_filter_all(t->archive);
+#endif
+
+        if (strequal(t->tar_path, "-")) {
+                r = archive_read_open_fd(t->archive, STDIN_FILENO, bsize);
+        } else {
+                r = archive_read_open_filename(t->archive, t->tar_path, bsize);
+        }
+
+        if (r != ARCHIVE_OK) {
+                DBG(0, ("Can't open %s : %s\n", t->tar_path,
+                                        archive_error_string(t->archive)));
+                err = 1;
+                goto out;
+        }
+
+        for (;;) {
+                NTSTATUS status;
+                bool skip;
+                r = archive_read_next_header(t->archive, &entry);
+                if (r == ARCHIVE_EOF) {
+                        break;
+                }
+                if (r == ARCHIVE_WARN) {
+                        DBG(0, ("Warning: %s\n", archive_error_string(t->archive)));
+                }
+                if (r == ARCHIVE_FATAL) {
+                        DBG(0, ("Fatal: %s\n", archive_error_string(t->archive)));
+                        err = 1;
+                        goto out;
+                }
+
+                status = tar_extract_skip_path(t, entry, &skip);
+                if (!NT_STATUS_IS_OK(status)) {
+                        err = 1;
+                        goto out;
+                }
+                if (skip) {
+                        DBG(5, ("--- %s\n", archive_entry_pathname(entry)));
+                        continue;
+                }
+
+                DBG(5, ("+++ %s\n", archive_entry_pathname(entry)));
+
+                rc = tar_send_file(t, entry);
+                if (rc != 0) {
+                        err = 1;
+                        goto out;
+                }
+        }
+
+out:
+#ifdef HAVE_ARCHIVE_READ_FREE
+        r = archive_read_free(t->archive);
+#else
+        r = archive_read_finish(t->archive);
+#endif
+        if (r != ARCHIVE_OK) {
+                DBG(0, ("Can't close %s : %s\n", t->tar_path,
+                                        archive_error_string(t->archive)));
+                err = 1;
+        }
+        return err;
+}
+
+/**
+ * tar_send_file - send @entry to the remote server
+ * @entry: current archive entry
+ *
+ * Handle the creation of the parent directories and transfer the
+ * entry to a new remote file.
+ */
+static int tar_send_file(struct tar *t, struct archive_entry *entry)
+{
+        extern struct cli_state *cli;
+        char *dos_path;
+        char *full_path;
+        NTSTATUS status;
+        uint16_t remote_fd = (uint16_t) -1;
+        int err = 0;
+        int flags = O_RDWR | O_CREAT | O_TRUNC;
+        mode_t mode = archive_entry_filetype(entry);
+        int rc;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        dos_path = talloc_strdup(ctx, archive_entry_pathname(entry));
+        if (dos_path == NULL) {
+                err = 1;
+                goto out;
+        }
+        fix_unix_path(dos_path, true);
+
+        full_path = talloc_strdup(ctx, client_get_cur_dir());
+        if (full_path == NULL) {
+                err = 1;
+                goto out;
+        }
+        full_path = talloc_strdup_append(full_path, dos_path);
+        if (full_path == NULL) {
+                err = 1;
+                goto out;
+        }
+
+        if (mode != AE_IFREG && mode != AE_IFDIR) {
+                DBG(0, ("Skipping non-dir & non-regular file %s\n", full_path));
+                goto out;
+        }
+
+        rc = make_remote_path(full_path);
+        if (rc != 0) {
+                err = 1;
+                goto out;
+        }
+
+        if (mode == AE_IFDIR) {
+                goto out;
+        }
+
+        status = cli_open(cli, full_path, flags, DENY_NONE, &remote_fd);
+        if (!NT_STATUS_IS_OK(status)) {
+                DBG(0, ("Error opening remote file %s: %s\n",
+                                        full_path, nt_errstr(status)));
+                err = 1;
+                goto out;
+        }
+
+        for (;;) {
+                const void *buf;
+                size_t len;
+                off_t off;
+                int r;
+
+                r = archive_read_data_block(t->archive, &buf, &len, &off);
+                if (r == ARCHIVE_EOF) {
+                        break;
+                }
+                if (r == ARCHIVE_WARN) {
+                        DBG(0, ("Warning: %s\n", archive_error_string(t->archive)));
+                }
+                if (r == ARCHIVE_FATAL) {
+                        DBG(0, ("Fatal: %s\n", archive_error_string(t->archive)));
+                        err = 1;
+                        goto close_out;
+                }
+
+                status = cli_writeall(cli, remote_fd, 0, buf, off, len, NULL);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DBG(0, ("Error writing remote file %s: %s\n",
+                                                full_path, nt_errstr(status)));
+                        err = 1;
+                        goto close_out;
+                }
+        }
+
+close_out:
+        status = cli_close(cli, remote_fd);
+        if (!NT_STATUS_IS_OK(status)) {
+                DBG(0, ("Error losing remote file %s: %s\n",
+                                        full_path, nt_errstr(status)));
+                err = 1;
+        }
+
+out:
+        talloc_free(ctx);
+        return err;
+}
+
+/**
+ * tar_add_selection_path - add a path to the path list
+ * @path: path to add
+ */
+static NTSTATUS tar_add_selection_path(struct tar *t, const char *path)
+{
+        const char **list;
+        TALLOC_CTX *ctx = t->talloc_ctx;
+        if (!t->path_list) {
+                t->path_list = str_list_make_empty(ctx);
+                if (t->path_list == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                t->path_list_size = 0;
+        }
+
+        /* cast to silence gcc const-qual warning */
+        list = str_list_add((void *)t->path_list, path);
+        if (list == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        t->path_list = discard_const_p(char *, list);
+        t->path_list_size++;
+        fix_unix_path(t->path_list[t->path_list_size - 1], true);
+
+        return NT_STATUS_OK;
+}
+
+/**
+ * tar_set_blocksize - set block size in TAR_BLOCK_UNIT
+ */
+static int tar_set_blocksize(struct tar *t, int size)
+{
+        if (size <= 0 || size > TAR_MAX_BLOCK_SIZE) {
+                return 1;
+        }
+
+        t->mode.blocksize = size;
+
+        return 0;
+}
+
+/**
+ * tar_set_newer_than - set date threshold of saved files
+ * @filename: local path to a file
+ *
+ * Only files newer than the modification time of @filename will be
+ * saved.
+ *
+ * Note: this function set the global variable newer_than from
+ * client.c. Thus the time is not a field of the tar structure. See
+ * cmd_newer() to change its value from an interactive session.
+ */
+static int tar_set_newer_than(struct tar *t, const char *filename)
+{
+        extern time_t newer_than;
+        SMB_STRUCT_STAT stbuf;
+        int rc;
+
+        rc = sys_stat(filename, &stbuf, false);
+        if (rc != 0) {
+                DBG(0, ("Error setting newer-than time\n"));
+                return 1;
+        }
+
+        newer_than = convert_timespec_to_time_t(stbuf.st_ex_mtime);
+        DBG(1, ("Getting files newer than %s\n", time_to_asc(newer_than)));
+        return 0;
+}
+
+/**
+ * tar_read_inclusion_file - set path list from file
+ * @filename: path to the list file
+ *
+ * Read and add each line of @filename to the path list.
+ */
+static int tar_read_inclusion_file(struct tar *t, const char* filename)
+{
+        char *line;
+        int err = 0;
+        int fd;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        fd = open(filename, O_RDONLY);
+        if (fd < 0) {
+                DBG(0, ("Can't open inclusion file '%s': %s\n", filename, strerror(errno)));
+                err = 1;
+                goto out;
+        }
+
+        for (line = afdgets(fd, ctx, 0);
+                        line != NULL;
+                        line = afdgets(fd, ctx, 0)) {
+                NTSTATUS status;
+                status = tar_add_selection_path(t, line);
+                if (!NT_STATUS_IS_OK(status)) {
+                        err = 1;
+                        goto out;
+                }
+        }
+
+        close(fd);
+
+out:
+        talloc_free(ctx);
+        return err;
+}
+
+/**
+ * tar_path_in_list - check whether @path is in the path list
+ * @path: path to find
+ * @reverse: when true also try to find path list element in @path
+ * @_is_in_list: set if @path is in the path list
+ *
+ * Look at each path of the path list and set @_is_in_list if @path is a
+ * subpath of one of them.
+ *
+ * If you want /path to be in the path list (path/a/, path/b/) set
+ * @reverse to true to try to match the other way around.
+ */
+static NTSTATUS tar_path_in_list(struct tar *t, const char *path,
+                                 bool reverse, bool *_is_in_list)
+{
+        int i;
+        const char *p;
+        const char *pattern;
+
+        if (path == NULL || path[0] == '\0') {
+                *_is_in_list = false;
+                return NT_STATUS_OK;
+        }
+
+        p = skip_useless_char_in_path(path);
+
+        for (i = 0; i < t->path_list_size; i++) {
+                bool is_in_list;
+                NTSTATUS status;
+
+                pattern = skip_useless_char_in_path(t->path_list[i]);
+                status = is_subpath(p, pattern, &is_in_list);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+                if (reverse && !is_in_list) {
+                        status = is_subpath(pattern, p, &is_in_list);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                return status;
+                        }
+                }
+                if (is_in_list) {
+                        *_is_in_list = true;
+                        return NT_STATUS_OK;
+                }
+        }
+
+        *_is_in_list = false;
+        return NT_STATUS_OK;
+}
+
+/**
+ * tar_extract_skip_path - check if @entry should be skipped
+ * @entry: current tar entry
+ * @_skip: set true if path should be skipped, otherwise false
+ *
+ * Skip predicate for tar extraction (archive to server) only.
+ */
+static NTSTATUS tar_extract_skip_path(struct tar *t,
+                                      struct archive_entry *entry,
+                                      bool *_skip)
+{
+        const char *fullpath = archive_entry_pathname(entry);
+        bool in = true;
+
+        if (t->path_list_size <= 0) {
+                *_skip = false;
+                return NT_STATUS_OK;
+        }
+
+        if (t->mode.regex) {
+                in = mask_match_list(fullpath, t->path_list, t->path_list_size, true);
+        } else {
+                NTSTATUS status = tar_path_in_list(t, fullpath, false, &in);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+        }
+
+        if (t->mode.selection == TAR_EXCLUDE) {
+                *_skip = in;
+        } else {
+                *_skip = !in;
+        }
+
+        return NT_STATUS_OK;
+}
+
+/**
+ * tar_create_skip_path - check if @fullpath shoud be skipped
+ * @fullpath: full remote path of the current file
+ * @finfo: remote file attributes
+ * @_skip: returned skip not
+ *
+ * Skip predicate for tar creation (server to archive) only.
+ */
+static NTSTATUS tar_create_skip_path(struct tar *t,
+                                     const char *fullpath,
+                                     const struct file_info *finfo,
+                                     bool *_skip)
+{
+        /* syntaxic sugar */
+        const mode_t mode = finfo->mode;
+        const bool isdir = mode & FILE_ATTRIBUTE_DIRECTORY;
+        const bool exclude = t->mode.selection == TAR_EXCLUDE;
+        bool in = true;
+
+        if (!isdir) {
+
+                /* 1. if we don't want X and we have X, skip */
+                if (!t->mode.system && (mode & FILE_ATTRIBUTE_SYSTEM)) {
+                        *_skip = true;
+                        return NT_STATUS_OK;
+                }
+
+                if (!t->mode.hidden && (mode & FILE_ATTRIBUTE_HIDDEN)) {
+                        *_skip = true;
+                        return NT_STATUS_OK;
+                }
+
+                /* 2. if we only want archive and it's not, skip */
+
+                if (t->mode.incremental && !(mode & FILE_ATTRIBUTE_ARCHIVE)) {
+                        *_skip = true;
+                        return NT_STATUS_OK;
+                }
+        }
+
+        /* 3. is it in the selection list? */
+
+        /*
+         * tar_create_from_list() use the include list as a starting
+         * point, no need to check
+         */
+        if (!exclude) {
+                *_skip = false;
+                return NT_STATUS_OK;
+        }
+
+        /* we are now in exclude mode */
+
+        /* no matter the selection, no list => include everything */
+        if (t->path_list_size <= 0) {
+                *_skip = false;
+                return NT_STATUS_OK;
+        }
+
+        if (t->mode.regex) {
+                in = mask_match_list(fullpath, t->path_list, t->path_list_size, true);
+        } else {
+                bool reverse = isdir && !exclude;
+                NTSTATUS status = tar_path_in_list(t, fullpath, reverse, &in);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+        }
+        *_skip = in;
+
+        return NT_STATUS_OK;
+}
+
+/**
+ * tar_to_process - return true if @t is ready to be processed
+ *
+ * @t is ready if it properly parsed command line arguments.
+ */
+bool tar_to_process(struct tar *t)
+{
+        if (t == NULL) {
+                DBG(0, ("Invalid tar context\n"));
+                return false;
+        }
+        return t->to_process;
+}
+
+/**
+ * skip_useless_char_in_path - skip leading slashes/dots
+ *
+ * Skip leading slashes, backslashes and dot-slashes.
+ */
+static const char* skip_useless_char_in_path(const char *p)
+{
+        while (p) {
+                if (*p == '/' || *p == '\\') {
+                        p++;
+                }
+                else if (p[0] == '.' && (p[1] == '/' || p[1] == '\\')) {
+                        p += 2;
+                }
+                else
+                        return p;
+        }
+        return p;
+}
+
+/**
+ * is_subpath - check if the path @sub is a subpath of @full.
+ * @sub: path to test
+ * @full: container path
+ * @_subpath_match: set true if @sub is a subpath of @full, otherwise false
+ *
+ * String comparaison is case-insensitive.
+ */
+static NTSTATUS is_subpath(const char *sub, const char *full,
+                           bool *_subpath_match)
+{
         NTSTATUS status = NT_STATUS_OK;
-
-        if (strequal(finfo->name,"..") || strequal(finfo->name,".")) {
-                status = NT_STATUS_OK;
-                goto cleanup;
-        }
-
-        /* Is it on the exclude list ? */
-        if (!tar_excl && clipn) {
-                char *exclaim;
-
-                DEBUG(5, ("Excl: strlen(cur_dir) = %d\n", (int)strlen(client_get_cur_dir())));
-
-                exclaim = talloc_asprintf(ctx,
-                                "%s\\%s",
-                                client_get_cur_dir(),
-                                finfo->name);
-                if (!exclaim) {
-                        status = NT_STATUS_NO_MEMORY;
-                        goto cleanup;
-                }
-
-                DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));
-
-                if ((!tar_re_search && clipfind(cliplist, clipn, exclaim)) ||
-                                (tar_re_search && mask_match_list(exclaim, cliplist, clipn, True))) {
-                        DEBUG(3,("Skipping file %s\n", exclaim));
-                        TALLOC_FREE(exclaim);
-                        status = NT_STATUS_OK;
-                        goto cleanup;
-                }
-                TALLOC_FREE(exclaim);
-        }
-
-        if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
-                char *saved_curdir = NULL;
-                char *new_cd = NULL;
-                char *mtar_mask = NULL;
-
-                saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
-                if (!saved_curdir) {
-                        status = NT_STATUS_NO_MEMORY;
-                        goto cleanup;
-                }
-
-                DEBUG(5, ("strlen(cur_dir)=%d, \
-strlen(finfo->name)=%d\nname=%s,cur_dir=%s\n",
-                        (int)strlen(saved_curdir),
-                        (int)strlen(finfo->name), finfo->name, saved_curdir));
-
-                new_cd = talloc_asprintf(ctx,
-                                "%s%s\\",
-                                client_get_cur_dir(),
-                                finfo->name);
-                if (!new_cd) {
-                        status = NT_STATUS_NO_MEMORY;
-                        goto cleanup;
-                }
-                client_set_cur_dir(new_cd);
-
-                DEBUG(5, ("Writing a dir, Name = %s\n", client_get_cur_dir()));
-
-                /* write a tar directory, don't bother with mode - just
-                 * set it to 40755 */
-                writetarheader(tarhandle, client_get_cur_dir(), 0,
-                                finfo->mtime_ts.tv_sec, "040755 \0", '5');
-                if (tar_noisy) {
-                        DEBUG(0,("                directory %s\n",
-                                client_get_cur_dir()));
-                }
-                ntarf++;  /* Make sure we have a file on there */
-                mtar_mask = talloc_asprintf(ctx,
-                                "%s*",
-                                client_get_cur_dir());
-                if (!mtar_mask) {
-                        status = NT_STATUS_NO_MEMORY;
-                        goto cleanup;
-                }
-                DEBUG(5, ("Doing list with mtar_mask: %s\n", mtar_mask));
-                do_list(mtar_mask, attribute, do_tar, False, True);
-                client_set_cur_dir(saved_curdir);
-                TALLOC_FREE(saved_curdir);
-                TALLOC_FREE(new_cd);
-                TALLOC_FREE(mtar_mask);
-        } else {
-                char *rname = talloc_asprintf(ctx,
-                                        "%s%s",
-                                        client_get_cur_dir(),
-                                        finfo->name);
-                if (!rname) {
-                        status = NT_STATUS_NO_MEMORY;
-                        goto cleanup;
-                }
-                status = do_atar(rname,finfo->name,finfo);
-                TALLOC_FREE(rname);
-        }
-
-  cleanup:
-        TALLOC_FREE(ctx);
+        int len = 0;
+        char *f, *s;
+        TALLOC_CTX *tmp_ctx = talloc_new(NULL);
+        if (tmp_ctx == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto out;
+        }
+
+        f = strlower_talloc(tmp_ctx, full);
+        if (f == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto out_ctx_free;
+        }
+        string_replace(f, '\\', '/');
+        s = strlower_talloc(tmp_ctx, sub);
+        if (f == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto out_ctx_free;
+        }
+        string_replace(s, '\\', '/');
+
+        /* find the point where sub and full diverge */
+        while ((*f != '\0') && (*s != '\0') && (*f == *s)) {
+                f++;
+                s++;
+                len++;
+        }
+
+        if ((*f == '\0') && (*s == '\0')) {
+                *_subpath_match = true; /* sub and full match */
+                goto out_ctx_free;
+        }
+
+        if ((*f == '\0') && (len > 0) && (*(f - 1) == '/')) {
+                /* sub diverges from full at path separator */
+                *_subpath_match = true;
+                goto out_ctx_free;
+        }
+
+        if ((*s == '\0') && (strcmp(f, "/") == 0)) {
+                /* full diverges from sub with trailing slash only */
+                *_subpath_match = true;
+                goto out_ctx_free;
+        }
+
+        if ((*s == '/') && (*f == '\0')) {
+                /* sub diverges from full with extra path component */
+                *_subpath_match = true;
+                goto out_ctx_free;
+        }
+        *_subpath_match = false;
+
+out_ctx_free:
+        talloc_free(tmp_ctx);
+out:
         return status;
 }
 
-/****************************************************************************
-Convert from UNIX to DOS file names
-***************************************************************************/
-
-static void unfixtarname(char *tptr, char *fp, int l, bool first)
-{
-        /* remove '.' from start of file name, convert from unix /'s to
-         * dos \'s in path. Kill any absolute path names. But only if first!
+
+/**
+ * make_remote_path - recursively make remote dirs
+ * @full_path: full hierarchy to create
+ *
+ * Create @full_path and each parent directories as needed.
+ */
+static int make_remote_path(const char *full_path)
+{
+        extern struct cli_state *cli;
+        char *path;
+        char *subpath;
+        char *state;
+        char *last_backslash;
+        char *p;
+        int len;
+        NTSTATUS status;
+        int err = 0;
+        TALLOC_CTX *ctx = talloc_new(NULL);
+        if (ctx == NULL) {
+                return 1;
+        }
+
+        subpath = talloc_strdup(ctx, full_path);
+        if (subpath == NULL) {
+                err = 1;
+                goto out;
+        }
+        path = talloc_strdup(ctx, full_path);
+        if (path == NULL) {
+                err = 1;
+                goto out;
+        }
+        len = talloc_get_size(path) - 1;
+
+        last_backslash = strrchr_m(path, '\\');
+        if (last_backslash == NULL) {
+                goto out;
+        }
+
+        *last_backslash = 0;
+
+        subpath[0] = 0;
+        p = strtok_r(path, "\\", &state);
+
+        while (p != NULL) {
+                strlcat(subpath, p, len);
+                status = cli_chkpath(cli, subpath);
+                if (!NT_STATUS_IS_OK(status)) {
+                        status = cli_mkdir(cli, subpath);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                DBG(0, ("Can't mkdir %s: %s\n", subpath, nt_errstr(status)));
+                                err = 1;
+                                goto out;
+                        }
+                        DBG(3, ("mkdir %s\n", subpath));
+                }
+
+                strlcat(subpath, "\\", len);
+                p = strtok_r(NULL, "/\\", &state);
+
+        }
+
+out:
+        talloc_free(ctx);
+        return err;
+}
+
+/**
+ * tar_reset_mem_context - reset talloc context associated with @t
+ *
+ * At the start of the program the context is NULL so a new one is
+ * allocated. On the following runs (interactive session only), simply
+ * free the children.
+ */
+static TALLOC_CTX *tar_reset_mem_context(struct tar *t)
+{
+        tar_free_mem_context(t);
+        t->talloc_ctx = talloc_new(NULL);
+        return t->talloc_ctx;
+}
+
+/**
+ * tar_free_mem_context - free talloc context associated with @t
+ */
+static void tar_free_mem_context(struct tar *t)
+{
+        if (t->talloc_ctx) {
+                talloc_free(t->talloc_ctx);
+                t->talloc_ctx = NULL;
+                t->path_list_size = 0;
+                t->path_list = NULL;
+                t->tar_path = NULL;
+        }
+}
+
+#define XSET(v)      [v] = #v
+#define XTABLE(v, t) DBG(2, ("DUMP:%-20.20s = %s\n", #v, t[v]))
+#define XBOOL(v)     DBG(2, ("DUMP:%-20.20s = %d\n", #v, v ? 1 : 0))
+#define XSTR(v)      DBG(2, ("DUMP:%-20.20s = %s\n", #v, v ? v : "NULL"))
+#define XINT(v)      DBG(2, ("DUMP:%-20.20s = %d\n", #v, v))
+#define XUINT64(v)   DBG(2, ("DUMP:%-20.20s = %" PRIu64  "\n", #v, v))
+
+/**
+ * tar_dump - dump tar structure on stdout
+ */
+static void tar_dump(struct tar *t)
+{
+        int i;
+        const char* op[] = {
+                XSET(TAR_NO_OPERATION),
+                XSET(TAR_CREATE),
+                XSET(TAR_EXTRACT),
+        };
+
+        const char* sel[] = {
+                XSET(TAR_NO_SELECTION),
+                XSET(TAR_INCLUDE),
+                XSET(TAR_EXCLUDE),
+        };
+
+        XBOOL(t->to_process);
+        XTABLE(t->mode.operation, op);
+        XTABLE(t->mode.selection, sel);
+        XINT(t->mode.blocksize);
+        XBOOL(t->mode.hidden);
+        XBOOL(t->mode.system);
+        XBOOL(t->mode.incremental);
+        XBOOL(t->mode.reset);
+        XBOOL(t->mode.dry);
+        XBOOL(t->mode.verbose);
+        XUINT64(t->total_size);
+        XSTR(t->tar_path);
+        XINT(t->path_list_size);
+
+        for (i = 0; t->path_list && t->path_list[i]; i++) {
+                DBG(2, ("DUMP: t->path_list[%2d] = %s\n", i, t->path_list[i]));
+        }
+
+        DBG(2, ("DUMP:t->path_list @ %p (%d elem)\n", t->path_list, i));
+}
+#undef XSET
+#undef XTABLE
+#undef XBOOL
+#undef XSTR
+#undef XINT
+
+/**
+ * max_token - return upper limit for the number of token in @str
+ *
+ * The result is not exact, the actual number of token might be less
+ * than what is returned.
+ */
+static int max_token(const char *str)
+{
+        const char *s;
+        int nb = 0;
+
+        if (str == NULL) {
+                return 0;
+        }
+
+        s = str;
+        while (s[0] != '\0') {
+                if (isspace((int)s[0])) {
+                        nb++;
+                }
+                s++;
+        }
+
+        nb++;
+
+        return nb;
+}
+
+/**
+ * fix_unix_path - convert @path to a DOS path
+ * @path: path to convert
+ * @removeprefix: if true, remove leading ./ or /.
+ */
+static char *fix_unix_path(char *path, bool do_remove_prefix)
+{
+        char *from = path, *to = path;
+
+        if (path == NULL || path[0] == '\0') {
+                return path;
+        }
+
+        /* remove prefix:
+         * ./path => path
+         *  /path => path
          */
-
-        DEBUG(5, ("firstb=%lX, secondb=%lX, len=%i\n", (long)tptr, (long)fp, l));
-
-        if (first) {
-                if (*fp == '.') {
-                        fp++;
-                        l--;
-                }
-                if (*fp == '\\' || *fp == '/') {
-                        fp++;
-                        l--;
-                }
-        }
-
-        safe_strcpy(tptr, fp, l);
-        string_replace(tptr, '/', '\\');
-}
-
-/****************************************************************************
-Move to the next block in the buffer, which may mean read in another set of
-blocks. FIXME, we should allow more than one block to be skipped.
-****************************************************************************/
-
-static int next_block(char *ltarbuf, char **bufferp, int bufsiz)
-{
-        int bufread, total = 0;
-
-        DEBUG(5, ("Advancing to next block: %0lx\n", (unsigned long)*bufferp));
-        *bufferp += TBLOCK;
-        total = TBLOCK;
-
-        if (*bufferp >= (ltarbuf + bufsiz)) {
-
-                DEBUG(5, ("Reading more data into ltarbuf ...\n"));
-
-                /*
-                 * Bugfix from Bob Boehmer <boehmer@worldnet.att.net>
-                 * Fixes bug where read can return short if coming from
-                 * a pipe.
-                 */
-
-                bufread = read(tarhandle, ltarbuf, bufsiz);
-                total = bufread;
-
-                while (total < bufsiz) {
-                        if (bufread < 0) { /* An error, return false */
-                                return (total > 0 ? -2 : bufread);
-                        }
-                        if (bufread == 0) {
-                                if (total <= 0) {
-                                        return -2;
-                                }
-                                break;
-                        }
-                        bufread = read(tarhandle, &ltarbuf[total], bufsiz - total);
-                        total += bufread;
-                }
-
-                DEBUG(5, ("Total bytes read ... %i\n", total));
-
-                *bufferp = ltarbuf;
-        }
-
-        return(total);
-}
-
-/* Skip a file, even if it includes a long file name? */
-static int skip_file(int skipsize)
-{
-        int dsize = skipsize;
-
-        DEBUG(5, ("Skiping file. Size = %i\n", skipsize));
-
-        /* FIXME, we should skip more than one block at a time */
-
-        while (dsize > 0) {
-                if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
-                        DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
-                        return(False);
-                }
-                dsize -= TBLOCK;
-        }
-
-        return(True);
-}
-
-/*************************************************************
- Get a file from the tar file and store it.
- When this is called, tarbuf already contains the first
- file block. This is a bit broken & needs fixing.
-**************************************************************/
-
-static int get_file(file_info2 finfo)
-{
-        uint16_t fnum = (uint16_t) -1;
-        int dsize = 0, bpos = 0;
-        uint64_t rsize = 0, pos = 0;
-        NTSTATUS status;
-
-        DEBUG(5, ("get_file: file: %s, size %.0f\n", finfo.name, (double)finfo.size));
-
-        if (!ensurepath(finfo.name)) {
-                DEBUG(0, ("abandoning restore\n"));
-                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;
-        }
-
-        /* read the blocks from the tar file and write to the remote file */
-
-        rsize = finfo.size;  /* This is how much to write */
-
-        while (rsize > 0) {
-
-                /* We can only write up to the end of the buffer */
-                dsize = MIN(tbufsiz - (buffer_p - tarbuf) - bpos, 65520); /* Calculate the size to write */
-                dsize = MIN(dsize, rsize);  /* Should be only what is left */
-                DEBUG(5, ("writing %i bytes, bpos = %i ...\n", dsize, bpos));
-
-                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;
-                }
-
-                rsize -= dsize;
-                pos += dsize;
-
-                /* Now figure out how much to move in the buffer */
-
-                /* FIXME, we should skip more than one block at a time */
-
-                /* First, skip any initial part of the part written that is left over */
-                /* from the end of the first TBLOCK                                   */
-
-                if ((bpos) && ((bpos + dsize) >= TBLOCK)) {
-                        dsize -= (TBLOCK - bpos);  /* Get rid of the end of the first block */
-                        bpos = 0;
-
-                        if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {  /* and skip the block */
-                                DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
-                                return False;
-                        }
-                }
-
-                /*
-                 * Bugfix from Bob Boehmer <boehmer@worldnet.att.net>.
-                 * If the file being extracted is an exact multiple of
-                 * TBLOCK bytes then we don't want to extract the next
-                 * block from the tarfile here, as it will be done in
-                 * the caller of get_file().
-                 */
-
-                while (((rsize != 0) && (dsize >= TBLOCK)) ||
-                                ((rsize == 0) && (dsize > TBLOCK))) {
-
-                        if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
-                                DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
-                                return False;
-                        }
-
-                        dsize -= TBLOCK;
-                }
-                bpos = dsize;
-        }
-
-        /* Now close the file ... */
-
-        if (!NT_STATUS_IS_OK(cli_close(cli, fnum))) {
-                DEBUG(0, ("Error %s closing remote file\n",
-                        cli_errstr(cli)));
-                return(False);
-        }
-
-        /* Now we update the creation date ... */
-        DEBUG(5, ("Updating creation date on %s\n", finfo.name));
-
-        if (!NT_STATUS_IS_OK(cli_setatr(cli, finfo.name, finfo.mode, finfo.mtime_ts.tv_sec))) {
-                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 */
-                }
-        }
-
-        ntarf++;
-        DEBUG(0, ("restore tar file %s of size %.0f bytes\n", finfo.name, (double)finfo.size));
-        return(True);
-}
-
-/* Create a directory.  We just ensure that the path exists and return as there
-   is no file associated with a directory
-*/
-static int get_dir(file_info2 finfo)
-{
-        DEBUG(0, ("restore directory %s\n", finfo.name));
-
-        if (!ensurepath(finfo.name)) {
-                DEBUG(0, ("Problems creating directory\n"));
-                return(False);
-        }
-        ntarf++;
-        return(True);
-}
-
-/* Get a file with a long file name ... first file has file name, next file 
-   has the data. We only want the long file name, as the loop in do_tarput
-   will deal with the rest.
-*/
-static char *get_longfilename(file_info2 finfo)
-{
-        /* finfo.size here is the length of the filename as written by the "/./@LongLink" name
-         * header call. */
-        int namesize = finfo.size + strlen(client_get_cur_dir()) + 2;
-        char *longname = (char *)SMB_MALLOC(namesize);
-        int offset = 0, left = finfo.size;
-        bool first = True;
-
-        DEBUG(5, ("Restoring a long file name: %s\n", finfo.name));
-        DEBUG(5, ("Len = %.0f\n", (double)finfo.size));
-
-        if (longname == NULL) {
-                DEBUG(0, ("could not allocate buffer of size %d for longname\n", namesize));
-                return(NULL);
-        }
-
-        /* First, add cur_dir to the long file name */
-
-        if (strlen(client_get_cur_dir()) > 0) {
-                strncpy(longname, client_get_cur_dir(), namesize);
-                offset = strlen(client_get_cur_dir());
-        }
-
-        /* Loop through the blocks picking up the name */
-
-        while (left > 0) {
-                if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
-                        DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
-                        SAFE_FREE(longname);
-                        return(NULL);
-                }
-
-                unfixtarname(longname + offset, buffer_p, MIN(TBLOCK, finfo.size), first--);
-                DEBUG(5, ("UnfixedName: %s, buffer: %s\n", longname, buffer_p));
-
-                offset += TBLOCK;
-                left -= TBLOCK;
-        }
-
-        return(longname);
-}
-
-static void do_tarput(void)
-{
-        file_info2 finfo;
-        struct timespec tp_start;
-        char *longfilename = NULL, linkflag;
-        int skip = False;
-
-        ZERO_STRUCT(finfo);
-
-        clock_gettime_mono(&tp_start);
-        DEBUG(5, ("RJS do_tarput called ...\n"));
-
-        buffer_p = tarbuf + tbufsiz;  /* init this to force first read */
-
-        /* Now read through those files ... */
-        while (True) {
-                /* Get us to the next block, or the first block first time around */
-                if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
-                        DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
-                        SAFE_FREE(longfilename);
-                        return;
-                }
-
-                DEBUG(5, ("Reading the next header ...\n"));
-
-                switch (readtarheader((union hblock *) buffer_p,
-                                        &finfo, client_get_cur_dir())) {
-                        case -2:    /* Hmm, not good, but not fatal */
-                                DEBUG(0, ("Skipping %s...\n", finfo.name));
-                                if ((next_block(tarbuf, &buffer_p, tbufsiz) <= 0) && !skip_file(finfo.size)) {
-                                        DEBUG(0, ("Short file, bailing out...\n"));
-                                        SAFE_FREE(longfilename);
-                                        return;
-                                }
-                                break;
-
-                        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 ... */
-
-                        default: 
-                                /* No action */
-                                break;
-                }
-
-                /* Now, do we have a long file name? */
-                if (longfilename != NULL) {
-                        SAFE_FREE(finfo.name);   /* Free the space already allocated */
-                        finfo.name = longfilename;
-                        longfilename = NULL;
-                }
-
-                /* Well, now we have a header, process the file ...            */
-                /* Should we skip the file? We have the long name as well here */
-                skip = clipn && ((!tar_re_search && clipfind(cliplist, clipn, finfo.name) ^ tar_excl) ||
-                                        (tar_re_search && mask_match_list(finfo.name, cliplist, clipn, True)));
-
-                DEBUG(5, ("Skip = %i, cliplist=%s, file=%s\n", skip, (cliplist?cliplist[0]:NULL), finfo.name));
-                if (skip) {
-                        skip_file(finfo.size);
-                        continue;
-                }
-
-                /* We only get this far if we should process the file */
-                linkflag = ((union hblock *)buffer_p) -> dbuf.linkflag;
-                switch (linkflag) {
-                        case '0':  /* Should use symbolic names--FIXME */
-                                /*
-                                 * Skip to the next block first, so we can get the file, FIXME, should
-                                 * be in get_file ...
-                                 * The 'finfo.size != 0' fix is from Bob Boehmer <boehmer@worldnet.att.net>
-                                 * Fixes bug where file size in tarfile is zero.
-                                 */
-                                if ((finfo.size != 0) && next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
-                                        DEBUG(0, ("Short file, bailing out...\n"));
-                                        return;
-                                }
-                                if (!get_file(finfo)) {
-                                        DEBUG(0, ("Abandoning restore\n"));
-                                        return;
-                                }
-                                break;
-                        case '5':
-                                if (!get_dir(finfo)) {
-                                        DEBUG(0, ("Abandoning restore \n"));
-                                        return;
-                                }
-                                break;
-                        case 'L':
-                                SAFE_FREE(longfilename);
-                                longfilename = get_longfilename(finfo);
-                                if (!longfilename) {
-                                        DEBUG(0, ("abandoning restore\n"));
-                                        return;
-                                }
-                                DEBUG(5, ("Long file name: %s\n", longfilename));
-                                break;
-
-                        default:
-                                skip_file(finfo.size);  /* Don't handle these yet */
-                                break;
-                }
-        }
-}
-
-/*
- * samba interactive commands
- */
-
-/****************************************************************************
-Blocksize command
-***************************************************************************/
+        if (do_remove_prefix) {
+                /* /path */
+                if (path[0] == '/' || path[0] == '\\') {
+                        from += 1;
+                }
+
+                /* ./path */
+                if (path[1] != '\0' && path[0] == '.' && (path[1] == '/' || path[1] == '\\')) {
+                        from += 2;
+                }
+        }
+
+        /* replace / with \ */
+        while (from[0] != '\0') {
+                if (from[0] == '/') {
+                        to[0] = '\\';
+                } else {
+                        to[0] = from[0];
+                }
+
+                from++;
+                to++;
+        }
+        to[0] = '\0';
+
+        return path;
+}
+
+/**
+ * path_base_name - return @path basename
+ *
+ * If @path doesn't contain any directory separator return NULL.
+ */
+static NTSTATUS path_base_name(TALLOC_CTX *ctx, const char *path, char **_base)
+{
+        char *base = NULL;
+        int last = -1;
+        int i;
+
+        for (i = 0; path[i]; i++) {
+                if (path[i] == '\\' || path[i] == '/') {
+                        last = i;
+                }
+        }
+
+        if (last >= 0) {
+                base = talloc_strdup(ctx, path);
+                if (base == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+
+                base[last] = 0;
+        }
+
+        *_base = base;
+        return NT_STATUS_OK;
+}
+
+#else
+
+#define NOT_IMPLEMENTED DEBUG(0, ("tar mode not compiled. build with --with-libarchive\n"))
 
 int cmd_block(void)
 {
-        TALLOC_CTX *ctx = talloc_tos();
-        char *buf;
-        int block;
-
-        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
-                DEBUG(0, ("blocksize <n>\n"));
-                return 1;
-        }
-
-        block=atoi(buf);
-        if (block < 0 || block > 65535) {
-                DEBUG(0, ("blocksize out of range"));
-                return 1;
-        }
-
-        blocksize=block;
-        DEBUG(2,("blocksize is now %d\n", blocksize));
-        return 0;
-}
-
-/****************************************************************************
-command to set incremental / reset mode
-***************************************************************************/
+        NOT_IMPLEMENTED;
+        return 1;
+}
 
 int cmd_tarmode(void)
 {
-        TALLOC_CTX *ctx = talloc_tos();
-        char *buf;
-
-        while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
-                if (strequal(buf, "full"))
-                        tar_inc=False;
-                else if (strequal(buf, "inc"))
-                        tar_inc=True;
-                else if (strequal(buf, "reset"))
-                        tar_reset=True;
-                else if (strequal(buf, "noreset"))
-                        tar_reset=False;
-                else if (strequal(buf, "system"))
-                        tar_system=True;
-                else if (strequal(buf, "nosystem"))
-                        tar_system=False;
-                else if (strequal(buf, "hidden"))
-                        tar_hidden=True;
-                else if (strequal(buf, "nohidden"))
-                        tar_hidden=False;
-                else if (strequal(buf, "verbose") || strequal(buf, "noquiet"))
-                        tar_noisy=True;
-                else if (strequal(buf, "quiet") || strequal(buf, "noverbose"))
-                        tar_noisy=False;
-                else
-                        DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
-                TALLOC_FREE(buf);
-        }
-
-        DEBUG(0, ("tarmode is now %s, %s, %s, %s, %s\n",
-                        tar_inc ? "incremental" : "full",
-                        tar_system ? "system" : "nosystem",
-                        tar_hidden ? "hidden" : "nohidden",
-                        tar_reset ? "reset" : "noreset",
-                        tar_noisy ? "verbose" : "quiet"));
-        return 0;
-}
-
-/****************************************************************************
-Feeble attrib command
-***************************************************************************/
-
-int cmd_setmode(void)
-{
-        TALLOC_CTX *ctx = talloc_tos();
-        char *q;
-        char *buf;
-        char *fname = NULL;
-        uint16 attra[2];
-        int direct=1;
-
-        attra[0] = attra[1] = 0;
-
-        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
-                DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
-                return 1;
-        }
-
-        fname = talloc_asprintf(ctx,
-                                "%s%s",
-                                client_get_cur_dir(),
-                                buf);
-        if (!fname) {
-                return 1;
-        }
-
-        while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
-                q=buf;
-
-                while(*q) {
-                        switch (*q++) {
-                                case '+':
-                                        direct=1;
-                                        break;
-                                case '-':
-                                        direct=0;
-                                        break;
-                                case 'r':
-                                        attra[direct]|=FILE_ATTRIBUTE_READONLY;
-                                        break;
-                                case 'h':
-                                        attra[direct]|=FILE_ATTRIBUTE_HIDDEN;
-                                        break;
-                                case 's':
-                                        attra[direct]|=FILE_ATTRIBUTE_SYSTEM;
-                                        break;
-                                case 'a':
-                                        attra[direct]|=FILE_ATTRIBUTE_ARCHIVE;
-                                        break;
-                                default:
-                                        DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
-                                        return 1;
-                        }
-                }
-        }
-
-        if (attra[ATTRSET]==0 && attra[ATTRRESET]==0) {
-                DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
-                return 1;
-        }
-
-        DEBUG(2, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
-        do_setrattr(fname, attra[ATTRSET], ATTRSET);
-        do_setrattr(fname, attra[ATTRRESET], ATTRRESET);
-        return 0;
-}
-
-/**
- Convert list of tokens to array; dependent on above routine.
- Uses the global cmd_ptr from above - bit of a hack.
-**/
-
-static char **toktocliplist(int *ctok, const char *sep)
-{
-        char *s=(char *)cmd_ptr;
-        int ictok=0;
-        char **ret, **iret;
-
-        if (!sep)
-                sep = " \t\n\r";
-
-        while(*s && strchr_m(sep,*s))
-                s++;
-
-        /* nothing left? */
-        if (!*s)
-                return(NULL);
-
-        do {
-                ictok++;
-                while(*s && (!strchr_m(sep,*s)))
-                        s++;
-                while(*s && strchr_m(sep,*s))
-                        *s++=0;
-        } while(*s);
-
-        *ctok=ictok;
-        s=(char *)cmd_ptr;
-
-        if (!(ret=iret=SMB_MALLOC_ARRAY(char *,ictok+1)))
-                return NULL;
-
-        while(ictok--) {
-                *iret++=s;
-                if (ictok > 0) {
-                        while(*s++)
-                                ;
-                        while(!*s)
-                                s++;
-                }
-        }
-
-        ret[*ctok] = NULL;
-        return ret;
-}
-
-/****************************************************************************
-Principal command for creating / extracting
-***************************************************************************/
+        NOT_IMPLEMENTED;
+        return 1;
+}
 
 int cmd_tar(void)
 {
-        TALLOC_CTX *ctx = talloc_tos();
-        char *buf;
-        char **argl = NULL;
-        int argcl = 0;
-        int ret;
-
-        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
-                DEBUG(0,("tar <c|x>[IXbgan] <filename>\n"));
-                return 1;
-        }
-
-        argl=toktocliplist(&argcl, NULL);
-        if (!tar_parseargs(argcl, argl, buf, 0)) {
-                SAFE_FREE(argl);
-                return 1;
-        }
-
-        ret = process_tar();
-        SAFE_FREE(argl);
-        return ret;
-}
-
-/****************************************************************************
-Command line (option) version
-***************************************************************************/
-
-int process_tar(void)
-{
-        TALLOC_CTX *ctx = talloc_tos();
-        int rc = 0;
-        initarbuf();
-        switch(tar_type) {
-                case 'x':
-
-#if 0
-                        do_tarput2();
-#else
-                        do_tarput();
+        NOT_IMPLEMENTED;
+        return 1;
+}
+
+int tar_process(struct tar* tar)
+{
+        NOT_IMPLEMENTED;
+        return 1;
+}
+
+int tar_parse_args(struct tar *tar, const char *flag, const char **val, int valsize)
+{
+        NOT_IMPLEMENTED;
+        return 1;
+}
+
+bool tar_to_process(struct tar *tar)
+{
+        return false;
+}
+
+struct tar *tar_get_ctx()
+{
+        return NULL;
+}
+
 #endif
-                        SAFE_FREE(tarbuf);
-                        close(tarhandle);
-                        break;
-                case 'r':
-                case 'c':
-                        if (clipn && tar_excl) {
-                                int i;
-                                char *tarmac = NULL;
-
-                                for (i=0; i<clipn; i++) {
-                                        DEBUG(5,("arg %d = %s\n", i, cliplist[i]));
-
-                                        if (*(cliplist[i]+strlen(cliplist[i])-1)=='\\') {
-                                                *(cliplist[i]+strlen(cliplist[i])-1)='\0';
-                                        }
-
-                                        if (strrchr_m(cliplist[i], '\\')) {
-                                                char *p;
-                                                char saved_char;
-                                                char *saved_dir = talloc_strdup(ctx,
-                                                                        client_get_cur_dir());
-                                                if (!saved_dir) {
-                                                        return 1;
-                                                }
-
-                                                if (*cliplist[i]=='\\') {
-                                                        tarmac = talloc_strdup(ctx,
-                                                                        cliplist[i]);
-                                                } else {
-                                                        tarmac = talloc_asprintf(ctx,
-                                                                        "%s%s",
-                                                                        client_get_cur_dir(),
-                                                                        cliplist[i]);
-                                                }
-                                                if (!tarmac) {
-                                                        return 1;
-                                                }
-                                                /*
-                                                 * Strip off the last \\xxx
-                                                 * xxx element of tarmac to set
-                                                 * it as current directory.
-                                                 */
-                                                p = strrchr_m(tarmac, '\\');
-                                                if (!p) {
-                                                        return 1;
-                                                }
-                                                saved_char = p[1];
-                                                p[1] = '\0';
-
-                                                client_set_cur_dir(tarmac);
-
-                                                /*
-                                                 * Restore the character we
-                                                 * just replaced to
-                                                 * put the pathname
-                                                 * back as it was.
-                                                 */
-                                                p[1] = saved_char;
-
-                                                DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac));
-                                                do_list(tarmac,attribute,do_tar, False, True);
-
-                                                client_set_cur_dir(saved_dir);
-
-                                                TALLOC_FREE(saved_dir);
-                                                TALLOC_FREE(tarmac);
-                                        } else {
-                                                tarmac = talloc_asprintf(ctx,
-                                                                "%s%s",
-                                                                client_get_cur_dir(),
-                                                                cliplist[i]);
-                                                if (!tarmac) {
-                                                        return 1;
-                                                }
-                                                DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac));
-                                                do_list(tarmac,attribute,do_tar, False, True);
-                                                TALLOC_FREE(tarmac);
-                                        }
-                                }
-                        } else {
-                                char *mask = talloc_asprintf(ctx,
-                                                        "%s\\*",
-                                                        client_get_cur_dir());
-                                if (!mask) {
-                                        return 1;
-                                }
-                                DEBUG(5, ("process_tar, do_list with mask: %s\n", mask));
-                                do_list(mask,attribute,do_tar,False, True);
-                                TALLOC_FREE(mask);
-                        }
-
-                        if (ntarf) {
-                                dotareof(tarhandle);
-                        }
-                        close(tarhandle);
-                        SAFE_FREE(tarbuf);
-
-                        DEBUG(0, ("tar: dumped %d files and directories\n", ntarf));
-                        DEBUG(0, ("Total bytes written: %.0f\n", (double)ttarf));
-                        break;
-        }
-
-        if (must_free_cliplist) {
-                int i;
-                for (i = 0; i < clipn; ++i) {
-                        SAFE_FREE(cliplist[i]);
-                }
-                SAFE_FREE(cliplist);
-                cliplist = NULL;
-                clipn = 0;
-                must_free_cliplist = False;
-        }
-        return rc;
-}
-
-/****************************************************************************
-Find a token (filename) in a clip list
-***************************************************************************/
-
-static int clipfind(char **aret, int ret, char *tok)
-{
-        if (aret==NULL)
-                return 0;
-
-        /* ignore leading slashes or dots in token */
-        while(strchr_m("/\\.", *tok))
-                tok++;
-
-        while(ret--) {
-                char *pkey=*aret++;
-
-                /* ignore leading slashes or dots in list */
-                while(strchr_m("/\\.", *pkey))
-                        pkey++;
-
-                if (!strslashcmp(pkey, tok))
-                        return 1;
-        }
-        return 0;
-}
-
-/****************************************************************************
-Read list of files to include from the file and initialize cliplist
-accordingly.
-***************************************************************************/
-
-static int read_inclusion_file(char *filename)
-{
-        XFILE *inclusion = NULL;
-        char buf[PATH_MAX + 1];
-        char *inclusion_buffer = NULL;
-        int inclusion_buffer_size = 0;
-        int inclusion_buffer_sofar = 0;
-        char *p;
-        char *tmpstr;
-        int i;
-        int error = 0;
-
-        clipn = 0;
-        buf[PATH_MAX] = '\0'; /* guarantee null-termination */
-        if ((inclusion = x_fopen(filename, O_RDONLY, 0)) == NULL) {
-                /* XXX It would be better to include a reason for failure, but without
-                 * autoconf, it's hard to use strerror, sys_errlist, etc.
-                 */
-                DEBUG(0,("Unable to open inclusion file %s\n", filename));
-                return 0;
-        }
-
-        while ((! error) && (x_fgets(buf, sizeof(buf)-1, inclusion))) {
-                if (inclusion_buffer == NULL) {
-                        inclusion_buffer_size = 1024;
-                        if ((inclusion_buffer = (char *)SMB_MALLOC(inclusion_buffer_size)) == NULL) {
-                                DEBUG(0,("failure allocating buffer to read inclusion file\n"));
-                                error = 1;
-                                break;
-                        }
-                }
-
-                if (buf[strlen(buf)-1] == '\n') {
-                        buf[strlen(buf)-1] = '\0';
-                }
-
-                if ((strlen(buf) + 1 + inclusion_buffer_sofar) >= inclusion_buffer_size) {
-                        inclusion_buffer_size *= 2;
-                        inclusion_buffer = (char *)SMB_REALLOC(inclusion_buffer,inclusion_buffer_size);
-                        if (!inclusion_buffer) {
-                                DEBUG(0,("failure enlarging inclusion buffer to %d bytes\n",
-                                                inclusion_buffer_size));
-                                error = 1;
-                                break;
-                        }
-                }
-
-                safe_strcpy(inclusion_buffer + inclusion_buffer_sofar, buf, inclusion_buffer_size - inclusion_buffer_sofar);
-                inclusion_buffer_sofar += strlen(buf) + 1;
-                clipn++;
-        }
-        x_fclose(inclusion);
-
-        if (! error) {
-                /* Allocate an array of clipn + 1 char*'s for cliplist */
-                cliplist = SMB_MALLOC_ARRAY(char *, clipn + 1);
-                if (cliplist == NULL) {
-                        DEBUG(0,("failure allocating memory for cliplist\n"));
-                        error = 1;
-                } else {
-                        cliplist[clipn] = NULL;
-                        p = inclusion_buffer;
-                        for (i = 0; (! error) && (i < clipn); i++) {
-                                /* set current item to NULL so array will be null-terminated even if
-                                                * malloc fails below. */
-                                cliplist[i] = NULL;
-                                if ((tmpstr = (char *)SMB_MALLOC(strlen(p)+1)) == NULL) {
-                                        DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", i));
-                                        error = 1;
-                                } else {
-                                        unfixtarname(tmpstr, p, strlen(p) + 1, True);
-                                        cliplist[i] = tmpstr;
-                                        if ((p = strchr_m(p, '\000')) == NULL) {
-                                                DEBUG(0,("INTERNAL ERROR: inclusion_buffer is of unexpected contents.\n"));
-                                                abort();
-                                        }
-                                }
-                                ++p;
-                        }
-                        must_free_cliplist = True;
-                }
-        }
-
-        SAFE_FREE(inclusion_buffer);
-        if (error) {
-                if (cliplist) {
-                        char **pp;
-                        /* We know cliplist is always null-terminated */
-                        for (pp = cliplist; *pp; ++pp) {
-                                SAFE_FREE(*pp);
-                        }
-                        SAFE_FREE(cliplist);
-                        cliplist = NULL;
-                        must_free_cliplist = False;
-                }
-                return 0;
-        }
-
-        /* cliplist and its elements are freed at the end of process_tar. */
-        return 1;
-}
-
-/****************************************************************************
-Parse tar arguments. Sets tar_type, tar_excl, etc.
-***************************************************************************/
-
-int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
-{
-        int newOptind = Optind;
-        char tar_clipfl='\0';
-
-        /* Reset back to defaults - could be from interactive version 
-         * reset mode and archive mode left as they are though
-         */
-        tar_type='\0';
-        tar_excl=True;
-        dry_run=False;
-
-        while (*Optarg) {
-                switch(*Optarg++) {
-                        case 'c':
-                                tar_type='c';
-                                break;
-                        case 'x':
-                                if (tar_type=='c') {
-                                        printf("Tar must be followed by only one of c or x.\n");
-                                        return 0;
-                                }
-                                tar_type='x';
-                                break;
-                        case 'b':
-                                if (Optind>=argc || !(blocksize=atoi(argv[Optind]))) {
-                                        DEBUG(0,("Option b must be followed by valid blocksize\n"));
-                                        return 0;
-                                } else {
-                                        Optind++;
-                                        newOptind++;
-                                }
-                                break;
-                        case 'g':
-                                tar_inc=True;
-                                break;
-                        case 'N':
-                                if (Optind>=argc) {
-                                        DEBUG(0,("Option N must be followed by valid file name\n"));
-                                        return 0;
-                                } else {
-                                        SMB_STRUCT_STAT stbuf;
-
-                                        if (sys_stat(argv[Optind], &stbuf,
-                                                     false) == 0) {
-                                                newer_than = convert_timespec_to_time_t(
-                                                        stbuf.st_ex_mtime);
-                                                DEBUG(1,("Getting files newer than %s",
-                                                        time_to_asc(newer_than)));
-                                                newOptind++;
-                                                Optind++;
-                                        } else {
-                                                DEBUG(0,("Error setting newer-than time\n"));
-                                                return 0;
-                                        }
-                                }
-                                break;
-                        case 'a':
-                                tar_reset=True;
-                                break;
-                        case 'q':
-                                tar_noisy=False;
-                                break;
-                        case 'I':
-                                if (tar_clipfl) {
-                                        DEBUG(0,("Only one of I,X,F must be specified\n"));
-                                        return 0;
-                                }
-                                tar_clipfl='I';
-                                break;
-                        case 'X':
-                                if (tar_clipfl) {
-                                        DEBUG(0,("Only one of I,X,F must be specified\n"));
-                                        return 0;
-                                }
-                                tar_clipfl='X';
-                                break;
-                        case 'F':
-                                if (tar_clipfl) {
-                                        DEBUG(0,("Only one of I,X,F must be specified\n"));
-                                        return 0;
-                                }
-                                tar_clipfl='F';
-                                break;
-                        case 'r':
-                                DEBUG(0, ("tar_re_search set\n"));
-                                tar_re_search = True;
-                                break;
-                        case 'n':
-                                if (tar_type == 'c') {
-                                        DEBUG(0, ("dry_run set\n"));
-                                        dry_run = True;
-                                } else {
-                                        DEBUG(0, ("n is only meaningful when creating a tar-file\n"));
-                                        return 0;
-                                }
-                                break;
-                        default:
-                                DEBUG(0,("Unknown tar option\n"));
-                                return 0;
-                }
-        }
-
-        if (!tar_type) {
-                printf("Option T must be followed by one of c or x.\n");
-                return 0;
-        }
-
-        /* tar_excl is true if cliplist lists files to be included.
-         * Both 'I' and 'F' mean include. */
-        tar_excl=tar_clipfl!='X';
-
-        if (tar_clipfl=='F') {
-                if (argc-Optind-1 != 1) {
-                        DEBUG(0,("Option F must be followed by exactly one filename.\n"));
-                        return 0;
-                }
-                newOptind++;
-                /* Optind points at the tar output file, Optind+1 at the inclusion file. */
-                if (! read_inclusion_file(argv[Optind+1])) {
-                        return 0;
-                }
-        } else if (Optind+1<argc && !tar_re_search) { /* For backwards compatibility */
-                char *tmpstr;
-                char **tmplist;
-                int clipcount;
-
-                cliplist=argv+Optind+1;
-                clipn=argc-Optind-1;
-                clipcount = clipn;
-
-                if ((tmplist=SMB_MALLOC_ARRAY(char *,clipn)) == NULL) {
-                        DEBUG(0, ("Could not allocate space to process cliplist, count = %i\n", clipn));
-                        return 0;
-                }
-
-                for (clipcount = 0; clipcount < clipn; clipcount++) {
-
-                        DEBUG(5, ("Processing an item, %s\n", cliplist[clipcount]));
-
-                        if ((tmpstr = (char *)SMB_MALLOC(strlen(cliplist[clipcount])+1)) == NULL) {
-                                DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", clipcount));
-                                SAFE_FREE(tmplist);
-                                return 0;
-                        }
-
-                        unfixtarname(tmpstr, cliplist[clipcount], strlen(cliplist[clipcount]) + 1, True);
-                        tmplist[clipcount] = tmpstr;
-                        DEBUG(5, ("Processed an item, %s\n", tmpstr));
-
-                        DEBUG(5, ("Cliplist is: %s\n", cliplist[0]));
-                }
-
-                cliplist = tmplist;
-                must_free_cliplist = True;
-
-                newOptind += clipn;
-        }
-
-        if (Optind+1<argc && tar_re_search && tar_clipfl != 'F') {
-                /* Doing regular expression seaches not from an inclusion file. */
-                clipn=argc-Optind-1;
-                cliplist=argv+Optind+1;
-                newOptind += clipn;
-        }
-
-        if (Optind>=argc || !strcmp(argv[Optind], "-")) {
-                /* Sets tar handle to either 0 or 1, as appropriate */
-                tarhandle=(tar_type=='c');
-                /*
-                 * Make sure that dbf points to stderr if we are using stdout for 
-                 * tar output
-                 */
-                if (tarhandle == 1)  {
-                        setup_logging("smbclient", DEBUG_STDERR);
-                }
-                if (!argv[Optind]) {
-                        DEBUG(0,("Must specify tar filename\n"));
-                        return 0;
-                }
-                if (!strcmp(argv[Optind], "-")) {
-                        newOptind++;
-                }
-
-        } else {
-                if (tar_type=='c' && dry_run) {
-                        tarhandle=-1;
-                } else if ((tar_type=='x' && (tarhandle = sys_open(argv[Optind], O_RDONLY, 0)) == -1)
-                                        || (tar_type=='c' && (tarhandle=sys_creat(argv[Optind], 0644)) < 0)) {
-                        DEBUG(0,("Error opening local file %s - %s\n", argv[Optind], strerror(errno)));
-                        return(0);
-                }
-                newOptind++;
-        }
-
-        return newOptind;
-}

vendor/current/source3/client/dnsbrowse.c

@@ -125 +125 @@
         }
 
-        bresult = TALLOC_ARRAY(talloc_tos(), struct mdns_smbsrv_result, 1);
+        bresult = talloc_array(talloc_tos(), struct mdns_smbsrv_result, 1);
         if (bresult == NULL) {
                 return;
@@ -169 +169 @@
                 int revents;
 
-                ret = poll_one_fd(mdnsfd, POLLIN|POLLHUP, &revents, 1000);
+                ret = poll_one_fd(mdnsfd, POLLIN|POLLHUP, 1000, &revents);
                 if (ret <= 0 && errno != EINTR) {
                         break;

vendor/current/source3/client/smbspool.c

@@ -152 +152 @@
                 goto done;
         } else {
-                copies = atoi(argv[4]);
+                char *p = argv[4];
+                char *endp;
+
+                copies = strtol(p, &endp, 10);
+                if (p == endp) {
+                        perror("ERROR: Unable to determine number of copies");
+                        goto done;
+                }
         }
 
@@ -246 +253 @@
         setup_logging("smbspool", DEBUG_STDOUT);
 
-        lp_set_in_client(True); /* Make sure that we tell lp_load we are */
-
-        load_case_tables();
-
-        if (!lp_load(get_dyn_CONFIGFILE(), True, False, False, True)) {
+        smb_init_locale();
+
+        if (!lp_load_client(get_dyn_CONFIGFILE())) {
                 fprintf(stderr, "ERROR: Can't load %s - run testparm to debug it\n", get_dyn_CONFIGFILE());
                 goto done;
@@ -342 +347 @@
 
 
-        fprintf(stderr, "DEBUG: get_exit_code(cli=%p, nt_status=%x)\n",
-                cli, NT_STATUS_V(nt_status));
+        fprintf(stderr, "DEBUG: get_exit_code(cli=%p, nt_status=%s [%x])\n",
+                cli, nt_errstr(nt_status), NT_STATUS_V(nt_status));
 
         for (i = 0; i < ARRAY_SIZE(auth_errors); i++) {
@@ -405 +410 @@
         *need_auth = false;
         nt_status = cli_start_connection(&cli, myname, server, NULL, port,
-                                         Undefined, flags);
+                                         SMB_SIGNING_DEFAULT, flags);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 fprintf(stderr, "ERROR: Connection failed: %s\n", nt_errstr(nt_status));
@@ -436 +441 @@
         }
 
-        nt_status = cli_tcon_andx(cli, share, "?????", password,
-                                  strlen(password) + 1);
+        nt_status = cli_tree_connect(cli, share, "?????", password,
+                                     strlen(password) + 1);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 fprintf(stderr, "ERROR: Tree connect failed (%s)\n",

vendor/current/source3/client/tree.c

@@ -31 +31 @@
 struct tree_data {
 
-  guint32 type;    /* Type of tree item, an SMBC_TYPE */
+  guint32_t type;    /* Type of tree item, an SMBC_TYPE */
   char name[256];  /* May need to change this later   */
 
@@ -129 +129 @@
 }
 
-struct tree_data *make_tree_data(guint32 type, const char *name)
+struct tree_data *make_tree_data(guint32_t type, const char *name)
 {
   struct tree_data *p = SMB_MALLOC_P(struct tree_data);