Logo Search packages:      
Sourcecode: likewise-open version File versions  Download package

clitar.c

/*
   Unix SMB/CIFS implementation.
   Tar Extensions
   Copyright (C) Ricky Poulten 1995-1998
   Copyright (C) Richard Sharpe 1998

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/* 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
*/


#include "includes.h"
#include "clitar.h"
#include "client/client_proto.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;

#define SEPARATORS " \t\n\r"
extern time_t newer_than;
extern struct cli_state *cli;

/* These defines are for the do_setrattr routine, to indicate
 * setting and reseting of file attributes in the function call */
#define ATTRSET 1
#define ATTRRESET 0

static uint16 attribute = aDIR | aSYSTEM | aHIDDEN;

#ifndef CLIENT_TIMEOUT
#define CLIENT_TIMEOUT (30*1000)
#endif

static char *tarbuf, *buffer_p;
static int tp, ntarf, tbufsiz;
static double ttarf;
/* Incremental mode */
static bool tar_inc=False;
/* Reset archive bit */
static bool tar_reset=False;
/* Include / exclude mode (true=include, false=exclude) */
static bool tar_excl=True;
/* use regular expressions for search on file names */
static bool tar_re_search=False;
/* Do not dump anything, just calculate sizes */
static bool dry_run=False;
/* Dump files with System attribute */
static bool tar_system=True;
/* Dump files with Hidden attribute */
static bool tar_hidden=True;
/* Be noisy - make a catalogue */
static bool tar_noisy=True;
static bool tar_real_noisy=False;  /* Don't want to be really noisy by default */

char tar_type='\0';
static char **cliplist=NULL;
static int clipn=0;
static bool must_free_cliplist = False;
static const char *cmd_ptr = NULL;

extern bool lowercase;
extern uint16 cnum;
extern bool readbraw_supported;
extern int max_xmit;
extern int get_total_time_ms;
extern int get_total_size;

static int blocksize=20;
static int tarhandle;

static void writetarheader(int f,  const char *aname, SMB_BIG_UINT size, time_t mtime,
                     const char *amode, unsigned char ftype);
static void do_atar(const char *rname_in,char *lname,file_info *finfo1);
static void do_tar(file_info *finfo, const char *dir);
static void oct_it(SMB_BIG_UINT value, int ndgs, char *p);
static void fixtarname(char *tptr, const char *fp, size_t l);
static int dotarbuf(int f, char *b, int n);
static void dozerobuf(int f, int n);
static void dotareof(int f);
static void initarbuf(void);

/* restore functions */
static long readtarheader(union hblock *hb, file_info2 *finfo, const char *prefix);
static long unoct(char *p, int ndgs);
static void do_tarput(void);
static void unfixtarname(char *tptr, char *fp, int l, bool first);

/*
 * tar specific utitlities
 */

/*******************************************************************
Create  a string of size size+1 (for the null)
*******************************************************************/

static char *string_create_s(int size)
{
      char *tmp;

      tmp = (char *)SMB_MALLOC(size+1);

      if (tmp == NULL) {
            DEBUG(0, ("Out of memory in string_create_s\n"));
      }

      return(tmp);
}

/****************************************************************************
Write a tar header to buffer
****************************************************************************/

static void writetarheader(int f, const char *aname, SMB_BIG_UINT size, time_t mtime,
                     const char *amode, unsigned char ftype)
{
      union hblock hb;
      int i, chk, l;
      char *jp;

      DEBUG(5, ("WriteTarHdr, Type = %c, Size= %.0f, Name = %s\n", ftype, (double)size, aname));

      memset(hb.dummy, 0, sizeof(hb.dummy));

      l=strlen(aname);
      /* We will be prepending a '.' in fixtarheader so use +2 to
       * take care of the . and terminating zero. JRA.
       */
      if (l+2 >= NAMSIZ) {
            /* write a GNU tar style long header */
            char *b;
            b = (char *)SMB_MALLOC(l+TBLOCK+100);
            if (!b) {
                  DEBUG(0,("out of memory\n"));
                  exit(1);
            }
            writetarheader(f, "/./@LongLink", l+2, 0, "     0 \0", 'L');
            memset(b, 0, l+TBLOCK+100);
            fixtarname(b, aname, l+2);
            i = strlen(b)+1;
            DEBUG(5, ("File name in tar file: %s, size=%d, \n", b, (int)strlen(b)));
            dotarbuf(f, b, TBLOCK*(((i-1)/TBLOCK)+1));
            SAFE_FREE(b);
      }

      fixtarname(hb.dbuf.name, aname, (l+2 >= NAMSIZ) ? NAMSIZ : l + 2);

      if (lowercase)
            strlower_m(hb.dbuf.name);

      /* write out a "standard" tar format header */

      hb.dbuf.name[NAMSIZ-1]='\0';
      safe_strcpy(hb.dbuf.mode, amode, sizeof(hb.dbuf.mode)-1);
      oct_it((SMB_BIG_UINT)0, 8, hb.dbuf.uid);
      oct_it((SMB_BIG_UINT)0, 8, hb.dbuf.gid);
      oct_it((SMB_BIG_UINT) size, 13, hb.dbuf.size);
      if (size > (SMB_BIG_UINT)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, jp=(char*)&size; i; i--)
                  hb.dbuf.size[i+3] = *(jp++);
      }
      oct_it((SMB_BIG_UINT) mtime, 13, hb.dbuf.mtime);
      memcpy(hb.dbuf.chksum, "        ", sizeof(hb.dbuf.chksum));
      memset(hb.dbuf.linkname, 0, NAMSIZ);
      hb.dbuf.linkflag=ftype;

      for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;)
            chk+=(0xFF & *jp++);

      oct_it((SMB_BIG_UINT) chk, 8, hb.dbuf.chksum);
      hb.dbuf.chksum[6] = '\0';

      (void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
}

/****************************************************************************
Read a tar header into a hblock structure, and validate
***************************************************************************/

