/*
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
it under the terms of the GNU General Public License as published by
You should have received a copy of the GNU General Public License
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 ... */
-};
-
-typedef struct {
- file_info2 *top;
- int items;
-} stack;
+#ifdef HAVE_LIBARCHIVE
-#define SEPARATORS " \t\n\r"
-extern time_t newer_than;
-extern struct cli_state *cli;
+#include <archive.h>
+#include <archive_entry.h>
-/* 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
+/* prepend module name and line number to debug messages */
+#define DBG(a, b) (DEBUG(a, ("tar:%-4d ", __LINE__)), DEBUG(a, b))
-static uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+/* preprocessor magic to stringify __LINE__ (int) */
+#define STR1(x) #x
+#define STR2(x) STR1(x)
-#ifndef CLIENT_TIMEOUT
-#define CLIENT_TIMEOUT (30*1000)
-#endif
+/**
+ * Number of byte in a block unit.
+ */
+#define TAR_BLOCK_UNIT 512
-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 char *cmd_ptr;
-
-extern bool lowercase;
-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);
+/**
+ * Default tar block size in TAR_BLOCK_UNIT.
+ */
+#define TAR_DEFAULT_BLOCK_SIZE 20
-/*
- * tar specific utitlities
+/**
+ * Maximum value for the blocksize field
*/
+#define TAR_MAX_BLOCK_SIZE 0xffff
-/****************************************************************************
-Write a tar header to buffer
-****************************************************************************/
+/**
+ * Size of the buffer used when downloading a file
+ */
+#define TAR_CLI_READ_SIZE 0xff00
-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;
+#define TAR_DO_LIST_ATTR (FILE_ATTRIBUTE_DIRECTORY \
+ | FILE_ATTRIBUTE_SYSTEM \
+ | FILE_ATTRIBUTE_HIDDEN)
- DEBUG(5, ("WriteTarHdr, Type = %c, Size= %.0f, Name = %s\n", ftype, (double)size, aname));
- memset(hb.dummy, 0, sizeof(hb.dummy));
+enum tar_operation {
+ TAR_NO_OPERATION,
+ TAR_CREATE, /* c flag */
+ TAR_EXTRACT, /* x flag */
+};
- 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';
- strlcpy(hb.dbuf.mode, amode ? amode : "", sizeof(hb.dbuf.mode));
- 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;
+enum tar_selection {
+ TAR_NO_SELECTION,
+ TAR_INCLUDE, /* I and F flag, default */
+ TAR_EXCLUDE, /* X flag */
+};
- for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;)
- chk+=(0xFF & *jp++);
+enum {
+ ATTR_UNSET,
+ ATTR_SET,
+};
- oct_it((uint64_t) chk, 8, hb.dbuf.chksum);
- hb.dbuf.chksum[6] = '\0';
+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;
+};
- (void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
-}
+/**
+ * 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,
+};
-/****************************************************************************
-Read a tar header into a hblock structure, and validate
-***************************************************************************/
+/* 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);
+static int set_remote_attr(const char *filename, uint16 new_attr, int mode);
-static long readtarheader(union hblock *hb, file_info2 *finfo, const char *prefix)
+/**
+ * tar_get_ctx - retrieve global tar context handle
+ */
+struct tar *tar_get_ctx()
{
- long chk, fchk;
- 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));
+ return &tar_ctx;
+}
- DEBUG(5, ("checksum totals chk=%ld fchk=%ld chksum=%s\n",
- chk, fchk, hb->dbuf.chksum));
+/**
+ * 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;
+ }
- if (fchk != chk) {
- DEBUG(0, ("checksums don't match %ld %ld\n", fchk, chk));
- dump_data(5, (uint8 *)hb - TBLOCK, TBLOCK *3);
- return -1;
+ ok = next_token_talloc(ctx, &cmd_ptr, &buf, NULL);
+ if (!ok) {
+ DBG(0, ("blocksize <n>\n"));
+ err = 1;
+ goto out;
}
- if ((finfo->name = SMB_MALLOC(strlen(prefix) + strlen(hb -> dbuf.name) + 4)) == NULL) {
- DEBUG(0, ("Out of space creating file_info2 for %s\n", hb -> dbuf.name));
- return(-1);
+ ok = tar_set_blocksize(&tar_ctx, atoi(buf));
+ if (ok) {
+ DBG(0, ("invalid blocksize\n"));
+ err = 1;
+ goto out;
}
- strlcpy(finfo->name, prefix, strlen(prefix) + strlen(hb -> dbuf.name) + 4);
+ DBG(2, ("blocksize is now %d\n", tar_ctx.mode.blocksize));
- /* 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);
+out:
+ talloc_free(ctx);
+ return err;
+}
- /* 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;
+/**
+ * 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;
+ 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;
}
}
- }
- 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 */
+ if (i == ARRAY_SIZE(table))
+ DBG(0, ("tarmode: unrecognised option %s\n", buf));
}
- /*
- * 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));
- }
+ 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"));
- return True;
+ talloc_free(ctx);
+ return 0;
}
-/****************************************************************************
-Write out the tar buffer to tape or wherever
-****************************************************************************/
-
-static int dotarbuf(int f, char *b, int n)
+/**
+ * cmd_tar - interactive command to start a tar backup/restoration
+ *
+ * Check presence of argument, parse them and handle the request.
+ */
+int cmd_tar(void)
{
- 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;
- }
+ 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;
}
- if (n>0) {
- memcpy(tarbuf+tp, b, n);
- tp+=n;
+ 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;
}
- return(fail ? writ : 0);
-}
-
-/****************************************************************************
-Write zeros to buffer / tape
-****************************************************************************/
+ flag = buf;
+ val = talloc_array(ctx, const char *, maxtok);
+ if (val == NULL) {
+ err = 1;
+ goto out;
+ }
-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;
+ while (next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
+ val[i++] = buf;
}
-}
-/****************************************************************************
-Malloc tape buffer
-****************************************************************************/
+ rc = tar_parse_args(&tar_ctx, flag, val, i);
+ if (rc != 0) {
+ DBG(0, ("parse_args failed\n"));
+ err = 1;
+ goto out;
+ }
-static void initarbuf(void)
-{
- /* initialize tar buffer */
- tbufsiz=blocksize*TBLOCK;
- tarbuf=(char *)SMB_MALLOC(tbufsiz); /* FIXME: We might not get the buffer */
+ rc = tar_process(&tar_ctx);
+ if (rc != 0) {
+ DBG(0, ("tar_process failed\n"));
+ err = 1;
+ goto out;
+ }
- /* reset tar buffer pointer and tar file counter and total dumped */
- tp=0; ntarf=0; ttarf=0;
+out:
+ talloc_free(ctx);
+ return err;
}
-/****************************************************************************
-Write two zero blocks at end of file
-****************************************************************************/
-
-static void dotareof(int f)
+/**
+ * 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)
{
- SMB_STRUCT_STAT stbuf;
- /* Two zero blocks at end of file, write out full buffer */
-
- if (dry_run)
- return;
+ const extern char *cmd_ptr;
+ char *buf;
+ char *fname = NULL;
+ uint16 attr[2] = {0};
+ int mode = ATTR_SET;
+ int err = 0;
+ bool ok;
+ TALLOC_CTX *ctx = talloc_new(NULL);
+ if (ctx == NULL) {
+ return 1;
+ }
- (void) dozerobuf(f, TBLOCK);
- (void) dozerobuf(f, TBLOCK);
+ ok = next_token_talloc(ctx, &cmd_ptr, &buf, NULL);
+ if (!ok) {
+ DBG(0, ("setmode <filename> <[+|-]rsha>\n"));
+ err = 1;
+ goto out;
+ }
- if (sys_fstat(f, &stbuf, false) == -1) {
- DEBUG(0, ("Couldn't stat file handle\n"));
- return;
+ fname = talloc_asprintf(ctx,
+ "%s%s",
+ client_get_cur_dir(),
+ buf);
+ if (fname == NULL) {
+ err = 1;
+ goto out;
}
- /* 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"));
+ 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:
+ DBG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
+ err = 1;
+ goto out;
+ }
}
}
-}
-/****************************************************************************
-(Un)mangle DOS pathname, make nonabsolute
-****************************************************************************/
+ if (attr[ATTR_SET] == 0 && attr[ATTR_UNSET] == 0) {
+ DBG(0, ("setmode <filename> <[+|-]rsha>\n"));
+ err = 1;
+ goto out;
+ }
-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--;
+ DBG(2, ("perm set %d %d\n", attr[ATTR_SET], attr[ATTR_UNSET]));
- StrnCpy(tptr, fp, l-1);
- string_replace(tptr, '\\', '/');
+ /* 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;
}
-/****************************************************************************
-Convert from decimal to octal string
-****************************************************************************/
-
-static void oct_it (uint64_t value, int ndgs, char *p)
+/**
+ * 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)
{
- /* 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
-***************************************************************************/
+ 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;
+ }
-static long unoct(char *p, int ndgs)
-{
- long value=0;
- /* Converts octal string to long, ignoring any non-digit */
+ 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;
+ }
+ 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;
+ }
+ t->mode.operation = TAR_EXTRACT;
+ break;
- while (--ndgs) {
- if (isdigit((int)*p))
- value = (value << 3) | (long) (*p - '0');
+ /* selection */
+ case 'I':
+ if (t->mode.selection != TAR_NO_SELECTION) {
+ DBG(0,("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) {
+ DBG(0,("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) {
+ DBG(0,("Only one of I,X,F must be specified\n"));
+ return 1;
+ }
+ t->mode.selection = TAR_INCLUDE;
+ do_read_list = true;
+ break;
- p++;
- }
+ /* blocksize */
+ case 'b':
+ if (ival >= valsize) {
+ DBG(0, ("Option b must be followed by a blocksize\n"));
+ return 1;
+ }
- return value;
-}
+ if (tar_set_blocksize(t, atoi(val[ival]))) {
+ DBG(0, ("Option b must be followed by a valid blocksize\n"));
+ return 1;
+ }
-/****************************************************************************
-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.
-***************************************************************************/
+ ival++;
+ break;
-static int strslashcmp(char *s1, char *s2)
-{
- char *s1_0=s1;
+ /* incremental mode */
+ case 'g':
+ t->mode.incremental = true;
+ break;
- while(*s1 && *s2 && (*s1 == *s2 || tolower_m(*s1) == tolower_m(*s2) ||
- (*s1 == '\\' && *s2=='/') || (*s1 == '/' && *s2=='\\'))) {
- s1++; s2++;
- }
+ /* newer than */
+ case 'N':
+ if (ival >= valsize) {
+ DBG(0, ("Option N must be followed by valid file name\n"));
+ return 1;
+ }
- /* 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;
+ if (tar_set_newer_than(t, val[ival])) {
+ DBG(0,("Error setting newer-than time\n"));
+ return 1;
+ }
- /* ignore trailing slash on s1 */
- if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1))
- return 0;
+ ival++;
+ break;
- /* check for s1 is an "initial" string of s2 */
- if ((*s2 == '/' || *s2 == '\\') && !*s1)
- return 0;
+ /* reset mode */
+ case 'a':
+ t->mode.reset = true;
+ break;
- return *s1-*s2;
-}
+ /* verbose */
+ case 'q':
+ t->mode.verbose = true;
+ break;
-/****************************************************************************
-Ensure a remote path exists (make if necessary)
-***************************************************************************/
+ /* regex match */
+ case 'r':
+ t->mode.regex = true;
+ break;
-static bool ensurepath(const char *fname)
-{
- /* *must* be called with buffer ready malloc'ed */
- /* ensures path exists */
-
- char *partpath, *ffname;
- size_t fnamelen = strlen(fname)+1;
- const char *p=fname;
- char *basehack;
- char *saveptr;
- NTSTATUS status;
+ /* 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;
+ }
- DEBUG(5, ( "Ensurepath called with: %s\n", fname));
+ t->mode.dry = true;
+ DBG(0, ("dry_run set\n"));
+ break;
- partpath = SMB_MALLOC(fnamelen);
- ffname = SMB_MALLOC(fnamelen);
+ default:
+ DBG(0,("Unknown tar option\n"));
+ return 1;
+ }
- if ((partpath == NULL) || (ffname == NULL)){
- DEBUG(0, ("Out of memory in ensurepath: %s\n", fname));
- SAFE_FREE(partpath);
- SAFE_FREE(ffname);
- return(False);
+ flag++;
}
- *partpath = 0;
+ /* no selection given? default selection is include */
+ if (t->mode.selection == TAR_NO_SELECTION) {
+ t->mode.selection = TAR_INCLUDE;
+ }
- /* fname copied to ffname so can strtok_r */
+ if (valsize - ival < 1) {
+ DBG(0, ("No tar file given.\n"));
+ return 1;
+ }
- strlcpy(ffname, fname, fnamelen);
+ /* handle TARFILE */
+ t->tar_path = talloc_strdup(ctx, val[ival]);
+ if (t->tar_path == NULL) {
+ return 1;
+ }
+ ival++;
- /* 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';
+ /*
+ * 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);
}
- p=strtok_r(ffname, "\\", &saveptr);
+ /* handle PATHs... */
- while (p) {
- strlcat(partpath, p, fnamelen);
+ /* 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;
+ }
- status = cli_chkpath(cli, partpath);
- if (!NT_STATUS_IS_OK(status)) {
- status = cli_mkdir(cli, partpath);
+ 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)) {
- SAFE_FREE(partpath);
- SAFE_FREE(ffname);
- DEBUG(0, ("Error mkdir %s\n", nt_errstr(status)));
- return False;
- } else {
- DEBUG(3, ("mkdirhiering %s\n", partpath));
+ return 1;
}
}
-
- strlcat(partpath, "\\", fnamelen);
- p = strtok_r(NULL, "/\\", &saveptr);
}
- SAFE_FREE(partpath);
- SAFE_FREE(ffname);
- return True;
+ t->to_process = true;
+ tar_dump(t);
+ return 0;
}
-static int padit(char *buf, uint64_t bufsize, uint64_t padsize)
+/**
+ * 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 berr= 0;
- int bytestowrite;
+ int rc = 0;
+
+ if (t == NULL) {
+ DBG(0, ("Invalid tar context\n"));
+ return 1;
+ }
- 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;
+ 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;
}
- return berr;
+ t->to_process = false;
+ tar_free_mem_context(t);
+ DBG(5, ("tar_process done, err = %d\n", rc));
+ return rc;
}
-static void do_setrattr(char *name, uint16 attr, int set)
+/**
+ * tar_create - create archive and fetch files
+ */
+static int tar_create(struct tar* t)
{
- uint16 oldattr;
+ 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;
+ }
- if (!NT_STATUS_IS_OK(cli_getatr(cli, name, &oldattr, NULL, NULL))) {
- return;
+ /*
+ * 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 {
+ 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;
+ }
}
- if (set == ATTRSET) {
- attr |= oldattr;
+ /*
+ * 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 {
- attr = oldattr & ~attr;
+ 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;
+ }
}
- status = cli_setatr(cli, name, attr, 0);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(1, ("setatr failed: %s\n", nt_errstr(status)));
+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:
+ archive_write_free(t->archive);
+ talloc_free(ctx);
+ return err;
}
-/****************************************************************************
-append one remote file to the tar file
-***************************************************************************/
-
-static NTSTATUS do_atar(const char *rname_in, char *lname,
- struct file_info *finfo1)
+/**
+ * tar_create_from_list - fetch from path list in include mode
+ */
+static int tar_create_from_list(struct tar *t)
{
- 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;
- size_t datalen=0;
- char *rname = NULL;
- TALLOC_CTX *ctx = talloc_stackframe();
- NTSTATUS status = NT_STATUS_OK;
- struct timespec tp_start;
-
- clock_gettime_mono(&tp_start);
+ 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;
+ }
- data = SMB_MALLOC_ARRAY(char, read_size);
- if (!data) {
- DEBUG(0,("do_atar: out of memory.\n"));
- status = NT_STATUS_NO_MEMORY;
- goto cleanup;
+ start_dir = talloc_strdup(ctx, client_get_cur_dir());
+ if (start_dir == NULL) {
+ err = 1;
+ goto out;
}
- ftype = '0'; /* An ordinary file ... */
+ 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));
- ZERO_STRUCT(finfo);
+ 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;
+ }
+ }
- 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;
+out:
+ talloc_free(ctx);
+ return err;
+}
- 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;
+/**
+ * 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;
}
- rname = clean_name(ctx, rname_in);
- if (!rname) {
+ remote_name = talloc_asprintf(ctx, "%s%s", initial_dir, finfo->name);
+ if (remote_name == NULL) {
status = NT_STATUS_NO_MEMORY;
- goto cleanup;
+ goto out;
+ }
+
+ if (strequal(finfo->name, "..") || strequal(finfo->name, ".")) {
+ goto out;
}
- status = cli_open(cli, rname, O_RDONLY, DENY_NONE, &fnum);
+ status = tar_create_skip_path(&tar_ctx, remote_name, finfo, &skip);
if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0,("%s opening remote file %s (%s)\n",
- nt_errstr(status),rname, client_get_cur_dir()));
- goto cleanup;
+ goto out;
}
- finfo.name = smb_xstrdup(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;
+ if (skip) {
+ DBG(5, ("--- %s\n", remote_name));
+ status = NT_STATUS_OK;
+ goto out;
}
- DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
+ 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;
+ goto out;
+ }
- 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;
+ 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 {
- bool wrote_tar_header = False;
+ rc = tar_get_file(&tar_ctx, remote_name, finfo);
+ if (rc != 0) {
+ status = NT_STATUS_UNSUCCESSFUL;
+ goto out;
+ }
+ }
- DEBUG(3,("getting file %s of size %.0f bytes as a tar file %s",
- finfo.name, (double)finfo.size, lname));
+out:
+ talloc_free(ctx);
+ return status;
+}
- do {
-
- DEBUG(3,("nread=%.0f\n",(double)nread));
-
- status = cli_read(cli, fnum, data, nread,
- read_size, &datalen);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0,("Error reading file %s : %s\n",
- rname, nt_errstr(status)));
- 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 file size has increased since we made file size query, truncate
- read so tar header for this file will be correct.
- */
+/**
+ * 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;
+ }
- if (nread > finfo.size) {
- datalen -= nread - finfo.size;
- DEBUG(0,("File size change - truncating %s to %.0f bytes\n",
- finfo.name, (double)finfo.size));
- }
+ DBG(5, ("+++ %s\n", full_dos_path));
- /* add received bits of file to buffer - dotarbuf will
- * write out in 512 byte intervals */
+ t->total_size += finfo->size;
- if (dotarbuf(tarhandle,data,datalen) != datalen) {
- DEBUG(0,("Error writing to tar file - %s\n", strerror(errno)));
- status = map_nt_error_from_unix(errno);
- break;
- }
+ if (t->mode.dry) {
+ goto out;
+ }
- if ( (datalen == 0) && (finfo.size != 0) ) {
- status = NT_STATUS_UNSUCCESSFUL;
- DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
- break;
- }
+ if (t->mode.reset) {
+ /* ignore return value: server might not store DOS attributes */
+ set_remote_attr(full_dos_path, FILE_ATTRIBUTE_ARCHIVE, ATTR_UNSET);
+ }
- 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)));
- }
- }
+ 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;
+ }
- /* round tar file to nearest block */
- if (finfo.size % TBLOCK)
- dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));
+ archive_entry_set_size(entry, (int64_t)finfo->size);
- ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
- ntarf++;
- } else {
- DEBUG(4, ("skipping %s - initial read failed (file was locked ?)\n", finfo.name));
- shallitime=0;
- status = NT_STATUS_UNSUCCESSFUL;
- }
+ 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;
}
- cli_close(cli, fnum);
- fnum = -1;
+ if (isdir) {
+ DBG(5, ("get_file skip dir %s\n", full_dos_path));
+ goto out_entry;
+ }
- if (shallitime) {
- struct timespec tp_end;
- int this_time;
+ 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;
+ }
- /* if shallitime is true then we didn't skip */
- if (tar_reset && !dry_run)
- (void) do_setrattr(finfo.name, FILE_ATTRIBUTE_ARCHIVE, ATTRRESET);
+ 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;
+ }
- 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;
+ off += len;
- 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));
+ 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;
}
- /* 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))));
- }
+ } while (off < finfo->size);
- cleanup:
+out_close:
+ cli_close(cli, remote_fd);
- if (fnum != (uint16_t)-1) {
- cli_close(cli, fnum);
- fnum = -1;
- }
- TALLOC_FREE(ctx);
- SAFE_FREE(data);
- return status;
-}
+out_entry:
+ archive_entry_free(entry);
-/****************************************************************************
-Append single file to tar file (or not)
-***************************************************************************/
+out:
+ talloc_free(ctx);
+ return err;
+}
-static NTSTATUS do_tar(struct cli_state *cli_state, struct file_info *finfo,
- const char *dir)
+/**
+ * tar_extract - open archive and send files.
+ */
+static int tar_extract(struct tar *t)
{
- TALLOC_CTX *ctx = talloc_stackframe();
- NTSTATUS status = NT_STATUS_OK;
-
- if (strequal(finfo->name,"..") || strequal(finfo->name,"."))
- return NT_STATUS_OK;
+ 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);
+ archive_read_support_filter_all(t->archive);
+
+ 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);
+ }
- /* Is it on the exclude list ? */
- if (!tar_excl && clipn) {
- char *exclaim;
+ if (r != ARCHIVE_OK) {
+ DBG(0, ("Can't open %s : %s\n", t->tar_path,
+ archive_error_string(t->archive)));
+ err = 1;
+ goto out;
+ }
- DEBUG(5, ("Excl: strlen(cur_dir) = %d\n", (int)strlen(client_get_cur_dir())));
+ 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;
+ }
- exclaim = talloc_asprintf(ctx,
- "%s\\%s",
- client_get_cur_dir(),
- finfo->name);
- if (!exclaim) {
- return NT_STATUS_NO_MEMORY;
+ 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;
}
- DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));
+ DBG(5, ("+++ %s\n", archive_entry_pathname(entry)));
- 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);
- return NT_STATUS_OK;
+ rc = tar_send_file(t, entry);
+ if (rc != 0) {
+ err = 1;
+ goto out;
}
- TALLOC_FREE(exclaim);
}
- if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
- char *saved_curdir = NULL;
- char *new_cd = NULL;
- char *mtar_mask = NULL;
+out:
+ r = archive_read_free(t->archive);
+ if (r != ARCHIVE_OK) {
+ DBG(0, ("Can't close %s : %s\n", t->tar_path,
+ archive_error_string(t->archive)));
+ err = 1;
+ }
+ return err;
+}
- saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
- if (!saved_curdir) {
- return NT_STATUS_NO_MEMORY;
- }
+/**
+ * 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;
+ }
- 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));
+ dos_path = talloc_strdup(ctx, archive_entry_pathname(entry));
+ if (dos_path == NULL) {
+ err = 1;
+ goto out;
+ }
+ fix_unix_path(dos_path, true);
- new_cd = talloc_asprintf(ctx,
- "%s%s\\",
- client_get_cur_dir(),
- finfo->name);
- if (!new_cd) {
- return NT_STATUS_NO_MEMORY;
- }
- client_set_cur_dir(new_cd);
+ 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;
+ }
- DEBUG(5, ("Writing a dir, Name = %s\n", client_get_cur_dir()));
+ if (mode != AE_IFREG && mode != AE_IFDIR) {
+ DBG(0, ("Skipping non-dir & non-regular file %s\n", full_path));
+ goto out;
+ }
- /* 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) {
- return NT_STATUS_NO_MEMORY;
- }
- DEBUG(5, ("Doing list with mtar_mask: %s\n", mtar_mask));
- status = 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) {
- return NT_STATUS_NO_MEMORY;
- }
- status = do_atar(rname,finfo->name,finfo);
- TALLOC_FREE(rname);
+ rc = make_remote_path(full_path);
+ if (rc != 0) {
+ err = 1;
+ goto out;
}
- return status;
-}
-/****************************************************************************
-Convert from UNIX to DOS file names
-***************************************************************************/
+ if (mode == AE_IFDIR) {
+ goto out;
+ }
-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!
- */
+ 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;
+ }
- DEBUG(5, ("firstb=%lX, secondb=%lX, len=%i\n", (long)tptr, (long)fp, l));
+ for (;;) {
+ const void *buf;
+ size_t len;
+ off_t off;
+ int r;
- if (first) {
- if (*fp == '.') {
- fp++;
- l--;
+ 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 (*fp == '\\' || *fp == '/') {
- fp++;
- l--;
+ if (r == ARCHIVE_FATAL) {
+ DBG(0, ("Fatal: %s\n", archive_error_string(t->archive)));
+ err = 1;
+ goto close_out;
}
- if (l <= 0) {
- return;
+
+ 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;
}
}
- strlcpy(tptr, fp, l);
- string_replace(tptr, '/', '\\');
-}
+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;
+ }
-/****************************************************************************
-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.
-****************************************************************************/
+out:
+ talloc_free(ctx);
+ return err;
+}
-static int next_block(char *ltarbuf, char **bufferp, int bufsiz)
+/**
+ * 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)
{
- 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, <arbuf[total], bufsiz - total);
- total += bufread;
+ 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;
+ }
- DEBUG(5, ("Total bytes read ... %i\n", total));
-
- *bufferp = ltarbuf;
+ /* 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(total);
+ return NT_STATUS_OK;
}
-/* Skip a file, even if it includes a long file name? */
-static int skip_file(int skipsize)
+/**
+ * tar_set_blocksize - set block size in TAR_BLOCK_UNIT
+ */
+static int tar_set_blocksize(struct tar *t, int size)
{
- int dsize = skipsize;
+ if (size <= 0 || size > TAR_MAX_BLOCK_SIZE) {
+ return 1;
+ }
- DEBUG(5, ("Skiping file. Size = %i\n", skipsize));
+ t->mode.blocksize = size;
- /* FIXME, we should skip more than one block at a time */
+ return 0;
+}
- 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;
+/**
+ * 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;
}
- return(True);
+ 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;
}
-/*************************************************************
- 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)
+/**
+ * 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)
{
- 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;
+ char *line;
+ int err = 0;
+ int fd;
+ TALLOC_CTX *ctx = talloc_new(NULL);
+ if (ctx == NULL) {
+ return 1;
}
- 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;
+ 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;
}
- /* 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);
+ 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)) {
- DEBUG(0, ("Error writing remote file: %s\n",
- nt_errstr(status)));
- return 0;
+ err = 1;
+ goto out;
}
+ }
- 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 */
+ close(fd);
- /* First, skip any initial part of the part written that is left over */
- /* from the end of the first TBLOCK */
+out:
+ talloc_free(ctx);
+ return err;
+}
- if ((bpos) && ((bpos + dsize) >= TBLOCK)) {
- dsize -= (TBLOCK - bpos); /* Get rid of the end of the first block */
- bpos = 0;
+/**
+ * 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 (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;
- }
- }
+ if (path == NULL || path[0] == '\0') {
+ *_is_in_list = false;
+ return NT_STATUS_OK;
+ }
- /*
- * 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().
- */
+ p = skip_useless_char_in_path(path);
- while (((rsize != 0) && (dsize >= TBLOCK)) ||
- ((rsize == 0) && (dsize > TBLOCK))) {
+ for (i = 0; i < t->path_list_size; i++) {
+ bool is_in_list;
+ NTSTATUS status;
- if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
- DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
- return False;
+ 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;
}
-
- dsize -= TBLOCK;
}
- bpos = dsize;
- }
-
- /* Now close the file ... */
- status = cli_close(cli, fnum);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0, ("Error %s closing remote file\n",
- nt_errstr(status)));
- 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 */
+ if (is_in_list) {
+ *_is_in_list = true;
+ return NT_STATUS_OK;
}
}
- 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);
+ *_is_in_list = false;
+ return NT_STATUS_OK;
}
-/* 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)
+/**
+ * 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)
{
- /* 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);
- }
+ const char *fullpath = archive_entry_pathname(entry);
+ bool in = true;
- /* 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());
+ if (t->path_list_size <= 0) {
+ *_skip = false;
+ return NT_STATUS_OK;
}
- /* 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);
+ 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;
}
+ }
- unfixtarname(longname + offset, buffer_p,
- namesize - offset, first--);
- DEBUG(5, ("UnfixedName: %s, buffer: %s\n", longname, buffer_p));
-
- offset += TBLOCK;
- left -= TBLOCK;
+ if (t->mode.selection == TAR_EXCLUDE) {
+ *_skip = in;
+ } else {
+ *_skip = !in;
}
- return(longname);
+ return NT_STATUS_OK;
}
-static void do_tarput(void)
+/**
+ * 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)
{
- file_info2 finfo;
- struct timespec tp_start;
- char *longfilename = NULL, linkflag;
- int skip = False;
-
- ZERO_STRUCT(finfo);
+ /* 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;
- clock_gettime_mono(&tp_start);
- DEBUG(5, ("RJS do_tarput called ...\n"));
+ if (!isdir) {
- 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;
+ /* 1. if we dont want X and we have X, skip */
+ if (!t->mode.system && (mode & FILE_ATTRIBUTE_SYSTEM)) {
+ *_skip = true;
+ return NT_STATUS_OK;
}
- 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;
+ if (!t->mode.hidden && (mode & FILE_ATTRIBUTE_HIDDEN)) {
+ *_skip = true;
+ return NT_STATUS_OK;
+ }
- 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 ... */
+ /* 2. if we only want archive and it's not, skip */
- default:
- /* No action */
- break;
+ if (t->mode.incremental && !(mode & FILE_ATTRIBUTE_ARCHIVE)) {
+ *_skip = true;
+ return NT_STATUS_OK;
}
+ }
- /* 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;
- }
+ /* 3. is it in the selection list? */
- /* 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)));
+ /*
+ * tar_create_from_list() use the include list as a starting
+ * point, no need to check
+ */
+ if (!exclude) {
+ *_skip = false;
+ return NT_STATUS_OK;
+ }
- DEBUG(5, ("Skip = %i, cliplist=%s, file=%s\n", skip, (cliplist?cliplist[0]:NULL), finfo.name));
- if (skip) {
- skip_file(finfo.size);
- continue;
- }
+ /* we are now in exclude mode */
- /* 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;
+ /* no matter the selection, no list => include everything */
+ if (t->path_list_size <= 0) {
+ *_skip = false;
+ return NT_STATUS_OK;
+ }
- default:
- skip_file(finfo.size); /* Don't handle these yet */
- break;
+ 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;
}
-/*
- * samba interactive commands
+/**
+ * tar_to_process - return true if @t is ready to be processed
+ *
+ * @t is ready if it properly parsed command line arguments.
*/
-
-/****************************************************************************
-Blocksize command
-***************************************************************************/
-
-int cmd_block(void)
+bool tar_to_process(struct tar *t)
{
- TALLOC_CTX *ctx = talloc_tos();
- char *buf;
- int block;
-
- if (!next_token_talloc(ctx, (const char **)&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;
+ if (t == NULL) {
+ DBG(0, ("Invalid tar context\n"));
+ return false;
}
-
- blocksize=block;
- DEBUG(2,("blocksize is now %d\n", blocksize));
- return 0;
+ return t->to_process;
}
-/****************************************************************************
-command to set incremental / reset mode
-***************************************************************************/
-
-int cmd_tarmode(void)
+/**
+ * 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)
{
- TALLOC_CTX *ctx = talloc_tos();
- char *buf;
-
- while (next_token_talloc(ctx, (const char **)&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;
+ while (p) {
+ if (*p == '/' || *p == '\\') {
+ p++;
+ }
+ else if (p[0] == '.' && (p[1] == '/' || p[1] == '\\')) {
+ p += 2;
+ }
else
- DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
- TALLOC_FREE(buf);
+ return p;
}
-
- 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;
+ return p;
}
-/****************************************************************************
-Feeble attrib command
-***************************************************************************/
-
-int cmd_setmode(void)
+/**
+ * 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)
{
- TALLOC_CTX *ctx = talloc_tos();
- char *q;
- char *buf;
- char *fname = NULL;
- uint16 attra[2];
- int direct=1;
+ 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 (f == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto out_ctx_free;
+ }
+ string_replace(s, '\\', '/');
- attra[0] = attra[1] = 0;
+ /* find the point where sub and full diverge */
+ while ((*f != '\0') && (*s != '\0') && (*f == *s)) {
+ f++;
+ s++;
+ len++;
+ }
- if (!next_token_talloc(ctx, (const char **)&cmd_ptr,&buf,NULL)) {
- DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
- return 1;
+ if ((*f == '\0') && (*s == '\0')) {
+ *_subpath_match = true; /* sub and full match */
+ goto out_ctx_free;
}
- fname = talloc_asprintf(ctx,
- "%s%s",
- client_get_cur_dir(),
- buf);
- if (!fname) {
- return 1;
+ if ((*f == '\0') && (len > 0) && (*(f - 1) == '/')) {
+ /* sub diverges from full at path separator */
+ *_subpath_match = true;
+ goto out_ctx_free;
}
- while (next_token_talloc(ctx, (const char **)&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 ((*s == '\0') && (strcmp(f, "/") == 0)) {
+ /* full diverges from sub with trailing slash only */
+ *_subpath_match = true;
+ goto out_ctx_free;
}
- if (attra[ATTRSET]==0 && attra[ATTRRESET]==0) {
- DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
- return 1;
+ if ((*s == '/') && (*f == '\0')) {
+ /* sub diverges from full with extra path component */
+ *_subpath_match = true;
+ goto out_ctx_free;
}
+ *_subpath_match = false;
- 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;
+out_ctx_free:
+ talloc_free(tmp_ctx);
+out:
+ return status;
}
/**
- 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)
+ * 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.
+ */
+static int set_remote_attr(const char *filename, uint16 new_attr, int mode)
{
- char *s=(char *)cmd_ptr;
- int ictok=0;
- char **ret, **iret;
-
- if (!sep)
- sep = " \t\n\r";
+ extern struct cli_state *cli;
+ uint16 old_attr;
+ NTSTATUS status;
- while(*s && strchr_m(sep,*s))
- s++;
+ status = cli_getatr(cli, filename, &old_attr, NULL, NULL);
+ if (!NT_STATUS_IS_OK(status)) {
+ DBG(0, ("cli_getatr failed: %s\n", nt_errstr(status)));
+ return 1;
+ }
- /* nothing left? */
- if (!*s)
- return(NULL);
+ if (mode == ATTR_SET) {
+ new_attr |= old_attr;
+ } else {
+ new_attr = old_attr & ~new_attr;
+ }
- 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++;
- }
+ status = cli_setatr(cli, filename, new_attr, 0);
+ if (!NT_STATUS_IS_OK(status)) {
+ DBG(1, ("cli_setatr failed: %s\n", nt_errstr(status)));
+ return 1;
}
- ret[*ctok] = NULL;
- return ret;
+ return 0;
}
-/****************************************************************************
-Principal command for creating / extracting
-***************************************************************************/
-int cmd_tar(void)
+/**
+ * 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)
{
- TALLOC_CTX *ctx = talloc_tos();
- char *buf;
- char **argl = NULL;
- int argcl = 0;
- int ret;
-
- if (!next_token_talloc(ctx, (const char **)&cmd_ptr,&buf,NULL)) {
- DEBUG(0,("tar <c|x>[IXbgan] <filename>\n"));
+ 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;
}
- argl=toktocliplist(&argcl, NULL);
- if (!tar_parseargs(argcl, argl, buf, 0)) {
- SAFE_FREE(argl);
- 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;
- ret = process_tar();
- SAFE_FREE(argl);
- return ret;
-}
+ last_backslash = strrchr_m(path, '\\');
+ if (last_backslash == NULL) {
+ goto out;
+ }
-/****************************************************************************
-Command line (option) version
-***************************************************************************/
+ *last_backslash = 0;
-int process_tar(void)
-{
- TALLOC_CTX *ctx = talloc_tos();
- int rc = 0;
- initarbuf();
- switch(tar_type) {
- case 'x':
+ subpath[0] = 0;
+ p = strtok_r(path, "\\", &state);
-#if 0
- do_tarput2();
-#else
- do_tarput();
-#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);
+ 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));
+ }
- if (ntarf) {
- dotareof(tarhandle);
- }
- close(tarhandle);
- SAFE_FREE(tarbuf);
+ strlcat(subpath, "\\", len);
+ p = strtok_r(NULL, "/\\", &state);
- 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;
+out:
+ talloc_free(ctx);
+ return err;
}
-/****************************************************************************
-Find a token (filename) in a clip list
-***************************************************************************/
-
-static int clipfind(char **aret, int ret, char *tok)
+/**
+ * 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)
{
- 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++;
+ tar_free_mem_context(t);
+ t->talloc_ctx = talloc_new(NULL);
+ return t->talloc_ctx;
+}
- if (!strslashcmp(pkey, tok))
- return 1;
+/**
+ * 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;
}
- return 0;
}
-/****************************************************************************
-Read list of files to include from the file and initialize cliplist
-accordingly.
-***************************************************************************/
+#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))
-static int read_inclusion_file(char *filename)
+/**
+ * tar_dump - dump tar structure on stdout
+ */
+static void tar_dump(struct tar *t)
{
- 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;
+ 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
- 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));
+/**
+ * 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;
}
- 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;
- }
+ s = str;
+ while (s[0] != '\0') {
+ if (isspace((int)s[0])) {
+ nb++;
}
+ s++;
+ }
- if (buf[strlen(buf)-1] == '\n') {
- buf[strlen(buf)-1] = '\0';
- }
+ nb++;
- 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;
- }
- }
+ 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;
- strlcpy(inclusion_buffer + inclusion_buffer_sofar, buf, inclusion_buffer_size - inclusion_buffer_sofar);
- inclusion_buffer_sofar += strlen(buf) + 1;
- clipn++;
+ if (path == NULL || path[0] == '\0') {
+ return path;
}
- 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;
+ /* 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;
}
}
- 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;
+ /* replace / with \ */
+ while (from[0] != '\0') {
+ if (from[0] == '/') {
+ to[0] = '\\';
+ } else {
+ to[0] = from[0];
}
- return 0;
+
+ from++;
+ to++;
}
+ to[0] = '\0';
- /* cliplist and its elements are freed at the end of process_tar. */
- return 1;
+ return path;
}
-/****************************************************************************
-Parse tar arguments. Sets tar_type, tar_excl, etc.
-***************************************************************************/
-
-int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
+/**
+ * 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)
{
- int newOptind = Optind;
- char tar_clipfl='\0';
+ char *base = NULL;
+ int last = -1;
+ int i;
- /* 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;
+ for (i = 0; path[i]; i++) {
+ if (path[i] == '\\' || path[i] == '/') {
+ last = i;
}
}
- 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;
+ if (last >= 0) {
+ base = talloc_strdup(ctx, path);
+ if (base == NULL) {
+ return NT_STATUS_NO_MEMORY;
}
- for (clipcount = 0; clipcount < clipn; clipcount++) {
+ base[last] = 0;
+ }
- DEBUG(5, ("Processing an item, %s\n", cliplist[clipcount]));
+ *_base = base;
+ return NT_STATUS_OK;
+}
- 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;
- }
+#else
- unfixtarname(tmpstr, cliplist[clipcount], strlen(cliplist[clipcount]) + 1, True);
- tmplist[clipcount] = tmpstr;
- DEBUG(5, ("Processed an item, %s\n", tmpstr));
+#define NOT_IMPLEMENTED DEBUG(0, ("tar mode not compiled. build with --with-libarchive\n"))
- DEBUG(5, ("Cliplist is: %s\n", cliplist[0]));
- }
+int cmd_block(void)
+{
+ NOT_IMPLEMENTED;
+ return 1;
+}
- cliplist = tmplist;
- must_free_cliplist = True;
+int cmd_tarmode(void)
+{
+ NOT_IMPLEMENTED;
+ return 1;
+}
- newOptind += clipn;
- }
+int cmd_setmode(void)
+{
+ NOT_IMPLEMENTED;
+ return 1;
+}
- 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;
- }
+int cmd_tar(void)
+{
+ NOT_IMPLEMENTED;
+ return 1;
+}
- 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++;
- }
+int tar_process(struct tar* tar)
+{
+ NOT_IMPLEMENTED;
+ return 1;
+}
- } else {
- if (tar_type=='c' && dry_run) {
- tarhandle=-1;
- } else if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY, 0)) == -1)
- || (tar_type=='c' && (tarhandle=creat(argv[Optind], 0644)) < 0)) {
- DEBUG(0,("Error opening local file %s - %s\n", argv[Optind], strerror(errno)));
- return(0);
- }
- newOptind++;
- }
+int tar_parse_args(struct tar *tar, const char *flag, const char **val, int valsize)
+{
+ NOT_IMPLEMENTED;
+ return 1;
+}
- return newOptind;
+bool tar_to_process(struct tar *tar)
+{
+ return false;
+}
+
+struct tar *tar_get_ctx()
+{
+ return NULL;
}
+
+#endif
git.samba.org / samba.git / blobdiff