Adding upstream version 2:4.20.0+dfsg.upstream/2%4.20.0+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1903 insertions, 0 deletions

diff --git a/source3/client/clitar.c b/source3/client/clitar.c
new file mode 100644
index 0000000..14b9811
--- /dev/null
+++ b/source3/client/clitar.c
@@ -0,0 +1,1903 @@
+/*
+   Unix SMB/CIFS implementation.
+   Tar backup command extension
+   Copyright (C) Aurélien Aptel 2013
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * # 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 "client/client_proto.h"
+#include "client/clitar_proto.h"
+#include "libsmb/libsmb.h"
+
+#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 */
+};
+
+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;
+
+	/* counters */
+	uint64_t numdir;
+	uint64_t numfile;
+};
+
+/**
+ * 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(void)
+{
+	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;
+	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,     false},
+		{"noverbose", &tar_ctx.mode.verbose,     true },
+	};
+
+	ctx = talloc_new(NULL);
+	if (ctx == NULL) {
+		return 1;
+	}
+
+	while (next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
+		size_t i;
+		for (i = 0; i < ARRAY_SIZE(table); i++) {
+			if (strequal(table[i].cmd, buf)) {
+				*table[i].p = table[i].value;
+				break;
+			}
+		}
+
+		if (i == ARRAY_SIZE(table))
+			d_printf("tarmode: unrecognised option %s\n", buf);
+	}
+
+	d_printf("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"     : "noverbose");
+
+	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) {
+		d_printf("tar <c|x>[IXFbgvanN] [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) {
+		d_printf("parse_args failed\n");
+		err = 1;
+		goto out;
+	}
+
+	rc = tar_process(&tar_ctx);
+	if (rc != 0) {
+		d_printf("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_WARNING("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) {
+				d_printf("Tar must be followed by only one of c or x.\n");
+				return 1;
+			}
+			t->mode.operation = TAR_CREATE;
+			break;
+		case 'x':
+			if (t->mode.operation != TAR_NO_OPERATION) {
+				d_printf("Tar must be followed by only one of c or x.\n");
+				return 1;
+			}
+			t->mode.operation = TAR_EXTRACT;
+			break;
+
+			/* selection  */
+		case 'I':
+			if (t->mode.selection != TAR_NO_SELECTION) {
+				d_printf("Only one of I,X,F must be specified\n");
+				return 1;
+			}
+			t->mode.selection = TAR_INCLUDE;
+			break;
+		case 'X':
+			if (t->mode.selection != TAR_NO_SELECTION) {
+				d_printf("Only one of I,X,F must be specified\n");
+				return 1;
+			}
+			t->mode.selection = TAR_EXCLUDE;
+			break;
+		case 'F':
+			if (t->mode.selection != TAR_NO_SELECTION) {
+				d_printf("Only one of I,X,F must be specified\n");
+				return 1;
+			}
+			t->mode.selection = TAR_INCLUDE;
+			do_read_list = true;
+			break;
+
+			/* blocksize */
+		case 'b':
+			if (ival >= valsize) {
+				d_printf("Option b must be followed by a blocksize\n");
+				return 1;
+			}
+
+			if (tar_set_blocksize(t, atoi(val[ival]))) {
+				d_printf("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) {
+				d_printf("Option N must be followed by valid file name\n");
+				return 1;
+			}
+
+			if (tar_set_newer_than(t, val[ival])) {
+				d_printf("Error setting newer-than time\n");
+				return 1;
+			}
+
+			ival++;
+			break;
+
+			/* reset mode */
+		case 'a':
+			t->mode.reset = true;
+			break;
+
+			/* verbose */
+		case 'v':
+			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) {
+				d_printf("n is only meaningful when creating a tar-file\n");
+				return 1;
+			}
+
+			t->mode.dry = true;
+			d_printf("dry_run set\n");
+			break;
+
+		default:
+			d_printf("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) {
+		d_printf("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) {
+			d_printf("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_WARNING("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_WARNING("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;
+	struct timespec tp_start, tp_end;
+	TALLOC_CTX *ctx = talloc_new(NULL);
+	if (ctx == NULL) {
+		return 1;
+	}
+
+	clock_gettime_mono(&tp_start);
+
+	t->numfile = 0;
+	t->numdir = 0;
+	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) {
+			d_printf("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) {
+			d_printf("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 {
+			r = archive_write_open_filename(t->archive, t->tar_path);
+		}
+
+		if (r != ARCHIVE_OK) {
+			d_printf("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;
+		}
+		mask = client_clean_name(ctx, mask);
+		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, true, true);
+		if (!NT_STATUS_IS_OK(status)) {
+			DBG(0, ("do_list fail %s\n", nt_errstr(status)));
+			err = 1;
+			goto out_close;
+		}
+	}
+
+	clock_gettime_mono(&tp_end);
+	d_printf("tar: dumped %"PRIu64" files and %"PRIu64" directories\n",
+	         t->numfile, t->numdir);
+	d_printf("Total bytes written: %"PRIu64" (%.1f MiB/s)\n",
+		t->total_size,
+		t->total_size/timespec_elapsed2(&tp_start, &tp_end)/1024/1024);
+
+out_close:
+
+	if (!t->mode.dry) {
+		r = archive_write_close(t->archive);
+		if (r != ARCHIVE_OK) {
+			d_printf("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;
+		}
+		mask = client_clean_name(ctx, mask);
+		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;
+			}
+			base = client_clean_name(ctx, 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, true, 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;
+	char *old_dir = NULL;
+	char *new_dir = NULL;
+	const char *initial_dir = dir;
+	bool skip = false;
+	bool isdir;
+	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;
+	}
+	remote_name = client_clean_name(ctx, remote_name);
+	if (remote_name == NULL) {
+		status = NT_STATUS_NO_MEMORY;
+		goto out;
+	}
+
+	if (strequal(finfo->name, "..") || strequal(finfo->name, ".")) {
+		goto out;
+	}
+
+	isdir = finfo->attr & FILE_ATTRIBUTE_DIRECTORY;
+	if (isdir) {
+		old_dir = talloc_strdup(ctx, initial_dir);
+		new_dir = talloc_asprintf(ctx, "%s\\", remote_name);
+		if ((old_dir == NULL) || (new_dir == NULL)) {
+			status = NT_STATUS_NO_MEMORY;
+			goto out;
+		}
+	}
+
+	status = tar_create_skip_path(&tar_ctx,
+	                              isdir ? new_dir : 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;
+	}
+
+	rc = tar_get_file(&tar_ctx, remote_name, finfo);
+	if (rc != 0) {
+		status = NT_STATUS_UNSUCCESSFUL;
+		goto out;
+	}
+
+out:
+	talloc_free(ctx);
+	return status;
+}
+
+/**
+ * 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->attr & 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) {
+		d_printf("Remote file %s too big\n", full_dos_path);
+		goto out_entry;
+	}
+
+	archive_entry_set_size(entry, (int64_t)finfo->size);
+
+	if (isdir) {
+		/* It's a directory just write a header */
+		r = archive_write_header(t->archive, entry);
+		if (r != ARCHIVE_OK) {
+			d_printf("Fatal: %s\n", archive_error_string(t->archive));
+			err = 1;
+		}
+		if (t->mode.verbose) {
+			d_printf("a %s\\\n", full_dos_path);
+		}
+		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)) {
+		d_printf("%s opening remote file %s\n",
+					nt_errstr(status), full_dos_path);
+		goto out_entry;
+	}
+
+	/* don't make tar file entry until after the file is open */
+	r = archive_write_header(t->archive, entry);
+	if (r != ARCHIVE_OK) {
+		d_printf("Fatal: %s\n", archive_error_string(t->archive));
+		err = 1;
+		goto out_entry;
+	}
+
+	if (t->mode.verbose) {
+		d_printf("a %s\n", full_dos_path);
+	}
+
+	do {
+		status = cli_read(cli, remote_fd, buf, off, sizeof(buf), &len);
+		if (!NT_STATUS_IS_OK(status)) {
+			d_printf("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) {
+			d_printf("Fatal: %s\n", archive_error_string(t->archive));
+			err = 1;
+			goto out_close;
+		}
+
+	} while (off < finfo->size);
+	t->numfile++;
+
+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) {
+		d_printf("Can't open %s : %s\n", t->tar_path,
+					archive_error_string(t->archive));
+		err = 1;
+		goto out;
+	}
+
+	for (;;) {
+		NTSTATUS status;
+		bool skip = false;
+		r = archive_read_next_header(t->archive, &entry);
+		if (r == ARCHIVE_EOF) {
+			break;
+		}
+		if (r == ARCHIVE_WARN) {
+			d_printf("Warning: %s\n", archive_error_string(t->archive));
+		}
+		if (r == ARCHIVE_FATAL) {
+			d_printf("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)));
+
+		if (t->mode.verbose) {
+			d_printf("x %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) {
+		d_printf("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 filetype = archive_entry_filetype(entry);
+	mode_t mode = archive_entry_mode(entry);
+	time_t mtime = archive_entry_mtime(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;
+	}
+	full_path = client_clean_name(ctx, full_path);
+	if (full_path == NULL) {
+		err = 1;
+		goto out;
+	}
+
+	if (filetype != AE_IFREG && filetype != AE_IFDIR) {
+		d_printf("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 (filetype == AE_IFDIR) {
+		goto out;
+	}
+
+	status = cli_open(cli, full_path, flags, DENY_NONE, &remote_fd);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_printf("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) {
+			d_printf("Warning: %s\n", archive_error_string(t->archive));
+		}
+		if (r == ARCHIVE_FATAL) {
+			d_printf("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)) {
+			d_printf("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)) {
+		d_printf("Error closing remote file %s: %s\n",
+					full_path, nt_errstr(status));
+		err = 1;
+	}
+
+	status = cli_setatr(cli, full_path, mode, mtime);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_printf("Error setting attributes on 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) {
+		d_printf("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", 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 = -1;
+	TALLOC_CTX *ctx = talloc_new(NULL);
+	if (ctx == NULL) {
+		return 1;
+	}
+
+	fd = open(filename, O_RDONLY);
+	if (fd < 0) {
+		d_printf("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;
+		}
+	}
+
+out:
+	if (fd != -1) {
+		close(fd);
+	}
+	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 should 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->attr;
+	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_WARNING("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 comparison is case-insensitive.
+ */
+static NTSTATUS is_subpath(const char *sub, const char *full,
+			   bool *_subpath_match)
+{
+	NTSTATUS status = NT_STATUS_OK;
+	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 (s == 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;
+}
+
+
+/**
+ * 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)) {
+				d_printf("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
+	 */
+	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 used --without-libarchive\n"))
+
+int cmd_block(void)
+{
+	NOT_IMPLEMENTED;
+	return 1;
+}
+
+int cmd_tarmode(void)
+{
+	NOT_IMPLEMENTED;
+	return 1;
+}
+
+int cmd_tar(void)
+{
+	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