static long readtarheader(union hblock *hb, file_info2 *finfo, const char *prefix)
{
      long chk, fchk;
      int i;
      char *jp;

      /*
       * read in a "standard" tar format header - we're not that interested
       * in that many fields, though
       */

      /* check the checksum */
      for (chk=0, i=sizeof(hb->dummy), jp=hb->dummy; --i>=0;)
            chk+=(0xFF & *jp++);

      if (chk == 0)
            return chk;

      /* compensate for blanks in chksum header */
      for (i=sizeof(hb->dbuf.chksum), jp=hb->dbuf.chksum; --i>=0;)
            chk-=(0xFF & *jp++);

      chk += ' ' * sizeof(hb->dbuf.chksum);

      fchk=unoct(hb->dbuf.chksum, sizeof(hb->dbuf.chksum));

      DEBUG(5, ("checksum totals chk=%ld fchk=%ld chksum=%s\n",
                  chk, fchk, hb->dbuf.chksum));

      if (fchk != chk) {
            DEBUG(0, ("checksums don't match %ld %ld\n", fchk, chk));
            dump_data(5, (uint8 *)hb - TBLOCK, TBLOCK *3);
            return -1;
      }

      if ((finfo->name = string_create_s(strlen(prefix) + strlen(hb -> dbuf.name) + 3)) == NULL) {
            DEBUG(0, ("Out of space creating file_info2 for %s\n", hb -> dbuf.name));
            return(-1);
      }

      safe_strcpy(finfo->name, prefix, strlen(prefix) + strlen(hb -> dbuf.name) + 3);

      /* use l + 1 to do the null too; do prefix - prefcnt to zap leading slash */
      unfixtarname(finfo->name + strlen(prefix), hb->dbuf.name,
            strlen(hb->dbuf.name) + 1, True);

      /* can't handle some links at present */
      if ((hb->dbuf.linkflag != '0') && (hb -> dbuf.linkflag != '5')) {
            if (hb->dbuf.linkflag == 0) {
                  DEBUG(6, ("Warning: NULL link flag (gnu tar archive ?) %s\n",
                        finfo->name));
            } else {
                  if (hb -> dbuf.linkflag == 'L') { /* We have a longlink */
                        /* Do nothing here at the moment. do_tarput will handle this
                              as long as the longlink gets back to it, as it has to advance 
                              the buffer pointer, etc */
                  } else {
                        DEBUG(0, ("this tar file appears to contain some kind \
of link other than a GNUtar Longlink - ignoring\n"));
                        return -2;
                  }
            }
      }

      if ((unoct(hb->dbuf.mode, sizeof(hb->dbuf.mode)) & S_IFDIR) ||
                        (*(finfo->name+strlen(finfo->name)-1) == '\\')) {
            finfo->mode=aDIR;
      } else {
            finfo->mode=0; /* we don't care about mode at the moment, we'll
                        * just make it a regular file */
      }

      /*
       * Bug fix by richard@sj.co.uk
       *
       * REC: restore times correctly (as does tar)
       * We only get the modification time of the file; set the creation time
       * from the mod. time, and the access time to current time
       */
      finfo->mtime_ts = finfo->ctime_ts =
            convert_time_t_to_timespec((time_t)strtol(hb->dbuf.mtime, NULL, 8));
      finfo->atime_ts = convert_time_t_to_timespec(time(NULL));
      finfo->size = unoct(hb->dbuf.size, sizeof(hb->dbuf.size));

      return True;
}

/****************************************************************************
Write out the tar buffer to tape or wherever
****************************************************************************/

static int dotarbuf(int f, char *b, int n)
{
      int fail=1, writ=n;

      if (dry_run) {
            return writ;
      }
      /* This routine and the next one should be the only ones that do write()s */
      if (tp + n >= tbufsiz) {
            int diff;

            diff=tbufsiz-tp;
            memcpy(tarbuf + tp, b, diff);
            fail=fail && (1+write(f, tarbuf, tbufsiz));
            n-=diff;
            b+=diff;
            tp=0;

            while (n >= tbufsiz) {
                  fail=fail && (1 + write(f, b, tbufsiz));
                  n-=tbufsiz;
                  b+=tbufsiz;
            }
      }

      if (n>0) {
            memcpy(tarbuf+tp, b, n);
            tp+=n;
      }

      return(fail ? writ : 0);
}

/****************************************************************************
Write zeros to buffer / tape
****************************************************************************/

static void dozerobuf(int f, int n)
{
      /* short routine just to write out n zeros to buffer -
       * used to round files to nearest block
       * and to do tar EOFs */

      if (dry_run)
            return;

      if (n+tp >= tbufsiz) {
            memset(tarbuf+tp, 0, tbufsiz-tp);
            write(f, tarbuf, tbufsiz);
            memset(tarbuf, 0, (tp+=n-tbufsiz));
      } else {
            memset(tarbuf+tp, 0, n);
            tp+=n;
      }
}

/****************************************************************************
Malloc tape buffer
****************************************************************************/

static void initarbuf(void)
{
      /* initialize tar buffer */
      tbufsiz=blocksize*TBLOCK;
      tarbuf=(char *)SMB_MALLOC(tbufsiz);      /* FIXME: We might not get the buffer */

      /* reset tar buffer pointer and tar file counter and total dumped */
      tp=0; ntarf=0; ttarf=0;
}

/****************************************************************************
Write two zero blocks at end of file
****************************************************************************/

static void dotareof(int f)
{
      SMB_STRUCT_STAT stbuf;
      /* Two zero blocks at end of file, write out full buffer */

      if (dry_run)
            return;

      (void) dozerobuf(f, TBLOCK);
      (void) dozerobuf(f, TBLOCK);

      if (sys_fstat(f, &stbuf) == -1) {
            DEBUG(0, ("Couldn't stat file handle\n"));
            return;
      }

      /* Could be a pipe, in which case S_ISREG should fail,
            * and we should write out at full size */
      if (tp > 0)
            write(f, tarbuf, S_ISREG(stbuf.st_mode) ? tp : tbufsiz);
}

/****************************************************************************
(Un)mangle DOS pathname, make nonabsolute
****************************************************************************/

static void fixtarname(char *tptr, const char *fp, size_t l)
{
      /* add a '.' to start of file name, convert from ugly dos \'s in path
       * to lovely unix /'s :-} */
      *tptr++='.';
      l--;

      StrnCpy(tptr, fp, l-1);
      string_replace(tptr, '\\', '/');
}

/****************************************************************************
Convert from decimal to octal string
****************************************************************************/

static void oct_it (SMB_BIG_UINT value, int ndgs, char *p)
{
      /* Converts long to octal string, pads with leading zeros */

      /* skip final null, but do final space */
      --ndgs;
      p[--ndgs] = ' ';

      /* Loop does at least one digit */
      do {
            p[--ndgs] = '0' + (char) (value & 7);
            value >>= 3;
      } while (ndgs > 0 && value != 0);

      /* Do leading zeros */
      while (ndgs > 0)
            p[--ndgs] = '0';
}

/****************************************************************************
Convert from octal string to long
***************************************************************************/

static long unoct(char *p, int ndgs)
{
      long value=0;
      /* Converts octal string to long, ignoring any non-digit */

      while (--ndgs) {
            if (isdigit((int)*p))
                  value = (value << 3) | (long) (*p - '0');

            p++;
      }

      return value;
}

/****************************************************************************
Compare two strings in a slash insensitive way, allowing s1 to match s2
if s1 is an "initial" string (up to directory marker).  Thus, if s2 is
a file in any subdirectory of s1, declare a match.
***************************************************************************/

