source3/client/clitar.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Tar Extensions
   5    Copyright (C) Ricky Poulten 1995-1998
   6    Copyright (C) Richard Sharpe 1998
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22 /* The following changes developed by Richard Sharpe for Canon Information
  23    Systems Research Australia (CISRA)
  24
  25    1. Restore can now restore files with long file names
  26    2. Save now saves directory information so that we can restore
  27       directory creation times
  28    3. tar now accepts both UNIX path names and DOS path names. I prefer
  29       those lovely /'s to those UGLY \'s :-)
  30    4. the files to exclude can be specified as a regular expression by adding
  31       an r flag to the other tar flags. Eg:
  32
  33          -TcrX file.tar "*.(obj|exe)"
  34
  35       will skip all .obj and .exe files
  36 */
  37
  38
  39 #include "includes.h"
  40 #include "clitar.h"
  41
  42 static int clipfind(char **aret, int ret, char *tok);
  43
  44 typedef struct file_info_struct file_info2;
  45
  46 struct file_info_struct
  47 {
  48   size_t size;
  49   uint16 mode;
  50   int uid;
  51   int gid;
  52   /* These times are normally kept in GMT */
  53   time_t mtime;
  54   time_t atime;
  55   time_t ctime;
  56   char *name;     /* This is dynamically allocate */
  57
  58   file_info2 *next, *prev;  /* Used in the stack ... */
  59
  60 };
  61
  62 typedef struct
  63 {
  64   file_info2 *top;
  65   int items;
  66
  67 } stack;
  68
  69 stack dir_stack = {NULL, 0}; /* Want an empty stack */
  70
  71 #define SEPARATORS " \t\n\r"
  72 extern int DEBUGLEVEL;
  73 extern struct cli_state *cli;
  74
  75 /* These defines are for the do_setrattr routine, to indicate
  76  * setting and reseting of file attributes in the function call */
  77 #define ATTRSET 1
  78 #define ATTRRESET 0
  79
  80 static uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
  81
  82 #ifndef CLIENT_TIMEOUT
  83 #define CLIENT_TIMEOUT (30*1000)
  84 #endif
  85
  86 static char *tarbuf, *buffer_p;
  87 static int tp, ntarf, tbufsiz, ttarf;
  88 /* Incremental mode */
  89 BOOL tar_inc=False;
  90 /* Reset archive bit */
  91 BOOL tar_reset=False;
  92 /* Include / exclude mode (true=include, false=exclude) */
  93 BOOL tar_excl=True;
  94 /* use regular expressions for search on file names */
  95 BOOL tar_re_search=False;
  96 #ifdef HAVE_REGEX_H
  97 regex_t *preg;
  98 #endif
  99 /* Do not dump anything, just calculate sizes */
 100 BOOL dry_run=False;
 101 /* Dump files with System attribute */
 102 BOOL tar_system=True;
 103 /* Dump files with Hidden attribute */
 104 BOOL tar_hidden=True;
 105 /* Be noisy - make a catalogue */
 106 BOOL tar_noisy=True;
 107 BOOL tar_real_noisy=False;  /* Don't want to be really noisy by default */
 108
 109 char tar_type='\0';
 110 static char **cliplist=NULL;
 111 static int clipn=0;
 112 static BOOL must_free_cliplist = False;
 113
 114 extern file_info def_finfo;
 115 extern BOOL lowercase;
 116 extern uint16 cnum;
 117 extern BOOL readbraw_supported;
 118 extern int max_xmit;
 119 extern pstring cur_dir;
 120 extern int get_total_time_ms;
 121 extern int get_total_size;
 122 extern int Protocol;
 123
 124 int blocksize=20;
 125 int tarhandle;
 126
 127 static void writetarheader(int f,  char *aname, int size, time_t mtime,
 128                            char *amode, unsigned char ftype);
 129 static void do_atar(char *rname,char *lname,file_info *finfo1);
 130 static void do_tar(file_info *finfo);
 131 static void oct_it(long value, int ndgs, char *p);
 132 static void fixtarname(char *tptr, char *fp, int l);
 133 static int dotarbuf(int f, char *b, int n);
 134 static void dozerobuf(int f, int n);
 135 static void dotareof(int f);
 136 static void initarbuf(void);
 137
 138 /* restore functions */
 139 static long readtarheader(union hblock *hb, file_info2 *finfo, char *prefix);
 140 static long unoct(char *p, int ndgs);
 141 static void do_tarput(void);
 142 static void unfixtarname(char *tptr, char *fp, int l, BOOL first);
 143
 144 /*
 145  * tar specific utitlities
 146  */
 147
 148 /*******************************************************************
 149 Create  a string of size size+1 (for the null)
 150 *******************************************************************/
 151 static char *string_create_s(int size)
 152 {
 153   char *tmp;
 154
 155   tmp = (char *)malloc(size+1);
 156
 157   if (tmp == NULL) {
 158
 159     DEBUG(0, ("Out of memory in string_create_s\n"));
 160
 161   }
 162
 163   return(tmp);
 164
 165 }
 166
 167 /****************************************************************************
 168 Write a tar header to buffer
 169 ****************************************************************************/
 170 static void writetarheader(int f,  char *aname, int size, time_t mtime,
 171                            char *amode, unsigned char ftype)
 172 {
 173   union hblock hb;
 174   int i, chk, l;
 175   char *jp;
 176
 177   DEBUG(5, ("WriteTarHdr, Type = %c, Size= %i, Name = %s\n", ftype, size, aname));
 178
 179   memset(hb.dummy, 0, sizeof(hb.dummy));
 180
 181   l=strlen(aname);
 182   if (l >= NAMSIZ) {
 183           /* write a GNU tar style long header */
 184           char *b;
 185           b = (char *)malloc(l+TBLOCK+100);
 186           if (!b) {
 187                   DEBUG(0,("out of memory\n"));
 188                   exit(1);
 189           }
 190           writetarheader(f, "/./@LongLink", l+1, 0, "     0 \0", 'L');
 191           memset(b, 0, l+TBLOCK+100);
 192           fixtarname(b, aname, l);
 193           i = strlen(b)+1;
 194           DEBUG(5, ("File name in tar file: %s, size=%i, \n", b, strlen(b)));
 195           dotarbuf(f, b, TBLOCK*(((i-1)/TBLOCK)+1));
 196           free(b);
 197   }
 198
 199   /* use l + 1 to do the null too */
 200   fixtarname(hb.dbuf.name, aname, (l >= NAMSIZ) ? NAMSIZ : l + 1);
 201
 202   if (lowercase)
 203     strlower(hb.dbuf.name);
 204
 205   /* write out a "standard" tar format header */
 206
 207   hb.dbuf.name[NAMSIZ-1]='\0';
 208   safe_strcpy(hb.dbuf.mode, amode, strlen(amode));
 209   oct_it(0L, 8, hb.dbuf.uid);
 210   oct_it(0L, 8, hb.dbuf.gid);
 211   oct_it((long) size, 13, hb.dbuf.size);
 212   oct_it((long) mtime, 13, hb.dbuf.mtime);
 213   memcpy(hb.dbuf.chksum, "        ", sizeof(hb.dbuf.chksum));
 214   memset(hb.dbuf.linkname, 0, NAMSIZ);
 215   hb.dbuf.linkflag=ftype;
 216
 217   for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;) chk+=(0xFF & *jp++);
 218
 219   oct_it((long) chk, 8, hb.dbuf.chksum);
 220   hb.dbuf.chksum[6] = '\0';
 221
 222   (void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
 223 }
 224
 225 /****************************************************************************
 226 Read a tar header into a hblock structure, and validate
 227 ***************************************************************************/
 228 static long readtarheader(union hblock *hb, file_info2 *finfo, char *prefix)
 229 {
 230   long chk, fchk;
 231   int i;
 232   char *jp;
 233
 234   /*
 235    * read in a "standard" tar format header - we're not that interested
 236    * in that many fields, though
 237    */
 238
 239   /* check the checksum */
 240   for (chk=0, i=sizeof(hb->dummy), jp=hb->dummy; --i>=0;) chk+=(0xFF & *jp++);
 241
 242   if (chk == 0)
 243     return chk;
 244
 245   /* compensate for blanks in chksum header */
 246   for (i=sizeof(hb->dbuf.chksum), jp=hb->dbuf.chksum; --i>=0;)
 247     chk-=(0xFF & *jp++);
 248
 249   chk += ' ' * sizeof(hb->dbuf.chksum);
 250
 251   fchk=unoct(hb->dbuf.chksum, sizeof(hb->dbuf.chksum));
 252
 253   DEBUG(5, ("checksum totals chk=%ld fchk=%ld chksum=%s\n",
 254             chk, fchk, hb->dbuf.chksum));
 255
 256   if (fchk != chk)
 257     {
 258       DEBUG(0, ("checksums don't match %ld %ld\n", fchk, chk));
 259       dump_data(5, (char *)hb - TBLOCK, TBLOCK *3);
 260       return -1;
 261     }
 262
 263   if ((finfo->name = string_create_s(strlen(prefix) + strlen(hb -> dbuf.name) + 3)) == NULL) {
 264
 265     DEBUG(0, ("Out of space creating file_info2 for %s\n", hb -> dbuf.name));
 266     return(-1);
 267
 268   }
 269
 270   safe_strcpy(finfo->name, prefix, strlen(prefix) + strlen(hb -> dbuf.name) + 3);
 271
 272   /* use l + 1 to do the null too; do prefix - prefcnt to zap leading slash */
 273   unfixtarname(finfo->name + strlen(prefix), hb->dbuf.name,
 274                strlen(hb->dbuf.name) + 1, True);
 275
 276   /* can't handle some links at present */
 277   if ((hb->dbuf.linkflag != '0') && (hb -> dbuf.linkflag != '5')) {
 278     if (hb->dbuf.linkflag == 0) {
 279       DEBUG(6, ("Warning: NULL link flag (gnu tar archive ?) %s\n",
 280                 finfo->name));
 281     } else {
 282       if (hb -> dbuf.linkflag == 'L') { /* We have a longlink */
 283          /* Do nothing here at the moment. do_tarput will handle this
 284             as long as the longlink gets back to it, as it has to advance
 285             the buffer pointer, etc */
 286
 287       } else {
 288         DEBUG(0, ("this tar file appears to contain some kind of link other than a GNUtar Longlink - ignoring\n"));
 289         return -2;
 290       }
 291     }
 292   }
 293
 294   if ((unoct(hb->dbuf.mode, sizeof(hb->dbuf.mode)) & S_IFDIR)
 295     || (*(finfo->name+strlen(finfo->name)-1) == '\\'))
 296     {
 297       finfo->mode=aDIR;
 298     }
 299   else
 300     finfo->mode=0; /* we don't care about mode at the moment, we'll
 301                     * just make it a regular file */
 302   /*
 303    * Bug fix by richard@sj.co.uk
 304    *
 305    * REC: restore times correctly (as does tar)
 306    * We only get the modification time of the file; set the creation time
 307    * from the mod. time, and the access time to current time
 308    */
 309   finfo->mtime = finfo->ctime = strtol(hb->dbuf.mtime, NULL, 8);
 310   finfo->atime = time(NULL);
 311   finfo->size = unoct(hb->dbuf.size, sizeof(hb->dbuf.size));
 312
 313   return True;
 314 }
 315
 316 /****************************************************************************
 317 Write out the tar buffer to tape or wherever
 318 ****************************************************************************/
 319 static int dotarbuf(int f, char *b, int n)
 320 {
 321   int fail=1, writ=n;
 322
 323   if (dry_run) {
 324     return writ;
 325   }
 326   /* This routine and the next one should be the only ones that do write()s */
 327   if (tp + n >= tbufsiz)
 328     {
 329       int diff;
 330
 331       diff=tbufsiz-tp;
 332       memcpy(tarbuf + tp, b, diff);
 333       fail=fail && (1+write(f, tarbuf, tbufsiz));
 334       n-=diff;
 335       b+=diff;
 336       tp=0;
 337
 338       while (n >= tbufsiz)
 339         {
 340           fail=fail && (1 + write(f, b, tbufsiz));
 341           n-=tbufsiz;
 342           b+=tbufsiz;
 343         }
 344     }
 345   if (n>0) {
 346     memcpy(tarbuf+tp, b, n);
 347     tp+=n;
 348   }
 349
 350   return(fail ? writ : 0);
 351 }
 352
 353 /****************************************************************************
 354 Write zeros to buffer / tape
 355 ****************************************************************************/
 356 static void dozerobuf(int f, int n)
 357 {
 358   /* short routine just to write out n zeros to buffer -
 359    * used to round files to nearest block
 360    * and to do tar EOFs */
 361
 362   if (dry_run)
 363     return;
 364
 365   if (n+tp >= tbufsiz)
 366     {
 367       memset(tarbuf+tp, 0, tbufsiz-tp);
 368
 369       write(f, tarbuf, tbufsiz);
 370       memset(tarbuf, 0, (tp+=n-tbufsiz));
 371     }
 372   else
 373     {
 374       memset(tarbuf+tp, 0, n);
 375       tp+=n;
 376     }
 377 }
 378
 379 /****************************************************************************
 380 Malloc tape buffer
 381 ****************************************************************************/
 382 static void initarbuf(void)
 383 {
 384   /* initialize tar buffer */
 385   tbufsiz=blocksize*TBLOCK;
 386   tarbuf=malloc(tbufsiz);      /* FIXME: We might not get the buffer */
 387
 388   /* reset tar buffer pointer and tar file counter and total dumped */
 389   tp=0; ntarf=0; ttarf=0;
 390 }
 391
 392 /****************************************************************************
 393 Write two zero blocks at end of file
 394 ****************************************************************************/
 395 static void dotareof(int f)
 396 {
 397   SMB_STRUCT_STAT stbuf;
 398   /* Two zero blocks at end of file, write out full buffer */
 399
 400   if (dry_run)
 401     return;
 402
 403   (void) dozerobuf(f, TBLOCK);
 404   (void) dozerobuf(f, TBLOCK);
 405
 406   if (sys_fstat(f, &stbuf) == -1)
 407     {
 408       DEBUG(0, ("Couldn't stat file handle\n"));
 409       return;
 410     }
 411
 412   /* Could be a pipe, in which case S_ISREG should fail,
 413    * and we should write out at full size */
 414   if (tp > 0) write(f, tarbuf, S_ISREG(stbuf.st_mode) ? tp : tbufsiz);
 415 }
 416
 417 /****************************************************************************
 418 (Un)mangle DOS pathname, make nonabsolute
 419 ****************************************************************************/
 420 static void fixtarname(char *tptr, char *fp, int l)
 421 {
 422   /* add a '.' to start of file name, convert from ugly dos \'s in path
 423    * to lovely unix /'s :-} */
 424
 425   *tptr++='.';
 426
 427   while (l > 0) {
 428     int skip;
 429     if((skip = skip_multibyte_char( *fp)) != 0) {
 430       if (skip == 2) {
 431         *tptr++ = *fp++;
 432         *tptr++ = *fp++;
 433         l -= 2;
 434       } else if (skip == 1) {
 435         *tptr++ = *fp++;
 436         l--;
 437       }
 438     } else if (*fp == '\\') {
 439       *tptr++ = '/';
 440       fp++;
 441       l--;
 442     } else {
 443       *tptr++ = *fp++;
 444       l--;
 445     }
 446   }
 447 }
 448
 449 /****************************************************************************
 450 Convert from decimal to octal string
 451 ****************************************************************************/
 452 static void oct_it (long value, int ndgs, char *p)
 453 {
 454   /* Converts long to octal string, pads with leading zeros */
 455
 456   /* skip final null, but do final space */
 457   --ndgs;
 458   p[--ndgs] = ' ';
 459
 460   /* Loop does at least one digit */
 461   do {
 462       p[--ndgs] = '0' + (char) (value & 7);
 463       value >>= 3;
 464     }
 465   while (ndgs > 0 && value != 0);
 466
 467   /* Do leading zeros */
 468   while (ndgs > 0)
 469     p[--ndgs] = '0';
 470 }
 471
 472 /****************************************************************************
 473 Convert from octal string to long
 474 ***************************************************************************/
 475 static long unoct(char *p, int ndgs)
 476 {
 477   long value=0;
 478   /* Converts octal string to long, ignoring any non-digit */
 479
 480   while (--ndgs)
 481     {
 482       if (isdigit((int)*p))
 483         value = (value << 3) | (long) (*p - '0');
 484
 485       p++;
 486     }
 487
 488   return value;
 489 }
 490
 491 /****************************************************************************
 492 Compare two strings in a slash insensitive way, allowing s1 to match s2
 493 if s1 is an "initial" string (up to directory marker).  Thus, if s2 is
 494 a file in any subdirectory of s1, declare a match.
 495 ***************************************************************************/
 496 static int strslashcmp(char *s1, char *s2)
 497 {
 498   char *s1_0=s1;
 499
 500   while(*s1 && *s2 &&
 501         (*s1 == *s2
 502          || tolower(*s1) == tolower(*s2)
 503          || (*s1 == '\\' && *s2=='/')
 504          || (*s1 == '/' && *s2=='\\'))) {
 505           s1++; s2++;
 506   }
 507
 508   /* if s1 has a trailing slash, it compared equal, so s1 is an "initial"
 509      string of s2.
 510    */
 511   if (!*s1 && s1 != s1_0 && (*(s1-1) == '/' || *(s1-1) == '\\')) return 0;
 512
 513   /* ignore trailing slash on s1 */
 514   if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1)) return 0;
 515
 516   /* check for s1 is an "initial" string of s2 */
 517   if (*s2 == '/' || *s2 == '\\') return 0;
 518
 519   return *s1-*s2;
 520 }
 521
 522
 523 /****************************************************************************
 524 Ensure a remote path exists (make if necessary)
 525 ***************************************************************************/
 526 static BOOL ensurepath(char *fname)
 527 {
 528   /* *must* be called with buffer ready malloc'ed */
 529   /* ensures path exists */
 530
 531   char *partpath, *ffname;
 532   char *p=fname, *basehack;
 533
 534   DEBUG(5, ( "Ensurepath called with: %s\n", fname));
 535
 536   partpath = string_create_s(strlen(fname));
 537   ffname = string_create_s(strlen(fname));
 538
 539   if ((partpath == NULL) || (ffname == NULL)){
 540
 541     DEBUG(0, ("Out of memory in ensurepath: %s\n", fname));
 542     return(False);
 543
 544   }
 545
 546   *partpath = 0;
 547
 548   /* fname copied to ffname so can strtok */
 549
 550   safe_strcpy(ffname, fname, strlen(fname));
 551
 552   /* do a `basename' on ffname, so don't try and make file name directory */
 553   if ((basehack=strrchr(ffname, '\\')) == NULL)
 554     return True;
 555   else
 556     *basehack='\0';
 557
 558   p=strtok(ffname, "\\");
 559
 560   while (p)
 561     {
 562       safe_strcat(partpath, p, strlen(fname) + 1);
 563
 564       if (!cli_chkpath(cli, partpath)) {
 565         if (!cli_mkdir(cli, partpath))
 566           {
 567             DEBUG(0, ("Error mkdirhiering\n"));
 568             return False;
 569           }
 570         else
 571           DEBUG(3, ("mkdirhiering %s\n", partpath));
 572
 573       }
 574
 575       safe_strcat(partpath, "\\", strlen(fname) + 1);
 576       p = strtok(NULL,"/\\");
 577     }
 578
 579     return True;
 580 }
 581
 582 static int padit(char *buf, int bufsize, int padsize)
 583 {
 584         int berr= 0;
 585         int bytestowrite;
 586
 587         DEBUG(5, ("Padding with %d zeros\n", padsize));
 588         memset(buf, 0, bufsize);
 589         while( !berr && padsize > 0 ) {
 590                 bytestowrite= MIN(bufsize, padsize);
 591                 berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite;
 592                 padsize -= bytestowrite;
 593         }
 594
 595         return berr;
 596 }
 597
 598
 599 static void do_setrattr(char *name, uint16 attr, int set)
 600 {
 601         uint16 oldattr;
 602         time_t t;
 603
 604         if (!cli_getatr(cli, name, &oldattr, NULL, &t)) return;
 605
 606         if (set == ATTRSET) {
 607                 attr |= oldattr;
 608         } else {
 609                 attr = oldattr & ~attr;
 610         }
 611
 612         if (!cli_setatr(cli, name, attr, t)) {
 613                 DEBUG(1,("setatr failed: %s\n", cli_errstr(cli)));
 614         }
 615 }
 616
 617
 618 /****************************************************************************
 619 append one remote file to the tar file
 620 ***************************************************************************/
 621 static void do_atar(char *rname,char *lname,file_info *finfo1)
 622 {
 623   int fnum;
 624   uint32 nread=0;
 625   char ftype;
 626   file_info2 finfo;
 627   BOOL close_done = False;
 628   BOOL shallitime=True;
 629   char data[65520];
 630   int read_size = 65520;
 631   int datalen=0;
 632
 633   struct timeval tp_start;
 634   GetTimeOfDay(&tp_start);
 635
 636   ftype = '0'; /* An ordinary file ... */
 637
 638   if (finfo1) {
 639     finfo.size  = finfo1 -> size;
 640     finfo.mode  = finfo1 -> mode;
 641     finfo.uid   = finfo1 -> uid;
 642     finfo.gid   = finfo1 -> gid;
 643     finfo.mtime = finfo1 -> mtime;
 644     finfo.atime = finfo1 -> atime;
 645     finfo.ctime = finfo1 -> ctime;
 646   }
 647   else {
 648     finfo.size  = def_finfo.size;
 649     finfo.mode  = def_finfo.mode;
 650     finfo.uid   = def_finfo.uid;
 651     finfo.gid   = def_finfo.gid;
 652     finfo.mtime = def_finfo.mtime;
 653     finfo.atime = def_finfo.atime;
 654     finfo.ctime = def_finfo.ctime;
 655   }
 656
 657   if (dry_run)
 658     {
 659       DEBUG(3,("skipping file %s of size %d bytes\n",
 660                finfo.name,
 661                finfo.size));
 662       shallitime=0;
 663       ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
 664       ntarf++;
 665       return;
 666     }
 667
 668   fnum = cli_open(cli, rname, O_RDONLY, DENY_NONE);
 669
 670   dos_clean_name(rname);
 671
 672   if (fnum == -1) {
 673           DEBUG(0,("%s opening remote file %s (%s)\n",
 674                    cli_errstr(cli),rname, cur_dir));
 675           return;
 676   }
 677
 678   finfo.name = string_create_s(strlen(rname));
 679   if (finfo.name == NULL) {
 680           DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n"));
 681           return;
 682   }
 683
 684   safe_strcpy(finfo.name,rname, strlen(rname));
 685   if (!finfo1) {
 686           if (!cli_getattrE(cli, fnum, &finfo.mode, &finfo.size, NULL, &finfo.atime, &finfo.mtime)) {
 687                   DEBUG(0, ("getattrE: %s\n", cli_errstr(cli)));
 688                   return;
 689           }
 690           finfo.ctime = finfo.mtime;
 691   }
 692
 693   DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
 694
 695   if (tar_inc && !(finfo.mode & aARCH))
 696     {
 697       DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name));
 698       shallitime=0;
 699     }
 700   else if (!tar_system && (finfo.mode & aSYSTEM))
 701     {
 702       DEBUG(4, ("skipping %s - system bit is set\n", finfo.name));
 703       shallitime=0;
 704     }
 705   else if (!tar_hidden && (finfo.mode & aHIDDEN))
 706     {
 707       DEBUG(4, ("skipping %s - hidden bit is set\n", finfo.name));
 708       shallitime=0;
 709     }
 710   else
 711     {
 712       DEBUG(3,("getting file %s of size %d bytes as a tar file %s",
 713                finfo.name,
 714                finfo.size,
 715                lname));
 716
 717       /* write a tar header, don't bother with mode - just set to 100644 */
 718       writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0", ftype);
 719
 720       while (nread < finfo.size && !close_done) {
 721
 722               DEBUG(3,("nread=%d\n",nread));
 723
 724               datalen = cli_read(cli, fnum, data, nread, read_size);
 725
 726               if (datalen == -1) {
 727                       DEBUG(0,("Error reading file %s : %s\n", rname, cli_errstr(cli)));
 728                       break;
 729               }
 730
 731               /* add received bits of file to buffer - dotarbuf will
 732                * write out in 512 byte intervals */
 733               if (dotarbuf(tarhandle,data,datalen) != datalen) {
 734                       DEBUG(0,("Error writing to tar file - %s\n", strerror(errno)));
 735                       break;
 736               }
 737
 738               nread += datalen;
 739               if (datalen == 0) {
 740                       DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
 741                       break;
 742               }
 743
 744               datalen=0;
 745       }
 746
 747       /* pad tar file with zero's if we couldn't get entire file */
 748       if (nread < finfo.size) {
 749               DEBUG(0, ("Didn't get entire file. size=%d, nread=%d\n", finfo.size, nread));
 750               if (padit(data, sizeof(data), finfo.size - nread))
 751                       DEBUG(0,("Error writing tar file - %s\n", strerror(errno)));
 752       }
 753
 754       /* round tar file to nearest block */
 755       if (finfo.size % TBLOCK)
 756         dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));
 757
 758       ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
 759       ntarf++;
 760     }
 761
 762   cli_close(cli, fnum);
 763
 764   if (shallitime)
 765     {
 766       struct timeval tp_end;
 767       int this_time;
 768
 769       /* if shallitime is true then we didn't skip */
 770       if (tar_reset && !dry_run)
 771         (void) do_setrattr(finfo.name, aARCH, ATTRRESET);
 772
 773       GetTimeOfDay(&tp_end);
 774       this_time =
 775         (tp_end.tv_sec - tp_start.tv_sec)*1000 +
 776           (tp_end.tv_usec - tp_start.tv_usec)/1000;
 777       get_total_time_ms += this_time;
 778       get_total_size += finfo.size;
 779
 780       if (tar_noisy)
 781         {
 782           DEBUG(0, ("%10d (%7.1f kb/s) %s\n",
 783                finfo.size, finfo.size / MAX(0.001, (1.024*this_time)),
 784                finfo.name));
 785         }
 786
 787       /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
 788       DEBUG(3,("(%g kb/s) (average %g kb/s)\n",
 789                finfo.size / MAX(0.001, (1.024*this_time)),
 790                get_total_size / MAX(0.001, (1.024*get_total_time_ms))));
 791     }
 792 }
 793
 794 /****************************************************************************
 795 Append single file to tar file (or not)
 796 ***************************************************************************/
 797 static void do_tar(file_info *finfo)
 798 {
 799   pstring rname;
 800
 801   if (strequal(finfo->name,"..") || strequal(finfo->name,"."))
 802     return;
 803
 804   /* Is it on the exclude list ? */
 805   if (!tar_excl && clipn) {
 806     pstring exclaim;
 807
 808     DEBUG(5, ("Excl: strlen(cur_dir) = %i\n", strlen(cur_dir)));
 809
 810     safe_strcpy(exclaim, cur_dir, sizeof(pstring));
 811     *(exclaim+strlen(exclaim)-1)='\0';
 812
 813     safe_strcat(exclaim, "\\", sizeof(pstring));
 814     safe_strcat(exclaim, finfo->name, sizeof(exclaim));
 815
 816     DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));
 817
 818     if ((!tar_re_search && clipfind(cliplist, clipn, exclaim)) ||
 819 #ifdef HAVE_REGEX_H
 820         (tar_re_search && !regexec(preg, exclaim, 0, NULL, 0))) {
 821 #else
 822         (tar_re_search && mask_match(exclaim, cliplist[0], True, False))) {
 823 #endif
 824       DEBUG(3,("Skipping file %s\n", exclaim));
 825       return;
 826     }
 827   }
 828
 829   if (finfo->mode & aDIR)
 830     {
 831       pstring saved_curdir;
 832       pstring mtar_mask;
 833
 834       safe_strcpy(saved_curdir, cur_dir, sizeof(saved_curdir));
 835
 836       DEBUG(5, ("Sizeof(cur_dir)=%i, strlen(cur_dir)=%i, strlen(finfo->name)=%i\nname=%s,cur_dir=%s\n", sizeof(cur_dir), strlen(cur_dir), strlen(finfo->name), finfo->name, cur_dir));
 837
 838       safe_strcat(cur_dir,finfo->name, sizeof(cur_dir));
 839       safe_strcat(cur_dir,"\\", sizeof(cur_dir));
 840
 841       DEBUG(5, ("Writing a dir, Name = %s\n", cur_dir));
 842
 843       /* write a tar directory, don't bother with mode - just set it to
 844        * 40755 */
 845       writetarheader(tarhandle, cur_dir, 0, finfo->mtime, "040755 \0", '5');
 846       if (tar_noisy) {
 847           DEBUG(0,("                directory %s\n", cur_dir));
 848       }
 849       ntarf++;  /* Make sure we have a file on there */
 850       safe_strcpy(mtar_mask,cur_dir, sizeof(pstring));
 851       safe_strcat(mtar_mask,"*.*", sizeof(pstring));
 852       do_list(mtar_mask, attribute, do_tar, False, True);
 853       safe_strcpy(cur_dir,saved_curdir, sizeof(pstring));
 854     }
 855   else
 856     {
 857       safe_strcpy(rname,cur_dir, sizeof(pstring));
 858       safe_strcat(rname,finfo->name, sizeof(pstring));
 859       do_atar(rname,finfo->name,finfo);
 860     }
 861 }
 862
 863 /****************************************************************************
 864 Convert from UNIX to DOS file names
 865 ***************************************************************************/
 866 static void unfixtarname(char *tptr, char *fp, int l, BOOL first)
 867 {
 868   /* remove '.' from start of file name, convert from unix /'s to
 869    * dos \'s in path. Kill any absolute path names. But only if first!
 870    */
 871
 872   DEBUG(5, ("firstb=%lX, secondb=%lX, len=%i\n", (long)tptr, (long)fp, l));
 873
 874   if (first) {
 875     if (*fp == '.') {
 876       fp++;
 877       l--;
 878     }
 879     if (*fp == '\\' || *fp == '/') {
 880       fp++;
 881       l--;
 882     }
 883   }
 884
 885   while (l > 0) {
 886     int skip;
 887     if(( skip = skip_multibyte_char( *fp )) != 0) {
 888       if (skip == 2) {
 889         *tptr++ = *fp++;
 890         *tptr++ = *fp++;
 891         l -= 2;
 892       } else if (skip == 1) {
 893         *tptr++ = *fp++;
 894         l--;
 895       }
 896     } else if (*fp == '/') {
 897       *tptr++ = '\\';
 898       fp++;
 899       l--;
 900     } else {
 901       *tptr++ = *fp++;
 902       l--;
 903     }
 904   }
 905 }
 906
 907
 908 /****************************************************************************
 909 Move to the next block in the buffer, which may mean read in another set of
 910 blocks. FIXME, we should allow more than one block to be skipped.
 911 ****************************************************************************/
 912 static int next_block(char *ltarbuf, char **bufferp, int bufsiz)
 913 {
 914   int bufread, total = 0;
 915
 916   DEBUG(5, ("Advancing to next block: %0lx\n", (unsigned long)*bufferp));
 917   *bufferp += TBLOCK;
 918   total = TBLOCK;
 919
 920   if (*bufferp >= (ltarbuf + bufsiz)) {
 921
 922     DEBUG(5, ("Reading more data into ltarbuf ...\n"));
 923
 924     total = 0;
 925
 926     for (bufread = read(tarhandle, ltarbuf, bufsiz); total < bufsiz; total += bufread) {
 927
 928       if (bufread <= 0) { /* An error, return false */
 929         return (total > 0 ? -2 : bufread);
 930       }
 931
 932     }
 933
 934     DEBUG(5, ("Total bytes read ... %i\n", total));
 935
 936     *bufferp = ltarbuf;
 937
 938   }
 939
 940   return(total);
 941
 942 }
 943
 944 /* Skip a file, even if it includes a long file name? */
 945 static int skip_file(int skipsize)
 946 {
 947   int dsize = skipsize;
 948
 949   DEBUG(5, ("Skiping file. Size = %i\n", skipsize));
 950
 951   /* FIXME, we should skip more than one block at a time */
 952
 953   while (dsize > 0) {
 954
 955     if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
 956
 957         DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
 958         return(False);
 959
 960     }
 961
 962     dsize -= TBLOCK;
 963
 964   }
 965
 966   return(True);
 967 }
 968
 969 /* We get a file from the tar file and store it */
 970 static int get_file(file_info2 finfo)
 971 {
 972   int fsize = finfo.size;
 973   int fnum, pos = 0, dsize = 0, rsize = 0, bpos = 0;
 974
 975   DEBUG(5, ("get_file: file: %s, size %i\n", finfo.name, fsize));
 976
 977   if (ensurepath(finfo.name) &&
 978       (fnum=cli_open(cli, finfo.name, O_WRONLY|O_CREAT|O_TRUNC, DENY_NONE)) == -1)
 979     {
 980       DEBUG(0, ("abandoning restore\n"));
 981       return(False);
 982     }
 983
 984   /* read the blocks from the tar file and write to the remote file */
 985
 986   rsize = fsize;  /* This is how much to write */
 987
 988   while (rsize > 0) {
 989
 990     /* We can only write up to the end of the buffer */
 991
 992     dsize = MIN(tbufsiz - (buffer_p - tarbuf) - bpos, 65520); /* Calculate the size to write */
 993     dsize = MIN(dsize, rsize);  /* Should be only what is left */
 994     DEBUG(5, ("writing %i bytes, bpos = %i ...\n", dsize, bpos));
 995
 996     if (cli_write(cli, fnum, 0, buffer_p + bpos, pos, dsize) != dsize) {
 997             DEBUG(0, ("Error writing remote file\n"));
 998             return 0;
 999     }
1000
1001     rsize -= dsize;
1002     pos += dsize;
1003
1004     /* Now figure out how much to move in the buffer */
1005
1006     /* FIXME, we should skip more than one block at a time */
1007
1008     /* First, skip any initial part of the part written that is left over */
1009     /* from the end of the first TBLOCK                                   */
1010
1011     if ((bpos) && ((bpos + dsize) >= TBLOCK)) {
1012
1013       dsize -= (TBLOCK - bpos);  /* Get rid of the end of the first block */
1014       bpos = 0;
1015
1016       if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {  /* and skip the block */
1017         DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
1018         return False;
1019
1020       }
1021
1022     }
1023
1024     while (dsize >= TBLOCK) {
1025
1026       if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
1027
1028         DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
1029         return False;
1030
1031       }
1032
1033       dsize -= TBLOCK;
1034
1035     }
1036
1037     bpos = dsize;
1038
1039   }
1040
1041   /* Now close the file ... */
1042
1043   if (!cli_close(cli, fnum)) {
1044           DEBUG(0, ("Error closing remote file\n"));
1045           return(False);
1046   }
1047
1048   /* Now we update the creation date ... */
1049
1050   DEBUG(5, ("Updating creation date on %s\n", finfo.name));
1051
1052   if (!cli_setatr(cli, finfo.name, finfo.mode, finfo.mtime)) {
1053           if (tar_real_noisy) {
1054                   DEBUG(0, ("Could not set time on file: %s\n", finfo.name));
1055                   /*return(False); */ /* Ignore, as Win95 does not allow changes */
1056           }
1057   }
1058
1059   ntarf++;
1060
1061   DEBUG(0, ("restore tar file %s of size %d bytes\n", finfo.name, finfo.size));
1062
1063   return(True);
1064 }
1065
1066 /* Create a directory.  We just ensure that the path exists and return as there
1067    is no file associated with a directory
1068 */
1069 static int get_dir(file_info2 finfo)
1070 {
1071
1072   DEBUG(5, ("Creating directory: %s\n", finfo.name));
1073
1074   if (!ensurepath(finfo.name)) {
1075
1076     DEBUG(0, ("Problems creating directory\n"));
1077     return(False);
1078
1079   }
1080   return(True);
1081
1082 }
1083 /* Get a file with a long file name ... first file has file name, next file
1084    has the data. We only want the long file name, as the loop in do_tarput
1085    will deal with the rest.
1086 */
1087 static char * get_longfilename(file_info2 finfo)
1088 {
1089   int namesize = finfo.size + strlen(cur_dir) + 2;
1090   char *longname = malloc(namesize);
1091   int offset = 0, left = finfo.size;
1092   BOOL first = True;
1093
1094   DEBUG(5, ("Restoring a long file name: %s\n", finfo.name));
1095   DEBUG(5, ("Len = %i\n", finfo.size));
1096
1097   if (longname == NULL) {
1098
1099     DEBUG(0, ("could not allocate buffer of size %d for longname\n",
1100               finfo.size + strlen(cur_dir) + 2));
1101     return(NULL);
1102   }
1103
1104   /* First, add cur_dir to the long file name */
1105
1106   if (strlen(cur_dir) > 0) {
1107     strncpy(longname, cur_dir, namesize);
1108     offset = strlen(cur_dir);
1109   }
1110
1111   /* Loop through the blocks picking up the name */
1112
1113   while (left > 0) {
1114
1115     if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
1116
1117       DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
1118       return(NULL);
1119
1120     }
1121
1122     unfixtarname(longname + offset, buffer_p, MIN(TBLOCK, finfo.size), first--);
1123     DEBUG(5, ("UnfixedName: %s, buffer: %s\n", longname, buffer_p));
1124
1125     offset += TBLOCK;
1126     left -= TBLOCK;
1127
1128   }
1129
1130   return(longname);
1131
1132 }
1133
1134 static void do_tarput(void)
1135 {
1136   file_info2 finfo;
1137   struct timeval tp_start;
1138   char *longfilename = NULL, linkflag;
1139   int skip = False;
1140
1141   GetTimeOfDay(&tp_start);
1142
1143   DEBUG(5, ("RJS do_tarput called ...\n"));
1144
1145   buffer_p = tarbuf + tbufsiz;  /* init this to force first read */
1146
1147   /* Now read through those files ... */
1148
1149   while (True) {
1150
1151     /* Get us to the next block, or the first block first time around */
1152
1153     if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
1154
1155       DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
1156
1157       return;
1158
1159     }
1160
1161     DEBUG(5, ("Reading the next header ...\n"));
1162
1163     switch (readtarheader((union hblock *) buffer_p, &finfo, cur_dir)) {
1164
1165     case -2:    /* Hmm, not good, but not fatal */
1166       DEBUG(0, ("Skipping %s...\n", finfo.name));
1167       if ((next_block(tarbuf, &buffer_p, tbufsiz) <= 0) &&
1168           !skip_file(finfo.size)) {
1169
1170         DEBUG(0, ("Short file, bailing out...\n"));
1171         return;
1172
1173       }
1174
1175       break;
1176
1177     case -1:
1178       DEBUG(0, ("abandoning restore, -1 from read tar header\n"));
1179       return;
1180
1181     case 0: /* chksum is zero - looks like an EOF */
1182       DEBUG(0, ("total of %d tar files restored to share\n", ntarf));
1183       return;        /* Hmmm, bad here ... */
1184
1185     default:
1186       /* No action */
1187
1188       break;
1189
1190     }
1191
1192     /* Now, do we have a long file name? */
1193
1194     if (longfilename != NULL) {
1195
1196       free(finfo.name);   /* Free the space already allocated */
1197       finfo.name = longfilename;
1198       longfilename = NULL;
1199
1200     }
1201
1202     /* Well, now we have a header, process the file ...            */
1203
1204     /* Should we skip the file? We have the long name as well here */
1205
1206     skip = clipn &&
1207       ((!tar_re_search && clipfind(cliplist, clipn, finfo.name) ^ tar_excl)
1208 #ifdef HAVE_REGEX_H
1209       || (tar_re_search && !regexec(preg, finfo.name, 0, NULL, 0)));
1210 #else
1211       || (tar_re_search && mask_match(finfo.name, cliplist[0], True, False)));
1212 #endif
1213
1214   DEBUG(5, ("Skip = %i, cliplist=%s, file=%s\n", skip, (cliplist?cliplist[0]:NULL), finfo.name));
1215
1216   if (skip) {
1217
1218     skip_file(finfo.size);
1219     continue;
1220
1221   }
1222
1223     /* We only get this far if we should process the file */
1224   linkflag = ((union hblock *)buffer_p) -> dbuf.linkflag;
1225
1226     switch (linkflag) {
1227
1228     case '0':  /* Should use symbolic names--FIXME */
1229
1230       /* Skip to the next block first, so we can get the file, FIXME, should
1231          be in get_file ... */
1232
1233       if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
1234         DEBUG(0, ("Short file, bailing out...\n"));
1235         return;
1236       }
1237       if (!get_file(finfo)) {
1238         DEBUG(0, ("Abandoning restore\n"));
1239         return;
1240
1241       }
1242       break;
1243
1244     case '5':
1245       if (!get_dir(finfo)) {
1246         DEBUG(0, ("Abandoning restore \n"));
1247         return;
1248       }
1249       break;
1250
1251     case 'L':
1252       longfilename = get_longfilename(finfo);
1253       if (!longfilename) {
1254         DEBUG(0, ("abandoning restore\n"));
1255         return;
1256
1257       }
1258       DEBUG(5, ("Long file name: %s\n", longfilename));
1259       break;
1260
1261     default:
1262       skip_file(finfo.size);  /* Don't handle these yet */
1263       break;
1264
1265     }
1266
1267   }
1268
1269
1270 }
1271
1272
1273 /*
1274  * samba interactive commands
1275  */
1276
1277 /****************************************************************************
1278 Blocksize command
1279 ***************************************************************************/
1280 void cmd_block(void)
1281 {
1282   fstring buf;
1283   int block;
1284
1285   if (!next_token(NULL,buf,NULL,sizeof(buf)))
1286     {
1287       DEBUG(0, ("blocksize <n>\n"));
1288       return;
1289     }
1290
1291   block=atoi(buf);
1292   if (block < 0 || block > 65535)
1293     {
1294       DEBUG(0, ("blocksize out of range"));
1295       return;
1296     }
1297
1298   blocksize=block;
1299   DEBUG(2,("blocksize is now %d\n", blocksize));
1300 }
1301
1302 /****************************************************************************
1303 command to set incremental / reset mode
1304 ***************************************************************************/
1305 void cmd_tarmode(void)
1306 {
1307   fstring buf;
1308
1309   while (next_token(NULL,buf,NULL,sizeof(buf))) {
1310     if (strequal(buf, "full"))
1311       tar_inc=False;
1312     else if (strequal(buf, "inc"))
1313       tar_inc=True;
1314     else if (strequal(buf, "reset"))
1315       tar_reset=True;
1316     else if (strequal(buf, "noreset"))
1317       tar_reset=False;
1318     else if (strequal(buf, "system"))
1319       tar_system=True;
1320     else if (strequal(buf, "nosystem"))
1321       tar_system=False;
1322     else if (strequal(buf, "hidden"))
1323       tar_hidden=True;
1324     else if (strequal(buf, "nohidden"))
1325       tar_hidden=False;
1326     else if (strequal(buf, "verbose") || strequal(buf, "noquiet"))
1327       tar_noisy=True;
1328     else if (strequal(buf, "quiet") || strequal(buf, "noverbose"))
1329       tar_noisy=False;
1330     else DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
1331   }
1332
1333   DEBUG(0, ("tarmode is now %s, %s, %s, %s, %s\n",
1334             tar_inc ? "incremental" : "full",
1335             tar_system ? "system" : "nosystem",
1336             tar_hidden ? "hidden" : "nohidden",
1337             tar_reset ? "reset" : "noreset",
1338             tar_noisy ? "verbose" : "quiet"));
1339
1340 }
1341
1342 /****************************************************************************
1343 Feeble attrib command
1344 ***************************************************************************/
1345 void cmd_setmode(void)
1346 {
1347   char *q;
1348   fstring buf;
1349   pstring fname;
1350   uint16 attra[2];
1351   int direct=1;
1352
1353   attra[0] = attra[1] = 0;
1354
1355   if (!next_token(NULL,buf,NULL,sizeof(buf)))
1356     {
1357       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1358       return;
1359     }
1360
1361   safe_strcpy(fname, cur_dir, sizeof(pstring));
1362   safe_strcat(fname, buf, sizeof(pstring));
1363
1364   while (next_token(NULL,buf,NULL,sizeof(buf))) {
1365     q=buf;
1366
1367     while(*q)
1368       switch (*q++) {
1369       case '+': direct=1;
1370         break;
1371       case '-': direct=0;
1372         break;
1373       case 'r': attra[direct]|=aRONLY;
1374         break;
1375       case 'h': attra[direct]|=aHIDDEN;
1376         break;
1377       case 's': attra[direct]|=aSYSTEM;
1378         break;
1379       case 'a': attra[direct]|=aARCH;
1380         break;
1381       default: DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1382         return;
1383       }
1384   }
1385
1386   if (attra[ATTRSET]==0 && attra[ATTRRESET]==0)
1387     {
1388       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1389       return;
1390     }
1391
1392   DEBUG(2, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
1393   (void) do_setrattr(fname, attra[ATTRSET], ATTRSET);
1394   (void) do_setrattr(fname, attra[ATTRRESET], ATTRRESET);
1395 }
1396
1397 /****************************************************************************
1398 Principal command for creating / extracting
1399 ***************************************************************************/
1400 void cmd_tar(void)
1401 {
1402   fstring buf;
1403   char **argl;
1404   int argcl;
1405
1406   if (!next_token(NULL,buf,NULL,sizeof(buf)))
1407     {
1408       DEBUG(0,("tar <c|x>[IXbgan] <filename>\n"));
1409       return;
1410     }
1411
1412   argl=toktocliplist(&argcl, NULL);
1413   if (!tar_parseargs(argcl, argl, buf, 0))
1414     return;
1415
1416   process_tar();
1417
1418   free(argl);
1419 }
1420
1421 /****************************************************************************
1422 Command line (option) version
1423 ***************************************************************************/
1424 int process_tar(void)
1425 {
1426   initarbuf();
1427   switch(tar_type) {
1428   case 'x':
1429
1430 #if 0
1431     do_tarput2();
1432 #else
1433     do_tarput();
1434 #endif
1435     free(tarbuf);
1436     close(tarhandle);
1437     break;
1438   case 'r':
1439   case 'c':
1440     if (clipn && tar_excl) {
1441       int i;
1442       pstring tarmac;
1443
1444       for (i=0; i<clipn; i++) {
1445         DEBUG(5,("arg %d = %s\n", i, cliplist[i]));
1446
1447         if (*(cliplist[i]+strlen(cliplist[i])-1)=='\\') {
1448           *(cliplist[i]+strlen(cliplist[i])-1)='\0';
1449         }
1450
1451         if (strrchr(cliplist[i], '\\')) {
1452           pstring saved_dir;
1453
1454           safe_strcpy(saved_dir, cur_dir, sizeof(pstring));
1455
1456           if (*cliplist[i]=='\\') {
1457             safe_strcpy(tarmac, cliplist[i], sizeof(pstring));
1458           } else {
1459             safe_strcpy(tarmac, cur_dir, sizeof(pstring));
1460             safe_strcat(tarmac, cliplist[i], sizeof(pstring));
1461           }
1462           safe_strcpy(cur_dir, tarmac, sizeof(pstring));
1463           *(strrchr(cur_dir, '\\')+1)='\0';
1464
1465           do_list(tarmac,attribute,do_tar, False, True);
1466           safe_strcpy(cur_dir,saved_dir, sizeof(pstring));
1467         } else {
1468           safe_strcpy(tarmac, cur_dir, sizeof(pstring));
1469           safe_strcat(tarmac, cliplist[i], sizeof(pstring));
1470           do_list(tarmac,attribute,do_tar, False, True);
1471         }
1472       }
1473     } else {
1474       pstring mask;
1475       safe_strcpy(mask,cur_dir, sizeof(pstring));
1476       safe_strcat(mask,"\\*.*", sizeof(pstring));
1477       do_list(mask,attribute,do_tar,False, True);
1478     }
1479
1480     if (ntarf) dotareof(tarhandle);
1481     close(tarhandle);
1482     free(tarbuf);
1483
1484     DEBUG(0, ("tar: dumped %d tar files\n", ntarf));
1485     DEBUG(0, ("Total bytes written: %d\n", ttarf));
1486     break;
1487   }
1488
1489   if (must_free_cliplist) {
1490     int i;
1491     for (i = 0; i < clipn; ++i) {
1492       free(cliplist[i]);
1493     }
1494     free(cliplist);
1495     cliplist = NULL;
1496     clipn = 0;
1497     must_free_cliplist = False;
1498   }
1499
1500   return(0);
1501 }
1502
1503 /****************************************************************************
1504 Find a token (filename) in a clip list
1505 ***************************************************************************/
1506 static int clipfind(char **aret, int ret, char *tok)
1507 {
1508   if (aret==NULL) return 0;
1509
1510   /* ignore leading slashes or dots in token */
1511   while(strchr("/\\.", *tok)) tok++;
1512
1513   while(ret--) {
1514     char *pkey=*aret++;
1515
1516     /* ignore leading slashes or dots in list */
1517     while(strchr("/\\.", *pkey)) pkey++;
1518
1519     if (!strslashcmp(pkey, tok)) return 1;
1520   }
1521
1522   return 0;
1523 }
1524
1525 /****************************************************************************
1526 Read list of files to include from the file and initialize cliplist
1527 accordingly.
1528 ***************************************************************************/
1529 static int read_inclusion_file(char *filename)
1530 {
1531   FILE *inclusion = NULL;
1532   char buf[MAXPATHLEN + 1];
1533   char *inclusion_buffer = NULL;
1534   int inclusion_buffer_size = 0;
1535   int inclusion_buffer_sofar = 0;
1536   char *p;
1537   char *tmpstr;
1538   int i;
1539   int error = 0;
1540
1541   clipn = 0;
1542   buf[MAXPATHLEN] = '\0'; /* guarantee null-termination */
1543   if ((inclusion = fopen(filename, "r")) == NULL) {
1544     /* XXX It would be better to include a reason for failure, but without
1545      * autoconf, it's hard to use strerror, sys_errlist, etc.
1546      */
1547     DEBUG(0,("Unable to open inclusion file %s\n", filename));
1548     return 0;
1549   }
1550
1551   while ((! error) && (fgets(buf, sizeof(buf)-1, inclusion))) {
1552     if (inclusion_buffer == NULL) {
1553       inclusion_buffer_size = 1024;
1554       if ((inclusion_buffer = malloc(inclusion_buffer_size)) == NULL) {
1555         DEBUG(0,("failure allocating buffer to read inclusion file\n"));
1556         error = 1;
1557         break;
1558       }
1559     }
1560
1561     if (buf[strlen(buf)-1] == '\n') {
1562       buf[strlen(buf)-1] = '\0';
1563     }
1564
1565     if ((strlen(buf) + 1 + inclusion_buffer_sofar) >= inclusion_buffer_size) {
1566       inclusion_buffer_size *= 2;
1567       inclusion_buffer = Realloc(inclusion_buffer,inclusion_buffer_size);
1568       if (! inclusion_buffer) {
1569         DEBUG(0,("failure enlarging inclusion buffer to %d bytes\n",
1570                  inclusion_buffer_size));
1571         error = 1;
1572         break;
1573       }
1574     }
1575
1576     safe_strcpy(inclusion_buffer + inclusion_buffer_sofar, buf, inclusion_buffer_size - inclusion_buffer_sofar);
1577     inclusion_buffer_sofar += strlen(buf) + 1;
1578     clipn++;
1579   }
1580   fclose(inclusion);
1581
1582   if (! error) {
1583     /* Allocate an array of clipn + 1 char*'s for cliplist */
1584     cliplist = malloc((clipn + 1) * sizeof(char *));
1585     if (cliplist == NULL) {
1586       DEBUG(0,("failure allocating memory for cliplist\n"));
1587       error = 1;
1588     } else {
1589       cliplist[clipn] = NULL;
1590       p = inclusion_buffer;
1591       for (i = 0; (! error) && (i < clipn); i++) {
1592         /* set current item to NULL so array will be null-terminated even if
1593          * malloc fails below. */
1594         cliplist[i] = NULL;
1595         if ((tmpstr = (char *)malloc(strlen(p)+1)) == NULL) {
1596           DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", i));
1597           error = 1;
1598         } else {
1599           unfixtarname(tmpstr, p, strlen(p) + 1, True);
1600           cliplist[i] = tmpstr;
1601           if ((p = strchr(p, '\000')) == NULL) {
1602             DEBUG(0,("INTERNAL ERROR: inclusion_buffer is of unexpected contents.\n"));
1603             abort();
1604           }
1605         }
1606         ++p;
1607       }
1608       must_free_cliplist = True;
1609     }
1610   }
1611
1612   if (inclusion_buffer) {
1613     free(inclusion_buffer);
1614   }
1615   if (error) {
1616     if (cliplist) {
1617       char **pp;
1618       /* We know cliplist is always null-terminated */
1619       for (pp = cliplist; *pp; ++pp) {
1620         free(*pp);
1621       }
1622       free(cliplist);
1623       cliplist = NULL;
1624       must_free_cliplist = False;
1625     }
1626     return 0;
1627   }
1628
1629   /* cliplist and its elements are freed at the end of process_tar. */
1630   return 1;
1631 }
1632
1633 /****************************************************************************
1634 Parse tar arguments. Sets tar_type, tar_excl, etc.
1635 ***************************************************************************/
1636 int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind)
1637 {
1638   char tar_clipfl='\0';
1639
1640   /* Reset back to defaults - could be from interactive version
1641    * reset mode and archive mode left as they are though
1642    */
1643   tar_type='\0';
1644   tar_excl=True;
1645   dry_run=False;
1646
1647   while (*Optarg)
1648     switch(*Optarg++) {
1649     case 'c':
1650       tar_type='c';
1651       break;
1652     case 'x':
1653       if (tar_type=='c') {
1654         printf("Tar must be followed by only one of c or x.\n");
1655         return 0;
1656       }
1657       tar_type='x';
1658       break;
1659     case 'b':
1660       if (Optind>=argc || !(blocksize=atoi(argv[Optind]))) {
1661         DEBUG(0,("Option b must be followed by valid blocksize\n"));
1662         return 0;
1663       } else {
1664         Optind++;
1665       }
1666       break;
1667     case 'g':
1668       tar_inc=True;
1669       break;
1670     case 'N':
1671       if (Optind>=argc) {
1672         DEBUG(0,("Option N must be followed by valid file name\n"));
1673         return 0;
1674       } else {
1675         SMB_STRUCT_STAT stbuf;
1676         extern time_t newer_than;
1677
1678         if (dos_stat(argv[Optind], &stbuf) == 0) {
1679           newer_than = stbuf.st_mtime;
1680           DEBUG(1,("Getting files newer than %s",
1681                    asctime(LocalTime(&newer_than))));
1682           Optind++;
1683         } else {
1684           DEBUG(0,("Error setting newer-than time\n"));
1685           return 0;
1686         }
1687       }
1688       break;
1689     case 'a':
1690       tar_reset=True;
1691       break;
1692     case 'q':
1693       tar_noisy=False;
1694       break;
1695     case 'I':
1696       if (tar_clipfl) {
1697         DEBUG(0,("Only one of I,X,F must be specified\n"));
1698         return 0;
1699       }
1700       tar_clipfl='I';
1701       break;
1702     case 'X':
1703       if (tar_clipfl) {
1704         DEBUG(0,("Only one of I,X,F must be specified\n"));
1705         return 0;
1706       }
1707       tar_clipfl='X';
1708       break;
1709     case 'F':
1710       if (tar_clipfl) {
1711         DEBUG(0,("Only one of I,X,F must be specified\n"));
1712         return 0;
1713       }
1714       tar_clipfl='F';
1715       break;
1716     case 'r':
1717       DEBUG(0, ("tar_re_search set\n"));
1718       tar_re_search = True;
1719       break;
1720     case 'n':
1721       if (tar_type == 'c') {
1722         DEBUG(0, ("dry_run set\n"));
1723         dry_run = True;
1724       } else {
1725         DEBUG(0, ("n is only meaningful when creating a tar-file\n"));
1726         return 0;
1727       }
1728       break;
1729     default:
1730       DEBUG(0,("Unknown tar option\n"));
1731       return 0;
1732     }
1733
1734   if (!tar_type) {
1735     printf("Option T must be followed by one of c or x.\n");
1736     return 0;
1737   }
1738
1739   /* tar_excl is true if cliplist lists files to be included.
1740    * Both 'I' and 'F' mean include. */
1741   tar_excl=tar_clipfl!='X';
1742
1743   if (tar_clipfl=='F') {
1744     if (argc-Optind-1 != 1) {
1745       DEBUG(0,("Option F must be followed by exactly one filename.\n"));
1746       return 0;
1747     }
1748     if (! read_inclusion_file(argv[Optind+1])) {
1749       return 0;
1750     }
1751   } else if (Optind+1<argc && !tar_re_search) { /* For backwards compatibility */
1752     char *tmpstr;
1753     char **tmplist;
1754     int clipcount;
1755
1756     cliplist=argv+Optind+1;
1757     clipn=argc-Optind-1;
1758     clipcount = clipn;
1759
1760     if ((tmplist=malloc(clipn*sizeof(char *))) == NULL) {
1761       DEBUG(0, ("Could not allocate space to process cliplist, count = %i\n",
1762                clipn)
1763            );
1764       return 0;
1765     }
1766
1767     for (clipcount = 0; clipcount < clipn; clipcount++) {
1768
1769       DEBUG(5, ("Processing an item, %s\n", cliplist[clipcount]));
1770
1771       if ((tmpstr = (char *)malloc(strlen(cliplist[clipcount])+1)) == NULL) {
1772         DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n",
1773                  clipcount)
1774              );
1775         return 0;
1776       }
1777       unfixtarname(tmpstr, cliplist[clipcount], strlen(cliplist[clipcount]) + 1, True);
1778       tmplist[clipcount] = tmpstr;
1779       DEBUG(5, ("Processed an item, %s\n", tmpstr));
1780
1781       DEBUG(5, ("Cliplist is: %s\n", cliplist[0]));
1782     }
1783     cliplist = tmplist;
1784     must_free_cliplist = True;
1785   }
1786
1787   if (Optind+1<argc && tar_re_search) {  /* Doing regular expression seaches */
1788 #ifdef HAVE_REGEX_H
1789     int errcode;
1790
1791     if ((preg = (regex_t *)malloc(65536)) == NULL) {
1792
1793       DEBUG(0, ("Could not allocate buffer for regular expression search\n"));
1794       return;
1795
1796     }
1797
1798     if (errcode = regcomp(preg, argv[Optind + 1], REG_EXTENDED)) {
1799       char errstr[1024];
1800       size_t errlen;
1801
1802       errlen = regerror(errcode, preg, errstr, sizeof(errstr) - 1);
1803
1804       DEBUG(0, ("Could not compile pattern buffer for re search: %s\n%s\n", argv[Optind + 1], errstr));
1805       return;
1806
1807     }
1808 #endif
1809
1810     clipn=argc-Optind-1;
1811     cliplist=argv+Optind+1;
1812
1813   }
1814
1815   if (Optind>=argc || !strcmp(argv[Optind], "-")) {
1816     /* Sets tar handle to either 0 or 1, as appropriate */
1817     tarhandle=(tar_type=='c');
1818   } else {
1819     if (tar_type=='c' && (dry_run || strcmp(argv[Optind], "/dev/null")==0))
1820       {
1821         if (!dry_run) {
1822           DEBUG(0,("Output is /dev/null, assuming dry_run"));
1823           dry_run = True;
1824         }
1825         tarhandle=-1;
1826       } else
1827     if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY)) == -1)
1828         || (tar_type=='c' && (tarhandle=creat(argv[Optind], 0644)) < 0))
1829       {
1830         DEBUG(0,("Error opening local file %s - %s\n",
1831                  argv[Optind], strerror(errno)));
1832         return(0);
1833       }
1834   }
1835
1836   return 1;
1837 }