source3/client/clitar.c

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