static int strslashcmp(char *s1, char *s2)
{
      char *s1_0=s1;

      while(*s1 && *s2 && (*s1 == *s2 || tolower_ascii(*s1) == tolower_ascii(*s2) ||
                        (*s1 == '\\' && *s2=='/') || (*s1 == '/' && *s2=='\\'))) {
            s1++; s2++;
      }

      /* if s1 has a trailing slash, it compared equal, so s1 is an "initial" 
            string of s2.
      */
      if (!*s1 && s1 != s1_0 && (*(s1-1) == '/' || *(s1-1) == '\\'))
            return 0;

      /* ignore trailing slash on s1 */
      if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1))
            return 0;

      /* check for s1 is an "initial" string of s2 */
      if ((*s2 == '/' || *s2 == '\\') && !*s1)
            return 0;

      return *s1-*s2;
}

/****************************************************************************
Ensure a remote path exists (make if necessary)
***************************************************************************/

static bool ensurepath(const char *fname)
{
      /* *must* be called with buffer ready malloc'ed */
      /* ensures path exists */

      char *partpath, *ffname;
      const char *p=fname;
      char *basehack;
      char *saveptr;

      DEBUG(5, ( "Ensurepath called with: %s\n", fname));

      partpath = string_create_s(strlen(fname));
      ffname = string_create_s(strlen(fname));

      if ((partpath == NULL) || (ffname == NULL)){
            DEBUG(0, ("Out of memory in ensurepath: %s\n", fname));
            SAFE_FREE(partpath);
            SAFE_FREE(ffname);
            return(False);
      }

      *partpath = 0;

      /* fname copied to ffname so can strtok_r */

      safe_strcpy(ffname, fname, strlen(fname));

      /* do a `basename' on ffname, so don't try and make file name directory */
      if ((basehack=strrchr_m(ffname, '\\')) == NULL) {
            SAFE_FREE(partpath);
            SAFE_FREE(ffname);
            return True;
      } else {
            *basehack='\0';
      }

      p=strtok_r(ffname, "\\", &saveptr);

      while (p) {
            safe_strcat(partpath, p, strlen(fname) + 1);

            if (!cli_chkpath(cli, partpath)) {
                  if (!cli_mkdir(cli, partpath)) {
                        SAFE_FREE(partpath);
                        SAFE_FREE(ffname);
                        DEBUG(0, ("Error mkdir %s\n", cli_errstr(cli)));
                        return False;
                  } else {
                        DEBUG(3, ("mkdirhiering %s\n", partpath));
                  }
            }

            safe_strcat(partpath, "\\", strlen(fname) + 1);
            p = strtok_r(NULL, "/\\", &saveptr);
      }

      SAFE_FREE(partpath);
      SAFE_FREE(ffname);
      return True;
}

static int padit(char *buf, SMB_BIG_UINT bufsize, SMB_BIG_UINT padsize)
{
      int berr= 0;
      int bytestowrite;

      DEBUG(5, ("Padding with %0.f zeros\n", (double)padsize));
      memset(buf, 0, (size_t)bufsize);
      while( !berr && padsize > 0 ) {
            bytestowrite= (int)MIN(bufsize, padsize);
            berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite;
            padsize -= bytestowrite;
      }

      return berr;
}

static void do_setrattr(char *name, uint16 attr, int set)
{
      uint16 oldattr;

      if (!cli_getatr(cli, name, &oldattr, NULL, NULL)) return;

      if (set == ATTRSET) {
            attr |= oldattr;
      } else {
            attr = oldattr & ~attr;
      }

      if (!cli_setatr(cli, name, attr, 0)) {
            DEBUG(1,("setatr failed: %s\n", cli_errstr(cli)));
      }
}

/****************************************************************************
append one remote file to the tar file
***************************************************************************/

static void do_atar(const char *rname_in,char *lname,file_info *finfo1)
{
      int fnum = -1;
      SMB_BIG_UINT nread=0;
      char ftype;
      file_info2 finfo;
      bool shallitime=True;
      char *data = NULL;
      int read_size = 65520;
      int datalen=0;
      char *rname = NULL;
      TALLOC_CTX *ctx = talloc_stackframe();

      struct timeval tp_start;

      GetTimeOfDay(&tp_start);

      data = SMB_MALLOC_ARRAY(char, read_size);
      if (!data) {
            DEBUG(0,("do_atar: out of memory.\n"));
            goto cleanup;
      }

      ftype = '0'; /* An ordinary file ... */

      ZERO_STRUCT(finfo);

      finfo.size  = finfo1 -> size;
      finfo.mode  = finfo1 -> mode;
      finfo.uid   = finfo1 -> uid;
      finfo.gid   = finfo1 -> gid;
      finfo.mtime_ts = finfo1 -> mtime_ts;
      finfo.atime_ts = finfo1 -> atime_ts;
      finfo.ctime_ts = finfo1 -> ctime_ts;

      if (dry_run) {
            DEBUG(3,("skipping file %s of size %12.0f bytes\n", finfo1->name,
                        (double)finfo.size));
            shallitime=0;
            ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
            ntarf++;
            goto cleanup;
      }

      rname = clean_name(ctx, rname_in);
      if (!rname) {
            goto cleanup;
      }

      fnum = cli_open(cli, rname, O_RDONLY, DENY_NONE);

      if (fnum == -1) {
            DEBUG(0,("%s opening remote file %s (%s)\n",
                        cli_errstr(cli),rname, client_get_cur_dir()));
            goto cleanup;
      }

      finfo.name = string_create_s(strlen(rname));
      if (finfo.name == NULL) {
            DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n"));
            goto cleanup;
      }

      safe_strcpy(finfo.name,rname, strlen(rname));
      if (!finfo1) {
            time_t atime, mtime;
            if (!cli_getattrE(cli, fnum, &finfo.mode, &finfo.size, NULL, &atime, &mtime)) {
                  DEBUG(0, ("getattrE: %s\n", cli_errstr(cli)));
                  goto cleanup;
            }
            finfo.atime_ts = convert_time_t_to_timespec(atime);
            finfo.mtime_ts = convert_time_t_to_timespec(mtime);
            finfo.ctime_ts = finfo.mtime_ts;
      }

      DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));

      if (tar_inc && !(finfo.mode & aARCH)) {
            DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name));
            shallitime=0;
      } else if (!tar_system && (finfo.mode & aSYSTEM)) {
            DEBUG(4, ("skipping %s - system bit is set\n", finfo.name));
            shallitime=0;
      } else if (!tar_hidden && (finfo.mode & aHIDDEN)) {
            DEBUG(4, ("skipping %s - hidden bit is set\n", finfo.name));
            shallitime=0;
      } else {
            bool wrote_tar_header = False;

            DEBUG(3,("getting file %s of size %.0f bytes as a tar file %s",
                  finfo.name, (double)finfo.size, lname));

            do {

                  DEBUG(3,("nread=%.0f\n",(double)nread));

                  datalen = cli_read(cli, fnum, data, nread, read_size);

                  if (datalen == -1) {
                        DEBUG(0,("Error reading file %s : %s\n", rname, cli_errstr(cli)));
                        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.
                  */

                  if (nread > finfo.size) {
                        datalen -= nread - finfo.size;
                        DEBUG(0,("File size change - truncating %s to %.0f bytes\n",
                                          finfo.name, (double)finfo.size));
                  }

                  /* add received bits of file to buffer - dotarbuf will
                  * write out in 512 byte intervals */

                  if (dotarbuf(tarhandle,data,datalen) != datalen) {
                        DEBUG(0,("Error writing to tar file - %s\n", strerror(errno)));
                        break;
                  }

                  if ( (datalen == 0) && (finfo.size != 0) ) {
                        DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
                        break;
                  }

                  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, (SMB_BIG_UINT)sizeof(data), finfo.size - nread))
                              DEBUG(0,("Error writing tar file - %s\n", strerror(errno)));
                  }

                  /* round tar file to nearest block */
                  if (finfo.size % TBLOCK)
                        dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));

                  ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
                  ntarf++;
            } else {
                  DEBUG(4, ("skipping %s - initial read failed (file was locked ?)\n", finfo.name));
                  shallitime=0;
            }
      }

      cli_close(cli, fnum);
      fnum = -1;

      if (shallitime) {
            struct timeval tp_end;
            int this_time;

            /* if shallitime is true then we didn't skip */
            if (tar_reset && !dry_run)
                  (void) do_setrattr(finfo.name, aARCH, ATTRRESET);

            GetTimeOfDay(&tp_end);
            this_time = (tp_end.tv_sec - tp_start.tv_sec)*1000 + (tp_end.tv_usec - tp_start.tv_usec)/1000;
            get_total_time_ms += this_time;
            get_total_size += finfo.size;

            if (tar_noisy) {
                  DEBUG(0, ("%12.0f (%7.1f kb/s) %s\n",
                        (double)finfo.size, finfo.size / MAX(0.001, (1.024*this_time)),
                        finfo.name));
            }

            /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
            DEBUG(3,("(%g kb/s) (average %g kb/s)\n",
                        finfo.size / MAX(0.001, (1.024*this_time)),
                        get_total_size / MAX(0.001, (1.024*get_total_time_ms))));
      }

  cleanup:

      if (fnum != -1) {
            cli_close(cli, fnum);
            fnum = -1;
      }
      TALLOC_FREE(ctx);
      SAFE_FREE(data);
}

/****************************************************************************
Append single file to tar file (or not)
***************************************************************************/

static void do_tar(file_info *finfo, const char *dir)
{
      TALLOC_CTX *ctx = talloc_stackframe();

      if (strequal(finfo->name,"..") || strequal(finfo->name,"."))
            return;

      /* Is it on the exclude list ? */
      if (!tar_excl && clipn) {
            char *exclaim;

            DEBUG(5, ("Excl: strlen(cur_dir) = %d\n", (int)strlen(client_get_cur_dir())));

            exclaim = talloc_asprintf(ctx,
                        "%s\\%s",
                        client_get_cur_dir(),
                        finfo->name);
            if (!exclaim) {
                  return;
            }

            DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));

            if ((!tar_re_search && clipfind(cliplist, clipn, exclaim)) ||
                        (tar_re_search && mask_match_list(exclaim, cliplist, clipn, True))) {
                  DEBUG(3,("Skipping file %s\n", exclaim));
                  TALLOC_FREE(exclaim);
                  return;
            }
            TALLOC_FREE(exclaim);
      }

      if (finfo->mode & aDIR) {
            char *saved_curdir = NULL;
            char *new_cd = NULL;
            char *mtar_mask = NULL;

            saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
            if (!saved_curdir) {
                  return;
            }

            DEBUG(5, ("strlen(cur_dir)=%d, \
strlen(finfo->name)=%d\nname=%s,cur_dir=%s\n",
                  (int)strlen(saved_curdir),
                  (int)strlen(finfo->name), finfo->name, saved_curdir));

            new_cd = talloc_asprintf(ctx,
                        "%s%s\\",
                        client_get_cur_dir(),
                        finfo->name);
            if (!new_cd) {
                  return;
            }
            client_set_cur_dir(new_cd);

            DEBUG(5, ("Writing a dir, Name = %s\n", client_get_cur_dir()));

            /* write a tar directory, don't bother with mode - just
             * set it to 40755 */
            writetarheader(tarhandle, client_get_cur_dir(), 0,
                        finfo->mtime_ts.tv_sec, "040755 \0", '5');
            if (tar_noisy) {
                  DEBUG(0,("                directory %s\n",
                        client_get_cur_dir()));
            }
            ntarf++;  /* Make sure we have a file on there */
            mtar_mask = talloc_asprintf(ctx,
                        "%s*",
                        client_get_cur_dir());
            if (!mtar_mask) {
                  return;
            }
            DEBUG(5, ("Doing list with mtar_mask: %s\n", mtar_mask));
            do_list(mtar_mask, attribute, do_tar, False, True);
            client_set_cur_dir(saved_curdir);
            TALLOC_FREE(saved_curdir);
            TALLOC_FREE(new_cd);
            TALLOC_FREE(mtar_mask);
      } else {
            char *rname = talloc_asprintf(ctx,
                              "%s%s",
                              client_get_cur_dir(),
                              finfo->name);
            if (!rname) {
                  return;
            }
            do_atar(rname,finfo->name,finfo);
            TALLOC_FREE(rname);
      }
}

/****************************************************************************
Convert from UNIX to DOS file names
***************************************************************************/

static void unfixtarname(char *tptr, char *fp, int l, bool first)
{
      /* remove '.' from start of file name, convert from unix /'s to
       * dos \'s in path. Kill any absolute path names. But only if first!
       */

      DEBUG(5, ("firstb=%lX, secondb=%lX, len=%i\n", (long)tptr, (long)fp, l));

      if (first) {
            if (*fp == '.') {
                  fp++;
                  l--;
            }
            if (*fp == '\\' || *fp == '/') {
                  fp++;
                  l--;
            }
      }

      safe_strcpy(tptr, fp, l);
      string_replace(tptr, '/', '\\');
}

/****************************************************************************
Move to the next block in the buffer, which may mean read in another set of
blocks. FIXME, we should allow more than one block to be skipped.
****************************************************************************/

static int next_block(char *ltarbuf, char **bufferp, int bufsiz)
{
      int bufread, total = 0;

      DEBUG(5, ("Advancing to next block: %0lx\n", (unsigned long)*bufferp));
      *bufferp += TBLOCK;
      total = TBLOCK;

      if (*bufferp >= (ltarbuf + bufsiz)) {

            DEBUG(5, ("Reading more data into ltarbuf ...\n"));

            /*
             * Bugfix from Bob Boehmer <boehmer@worldnet.att.net>
             * Fixes bug where read can return short if coming from
             * a pipe.
             */

            bufread = read(tarhandle, ltarbuf, bufsiz);
            total = bufread;

            while (total < bufsiz) {
                  if (bufread < 0) { /* An error, return false */
                        return (total > 0 ? -2 : bufread);
                  }
                  if (bufread == 0) {
                        if (total <= 0) {
                              return -2;
                        }
                        break;
                  }
                  bufread = read(tarhandle, &ltarbuf[total], bufsiz - total);
                  total += bufread;
            }

            DEBUG(5, ("Total bytes read ... %i\n", total));

            *bufferp = ltarbuf;
      }

      return(total);
}

/* Skip a file, even if it includes a long file name? */
static int skip_file(int skipsize)
{
      int dsize = skipsize;

      DEBUG(5, ("Skiping file. Size = %i\n", skipsize));

      /* FIXME, we should skip more than one block at a time */

      while (dsize > 0) {
            if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
                  DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
                  return(False);
            }
            dsize -= TBLOCK;
      }

      return(True);
}

/*************************************************************
 Get a file from the tar file and store it.
 When this is called, tarbuf already contains the first
 file block. This is a bit broken & needs fixing.
**************************************************************/

static int get_file(file_info2 finfo)
{
      int fnum = -1, pos = 0, dsize = 0, bpos = 0;
      SMB_BIG_UINT rsize = 0;

      DEBUG(5, ("get_file: file: %s, size %.0f\n", finfo.name, (double)finfo.size));

      if (ensurepath(finfo.name) &&
                  (fnum=cli_open(cli, finfo.name, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) == -1) {
            DEBUG(0, ("abandoning restore\n"));
            return(False);
      }

      /* read the blocks from the tar file and write to the remote file */

      rsize = finfo.size;  /* This is how much to write */

      while (rsize > 0) {

            /* We can only write up to the end of the buffer */
            dsize = MIN(tbufsiz - (buffer_p - tarbuf) - bpos, 65520); /* Calculate the size to write */
            dsize = MIN(dsize, rsize);  /* Should be only what is left */
            DEBUG(5, ("writing %i bytes, bpos = %i ...\n", dsize, bpos));

            if (cli_write(cli, fnum, 0, buffer_p + bpos, pos, dsize) != dsize) {
                  DEBUG(0, ("Error writing remote file\n"));
                  return 0;
            }

            rsize -= dsize;
            pos += dsize;

            /* Now figure out how much to move in the buffer */

            /* FIXME, we should skip more than one block at a time */

            /* First, skip any initial part of the part written that is left over */
            /* from the end of the first TBLOCK                                   */

            if ((bpos) && ((bpos + dsize) >= TBLOCK)) {
                  dsize -= (TBLOCK - bpos);  /* Get rid of the end of the first block */
                  bpos = 0;

                  if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {  /* and skip the block */
                        DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
                        return False;
                  }
            }

            /*
             * Bugfix from Bob Boehmer <boehmer@worldnet.att.net>.
             * If the file being extracted is an exact multiple of
             * TBLOCK bytes then we don't want to extract the next
             * block from the tarfile here, as it will be done in
             * the caller of get_file().
             */

            while (((rsize != 0) && (dsize >= TBLOCK)) ||
                        ((rsize == 0) && (dsize > TBLOCK))) {

                  if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
                        DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
                        return False;
                  }

                  dsize -= TBLOCK;
            }
            bpos = dsize;
      }

      /* Now close the file ... */

      if (!cli_close(cli, fnum)) {
            DEBUG(0, ("Error closing remote file\n"));
            return(False);
      }

      /* Now we update the creation date ... */
      DEBUG(5, ("Updating creation date on %s\n", finfo.name));

      if (!cli_setatr(cli, finfo.name, finfo.mode, finfo.mtime_ts.tv_sec)) {
            if (tar_real_noisy) {
                  DEBUG(0, ("Could not set time on file: %s\n", finfo.name));
                  /*return(False); */ /* Ignore, as Win95 does not allow changes */
            }
      }

      ntarf++;
      DEBUG(0, ("restore tar file %s of size %.0f bytes\n", finfo.name, (double)finfo.size));
      return(True);
}

/* Create a directory.  We just ensure that the path exists and return as there
   is no file associated with a directory
*/
static int get_dir(file_info2 finfo)
{
      DEBUG(0, ("restore directory %s\n", finfo.name));

      if (!ensurepath(finfo.name)) {
            DEBUG(0, ("Problems creating directory\n"));
            return(False);
      }
      ntarf++;
      return(True);
}

/* Get a file with a long file name ... first file has file name, next file 
   has the data. We only want the long file name, as the loop in do_tarput
   will deal with the rest.
*/
static char *get_longfilename(file_info2 finfo)
{
      /* finfo.size here is the length of the filename as written by the "/./@LongLink" name
       * header call. */
      int namesize = finfo.size + strlen(client_get_cur_dir()) + 2;
      char *longname = (char *)SMB_MALLOC(namesize);
      int offset = 0, left = finfo.size;
      bool first = True;

      DEBUG(5, ("Restoring a long file name: %s\n", finfo.name));
      DEBUG(5, ("Len = %.0f\n", (double)finfo.size));

      if (longname == NULL) {
            DEBUG(0, ("could not allocate buffer of size %d for longname\n", namesize));
            return(NULL);
      }

      /* First, add cur_dir to the long file name */

      if (strlen(client_get_cur_dir()) > 0) {
            strncpy(longname, client_get_cur_dir(), namesize);
            offset = strlen(client_get_cur_dir());
      }

      /* Loop through the blocks picking up the name */

      while (left > 0) {
            if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
                  DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
                  SAFE_FREE(longname);
                  return(NULL);
            }

            unfixtarname(longname + offset, buffer_p, MIN(TBLOCK, finfo.size), first--);
            DEBUG(5, ("UnfixedName: %s, buffer: %s\n", longname, buffer_p));

            offset += TBLOCK;
            left -= TBLOCK;
      }

      return(longname);
}

static void do_tarput(void)
{
      file_info2 finfo;
      struct timeval tp_start;
      char *longfilename = NULL, linkflag;
      int skip = False;

      ZERO_STRUCT(finfo);

      GetTimeOfDay(&tp_start);
      DEBUG(5, ("RJS do_tarput called ...\n"));

      buffer_p = tarbuf + tbufsiz;  /* init this to force first read */

      /* Now read through those files ... */
      while (True) {
            /* Get us to the next block, or the first block first time around */
            if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
                  DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
                  SAFE_FREE(longfilename);
                  return;
            }

            DEBUG(5, ("Reading the next header ...\n"));

            switch (readtarheader((union hblock *) buffer_p,
                              &finfo, client_get_cur_dir())) {
                  case -2:    /* Hmm, not good, but not fatal */
                        DEBUG(0, ("Skipping %s...\n", finfo.name));
                        if ((next_block(tarbuf, &buffer_p, tbufsiz) <= 0) && !skip_file(finfo.size)) {
                              DEBUG(0, ("Short file, bailing out...\n"));
                              return;
                        }
                        break;

                  case -1:
                        DEBUG(0, ("abandoning restore, -1 from read tar header\n"));
                        return;

                  case 0: /* chksum is zero - looks like an EOF */
                        DEBUG(0, ("tar: restored %d files and directories\n", ntarf));
                        return;        /* Hmmm, bad here ... */

                  default: 
                        /* No action */
                        break;
            }

            /* Now, do we have a long file name? */
            if (longfilename != NULL) {
                  SAFE_FREE(finfo.name);   /* Free the space already allocated */
                  finfo.name = longfilename;
                  longfilename = NULL;
            }

            /* Well, now we have a header, process the file ...            */
            /* Should we skip the file? We have the long name as well here */
            skip = clipn && ((!tar_re_search && clipfind(cliplist, clipn, finfo.name) ^ tar_excl) ||
                              (tar_re_search && mask_match_list(finfo.name, cliplist, clipn, True)));

            DEBUG(5, ("Skip = %i, cliplist=%s, file=%s\n", skip, (cliplist?cliplist[0]:NULL), finfo.name));
            if (skip) {
                  skip_file(finfo.size);
                  continue;
            }

            /* We only get this far if we should process the file */
            linkflag = ((union hblock *)buffer_p) -> dbuf.linkflag;
            switch (linkflag) {
                  case '0':  /* Should use symbolic names--FIXME */
                        /*
                         * Skip to the next block first, so we can get the file, FIXME, should
                         * be in get_file ...
                         * The 'finfo.size != 0' fix is from Bob Boehmer <boehmer@worldnet.att.net>
                         * Fixes bug where file size in tarfile is zero.
                         */
                        if ((finfo.size != 0) && next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
                              DEBUG(0, ("Short file, bailing out...\n"));
                              return;
                        }
                        if (!get_file(finfo)) {
                              DEBUG(0, ("Abandoning restore\n"));
                              return;
                        }
                        break;
                  case '5':
                        if (!get_dir(finfo)) {
                              DEBUG(0, ("Abandoning restore \n"));
                              return;
                        }
                        break;
                  case 'L':
                        SAFE_FREE(longfilename);
                        longfilename = get_longfilename(finfo);
                        if (!longfilename) {
                              DEBUG(0, ("abandoning restore\n"));
                              return;
                        }
                        DEBUG(5, ("Long file name: %s\n", longfilename));
                        break;

                  default:
                        skip_file(finfo.size);  /* Don't handle these yet */
                        break;
            }
      }
}

/*
 * samba interactive commands
 */

/****************************************************************************
Blocksize command
***************************************************************************/

int cmd_block(void)
{
      TALLOC_CTX *ctx = talloc_tos();
      char *buf;
      int block;

      if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
            DEBUG(0, ("blocksize <n>\n"));
            return 1;
      }

      block=atoi(buf);
      if (block < 0 || block > 65535) {
            DEBUG(0, ("blocksize out of range"));
            return 1;
      }

      blocksize=block;
      DEBUG(2,("blocksize is now %d\n", blocksize));
      return 0;
}

/****************************************************************************
command to set incremental / reset mode
***************************************************************************/

int cmd_tarmode(void)
{
      TALLOC_CTX *ctx = talloc_tos();
      char *buf;

      while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
            if (strequal(buf, "full"))
                  tar_inc=False;
            else if (strequal(buf, "inc"))
                  tar_inc=True;
            else if (strequal(buf, "reset"))
                  tar_reset=True;
            else if (strequal(buf, "noreset"))
                  tar_reset=False;
            else if (strequal(buf, "system"))
                  tar_system=True;
            else if (strequal(buf, "nosystem"))
                  tar_system=False;
            else if (strequal(buf, "hidden"))
                  tar_hidden=True;
            else if (strequal(buf, "nohidden"))
                  tar_hidden=False;
            else if (strequal(buf, "verbose") || strequal(buf, "noquiet"))
                  tar_noisy=True;
            else if (strequal(buf, "quiet") || strequal(buf, "noverbose"))
                  tar_noisy=False;
            else
                  DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
            TALLOC_FREE(buf);
      }

      DEBUG(0, ("tarmode is now %s, %s, %s, %s, %s\n",
                  tar_inc ? "incremental" : "full",
                  tar_system ? "system" : "nosystem",
                  tar_hidden ? "hidden" : "nohidden",
                  tar_reset ? "reset" : "noreset",
                  tar_noisy ? "verbose" : "quiet"));
      return 0;
}

/****************************************************************************
Feeble attrib command
***************************************************************************/

int cmd_setmode(void)
{
      TALLOC_CTX *ctx = talloc_tos();
      char *q;
      char *buf;
      char *fname = NULL;
      uint16 attra[2];
      int direct=1;

      attra[0] = attra[1] = 0;

      if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
            DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
            return 1;
      }

      fname = talloc_asprintf(ctx,
                        "%s%s",
                        client_get_cur_dir(),
                        buf);
      if (!fname) {
            return 1;
      }

      while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
            q=buf;

            while(*q) {
                  switch (*q++) {
                        case '+':
                              direct=1;
                              break;
                        case '-':
                              direct=0;
                              break;
                        case 'r':
                              attra[direct]|=aRONLY;
                              break;
                        case 'h':
                              attra[direct]|=aHIDDEN;
                              break;
                        case 's':
                              attra[direct]|=aSYSTEM;
                              break;
                        case 'a':
                              attra[direct]|=aARCH;
                              break;
                        default:
                              DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
                              return 1;
                  }
            }
      }

      if (attra[ATTRSET]==0 && attra[ATTRRESET]==0) {
            DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
            return 1;
      }

      DEBUG(2, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
      do_setrattr(fname, attra[ATTRSET], ATTRSET);
      do_setrattr(fname, attra[ATTRRESET], ATTRRESET);
      return 0;
}

/**
 Convert list of tokens to array; dependent on above routine.
 Uses the global cmd_ptr from above - bit of a hack.
**/

static char **toktocliplist(int *ctok, const char *sep)
{
      char *s=(char *)cmd_ptr;
      int ictok=0;
      char **ret, **iret;

      if (!sep)
            sep = " \t\n\r";

      while(*s && strchr_m(sep,*s))
            s++;

      /* nothing left? */
      if (!*s)
            return(NULL);

      do {
            ictok++;
            while(*s && (!strchr_m(sep,*s)))
                  s++;
            while(*s && strchr_m(sep,*s))
                  *s++=0;
      } while(*s);

      *ctok=ictok;
      s=(char *)cmd_ptr;

      if (!(ret=iret=SMB_MALLOC_ARRAY(char *,ictok+1)))
            return NULL;

      while(ictok--) {
            *iret++=s;
            if (ictok > 0) {
                  while(*s++)
                        ;
                  while(!*s)
                        s++;
            }
      }

      ret[*ctok] = NULL;
      return ret;
}

/****************************************************************************
Principal command for creating / extracting
***************************************************************************/

int cmd_tar(void)
{
      TALLOC_CTX *ctx = talloc_tos();
      char *buf;
      char **argl = NULL;
      int argcl = 0;
      int ret;

      if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
            DEBUG(0,("tar <c|x>[IXbgan] <filename>\n"));
            return 1;
      }

      argl=toktocliplist(&argcl, NULL);
      if (!tar_parseargs(argcl, argl, buf, 0)) {
            SAFE_FREE(argl);
            return 1;
      }

      ret = process_tar();
      SAFE_FREE(argl);
      return ret;
}

/****************************************************************************
Command line (option) version
***************************************************************************/

int process_tar(void)
{
      TALLOC_CTX *ctx = talloc_tos();
      int rc = 0;
      initarbuf();
      switch(tar_type) {
            case 'x':

#if 0
                  do_tarput2();
#else
                  do_tarput();
#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_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;
                                    }
                                    p = strrchr_m(tarmac, '\\');
                                    if (!p) {
                                          return 1;
                                    }
                                    p[1] = '\0';
                                    client_set_cur_dir(tarmac);

                                    DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac));
                                    do_list(tarmac,attribute,do_tar, False, True);

                                    client_set_cur_dir(saved_dir);

                                    TALLOC_FREE(saved_dir);
                                    TALLOC_FREE(tarmac);
                              } else {
                                    tarmac = talloc_asprintf(ctx,
                                                "%s%s",
                                                client_get_cur_dir(),
                                                cliplist[i]);
                                    if (!tarmac) {
                                          return 1;
                                    }
                                    DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac));
                                    do_list(tarmac,attribute,do_tar, False, True);
                                    TALLOC_FREE(tarmac);
                              }
                        }
                  } else {
                        char *mask = talloc_asprintf(ctx,
                                          "%s\\*",
                                          client_get_cur_dir());
                        if (!mask) {
                              return 1;
                        }
                        DEBUG(5, ("process_tar, do_list with mask: %s\n", mask));
                        do_list(mask,attribute,do_tar,False, True);
                        TALLOC_FREE(mask);
                  }

                  if (ntarf) {
                        dotareof(tarhandle);
                  }
                  close(tarhandle);
                  SAFE_FREE(tarbuf);

                  DEBUG(0, ("tar: dumped %d files and directories\n", ntarf));
                  DEBUG(0, ("Total bytes written: %.0f\n", (double)ttarf));
                  break;
      }

      if (must_free_cliplist) {
            int i;
            for (i = 0; i < clipn; ++i) {
                  SAFE_FREE(cliplist[i]);
            }
            SAFE_FREE(cliplist);
            cliplist = NULL;
            clipn = 0;
            must_free_cliplist = False;
      }
      return rc;
}

/****************************************************************************
Find a token (filename) in a clip list
***************************************************************************/

static int clipfind(char **aret, int ret, char *tok)
{
      if (aret==NULL)
            return 0;

      /* ignore leading slashes or dots in token */
      while(strchr_m("/\\.", *tok))
            tok++;

      while(ret--) {
            char *pkey=*aret++;

            /* ignore leading slashes or dots in list */
            while(strchr_m("/\\.", *pkey))
                  pkey++;

            if (!strslashcmp(pkey, tok))
                  return 1;
      }
      return 0;
}

/****************************************************************************
Read list of files to include from the file and initialize cliplist
accordingly.
***************************************************************************/

static int read_inclusion_file(char *filename)
{
      XFILE *inclusion = NULL;
      char buf[PATH_MAX + 1];
      char *inclusion_buffer = NULL;
      int inclusion_buffer_size = 0;
      int inclusion_buffer_sofar = 0;
      char *p;
      char *tmpstr;
      int i;
      int error = 0;

      clipn = 0;
      buf[PATH_MAX] = '\0'; /* guarantee null-termination */
      if ((inclusion = x_fopen(filename, O_RDONLY, 0)) == NULL) {
            /* XXX It would be better to include a reason for failure, but without
             * autoconf, it's hard to use strerror, sys_errlist, etc.
             */
            DEBUG(0,("Unable to open inclusion file %s\n", filename));
            return 0;
      }

      while ((! error) && (x_fgets(buf, sizeof(buf)-1, inclusion))) {
            if (inclusion_buffer == NULL) {
                  inclusion_buffer_size = 1024;
                  if ((inclusion_buffer = (char *)SMB_MALLOC(inclusion_buffer_size)) == NULL) {
                        DEBUG(0,("failure allocating buffer to read inclusion file\n"));
                        error = 1;
                        break;
                  }
            }

            if (buf[strlen(buf)-1] == '\n') {
                  buf[strlen(buf)-1] = '\0';
            }

            if ((strlen(buf) + 1 + inclusion_buffer_sofar) >= inclusion_buffer_size) {
                  inclusion_buffer_size *= 2;
                  inclusion_buffer = (char *)SMB_REALLOC(inclusion_buffer,inclusion_buffer_size);
                  if (!inclusion_buffer) {
                        DEBUG(0,("failure enlarging inclusion buffer to %d bytes\n",
                                    inclusion_buffer_size));
                        error = 1;
                        break;
                  }
            }

            safe_strcpy(inclusion_buffer + inclusion_buffer_sofar, buf, inclusion_buffer_size - inclusion_buffer_sofar);
            inclusion_buffer_sofar += strlen(buf) + 1;
            clipn++;
      }
      x_fclose(inclusion);

      if (! error) {
            /* Allocate an array of clipn + 1 char*'s for cliplist */
            cliplist = SMB_MALLOC_ARRAY(char *, clipn + 1);
            if (cliplist == NULL) {
                  DEBUG(0,("failure allocating memory for cliplist\n"));
                  error = 1;
            } else {
                  cliplist[clipn] = NULL;
                  p = inclusion_buffer;
                  for (i = 0; (! error) && (i < clipn); i++) {
                        /* set current item to NULL so array will be null-terminated even if
                                    * malloc fails below. */
                        cliplist[i] = NULL;
                        if ((tmpstr = (char *)SMB_MALLOC(strlen(p)+1)) == NULL) {
                              DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", i));
                              error = 1;
                        } else {
                              unfixtarname(tmpstr, p, strlen(p) + 1, True);
                              cliplist[i] = tmpstr;
                              if ((p = strchr_m(p, '\000')) == NULL) {
                                    DEBUG(0,("INTERNAL ERROR: inclusion_buffer is of unexpected contents.\n"));
                                    abort();
                              }
                        }
                        ++p;
                  }
                  must_free_cliplist = True;
            }
      }

      SAFE_FREE(inclusion_buffer);
      if (error) {
            if (cliplist) {
                  char **pp;
                  /* We know cliplist is always null-terminated */
                  for (pp = cliplist; *pp; ++pp) {
                        SAFE_FREE(*pp);
                  }
                  SAFE_FREE(cliplist);
                  cliplist = NULL;
                  must_free_cliplist = False;
            }
            return 0;
      }

      /* cliplist and its elements are freed at the end of process_tar. */
      return 1;
}

/****************************************************************************
Parse tar arguments. Sets tar_type, tar_excl, etc.
***************************************************************************/

int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
{
      int newOptind = Optind;
      char tar_clipfl='\0';

      /* Reset back to defaults - could be from interactive version 
       * reset mode and archive mode left as they are though
       */
      tar_type='\0';
      tar_excl=True;
      dry_run=False;

      while (*Optarg) {
            switch(*Optarg++) {
                  case 'c':
                        tar_type='c';
                        break;
                  case 'x':
                        if (tar_type=='c') {
                              printf("Tar must be followed by only one of c or x.\n");
                              return 0;
                        }
                        tar_type='x';
                        break;
                  case 'b':
                        if (Optind>=argc || !(blocksize=atoi(argv[Optind]))) {
                              DEBUG(0,("Option b must be followed by valid blocksize\n"));
                              return 0;
                        } else {
                              Optind++;
                              newOptind++;
                        }
                        break;
                  case 'g':
                        tar_inc=True;
                        break;
                  case 'N':
                        if (Optind>=argc) {
                              DEBUG(0,("Option N must be followed by valid file name\n"));
                              return 0;
                        } else {
                              SMB_STRUCT_STAT stbuf;

                              if (sys_stat(argv[Optind], &stbuf) == 0) {
                                    newer_than = stbuf.st_mtime;
                                    DEBUG(1,("Getting files newer than %s",
                                          time_to_asc(newer_than)));
                                    newOptind++;
                                    Optind++;
                              } else {
                                    DEBUG(0,("Error setting newer-than time\n"));
                                    return 0;
                              }
                        }
                        break;
                  case 'a':
                        tar_reset=True;
                        break;
                  case 'q':
                        tar_noisy=False;
                        break;
                  case 'I':
                        if (tar_clipfl) {
                              DEBUG(0,("Only one of I,X,F must be specified\n"));
                              return 0;
                        }
                        tar_clipfl='I';
                        break;
                  case 'X':
                        if (tar_clipfl) {
                              DEBUG(0,("Only one of I,X,F must be specified\n"));
                              return 0;
                        }
                        tar_clipfl='X';
                        break;
                  case 'F':
                        if (tar_clipfl) {
                              DEBUG(0,("Only one of I,X,F must be specified\n"));
                              return 0;
                        }
                        tar_clipfl='F';
                        break;
                  case 'r':
                        DEBUG(0, ("tar_re_search set\n"));
                        tar_re_search = True;
                        break;
                  case 'n':
                        if (tar_type == 'c') {
                              DEBUG(0, ("dry_run set\n"));
                              dry_run = True;
                        } else {
                              DEBUG(0, ("n is only meaningful when creating a tar-file\n"));
                              return 0;
                        }
                        break;
                  default:
                        DEBUG(0,("Unknown tar option\n"));
                        return 0;
            }
      }

      if (!tar_type) {
            printf("Option T must be followed by one of c or x.\n");
            return 0;
      }

      /* tar_excl is true if cliplist lists files to be included.
       * Both 'I' and 'F' mean include. */
      tar_excl=tar_clipfl!='X';

      if (tar_clipfl=='F') {
            if (argc-Optind-1 != 1) {
                  DEBUG(0,("Option F must be followed by exactly one filename.\n"));
                  return 0;
            }
            newOptind++;
            /* Optind points at the tar output file, Optind+1 at the inclusion file. */
            if (! read_inclusion_file(argv[Optind+1])) {
                  return 0;
            }
      } else if (Optind+1<argc && !tar_re_search) { /* For backwards compatibility */
            char *tmpstr;
            char **tmplist;
            int clipcount;

            cliplist=argv+Optind+1;
            clipn=argc-Optind-1;
            clipcount = clipn;

            if ((tmplist=SMB_MALLOC_ARRAY(char *,clipn)) == NULL) {
                  DEBUG(0, ("Could not allocate space to process cliplist, count = %i\n", clipn));
                  return 0;
            }

            for (clipcount = 0; clipcount < clipn; clipcount++) {

                  DEBUG(5, ("Processing an item, %s\n", cliplist[clipcount]));

                  if ((tmpstr = (char *)SMB_MALLOC(strlen(cliplist[clipcount])+1)) == NULL) {
                        DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", clipcount));
                        SAFE_FREE(tmplist);
                        return 0;
                  }

                  unfixtarname(tmpstr, cliplist[clipcount], strlen(cliplist[clipcount]) + 1, True);
                  tmplist[clipcount] = tmpstr;
                  DEBUG(5, ("Processed an item, %s\n", tmpstr));

                  DEBUG(5, ("Cliplist is: %s\n", cliplist[0]));
            }

            cliplist = tmplist;
            must_free_cliplist = True;

            newOptind += clipn;
      }

      if (Optind+1<argc && tar_re_search && tar_clipfl != 'F') {
            /* Doing regular expression seaches not from an inclusion file. */
            clipn=argc-Optind-1;
            cliplist=argv+Optind+1;
            newOptind += clipn;
      }

      if (Optind>=argc || !strcmp(argv[Optind], "-")) {
            /* Sets tar handle to either 0 or 1, as appropriate */
            tarhandle=(tar_type=='c');
            /*
             * Make sure that dbf points to stderr if we are using stdout for 
             * tar output
             */
            if (tarhandle == 1)  {
                  dbf = x_stderr;
            }
            if (!argv[Optind]) {
                  DEBUG(0,("Must specify tar filename\n"));
                  return 0;
            }
            if (!strcmp(argv[Optind], "-")) {
                  newOptind++;
            }

      } else {
            if (tar_type=='c' && dry_run) {
                  tarhandle=-1;
            } else if ((tar_type=='x' && (tarhandle = sys_open(argv[Optind], O_RDONLY, 0)) == -1)
                              || (tar_type=='c' && (tarhandle=sys_creat(argv[Optind], 0644)) < 0)) {
                  DEBUG(0,("Error opening local file %s - %s\n", argv[Optind], strerror(errno)));
                  return(0);
            }
            newOptind++;
      }

      return newOptind;
}

Generated by  Doxygen 1.6.0   Back to index