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 typedef struct file_info_struct file_info2;
  43
  44 struct file_info_struct
  45 {
  46   int size;
  47   int mode;
  48   int uid;
  49   int gid;
  50   /* These times are normally kept in GMT */
  51   time_t mtime;
  52   time_t atime;
  53   time_t ctime;
  54   char *name;     /* This is dynamically allocate */
  55
  56   file_info2 *next, *prev;  /* Used in the stack ... */
  57
  58 };
  59
  60 typedef struct
  61 {
  62   file_info2 *top;
  63   int items;
  64
  65 } stack;
  66
  67 stack dir_stack = {NULL, 0}; /* Want an empty stack */
  68
  69 extern BOOL recurse;
  70
  71 #define SEPARATORS " \t\n\r"
  72 extern int DEBUGLEVEL;
  73 extern int Client;
  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 int attribute = aDIR | aSYSTEM | aHIDDEN;
  81
  82 #ifndef CLIENT_TIMEOUT
  83 #define CLIENT_TIMEOUT (30*1000)
  84 #endif
  85
  86 static char *tarbuf;
  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 /* Dump files with System attribute */
 100 BOOL tar_system=True;
 101 /* Dump files with Hidden attribute */
 102 BOOL tar_hidden=True;
 103 /* Be noisy - make a catalogue */
 104 BOOL tar_noisy=True;
 105 BOOL tar_real_noisy=True;
 106
 107 char tar_type='\0';
 108 static char **cliplist=NULL;
 109 static int clipn=0;
 110 static BOOL must_free_cliplist = False;
 111
 112 extern file_info def_finfo;
 113 extern BOOL lowercase;
 114 extern int cnum;
 115 extern BOOL readbraw_supported;
 116 extern int max_xmit;
 117 extern pstring cur_dir;
 118 extern int get_total_time_ms;
 119 extern int get_total_size;
 120 extern int Protocol;
 121
 122 int blocksize=20;
 123 int tarhandle;
 124
 125 static void writetarheader(int f,  char *aname, int size, time_t mtime,
 126                            char *amode, unsigned char ftype);
 127 static void do_atar(char *rname,char *lname,file_info *finfo1);
 128 static void do_tar(file_info *finfo);
 129 static void oct_it(long value, int ndgs, char *p);
 130 static void fixtarname(char *tptr, char *fp, int l);
 131 static int dotarbuf(int f, char *b, int n);
 132 static void dozerobuf(int f, int n);
 133 static void dotareof(int f);
 134 static void initarbuf(void);
 135 static int do_setrattr(char *fname, int attr, int setit);
 136
 137 /* restore functions */
 138 static long readtarheader(union hblock *hb, file_info2 *finfo, char *prefix);
 139 static long unoct(char *p, int ndgs);
 140 static void do_tarput(void);
 141 static void unfixtarname(char *tptr, char *fp, int l, BOOL first);
 142
 143 /*
 144  * tar specific utitlities
 145  */
 146
 147 #if 0 /* Removed to get around gcc 'defined but not used' error. */
 148
 149 /*
 150  * Stack routines, push_dir, pop_dir, top_dir_name
 151  */
 152
 153 static BOOL push_dir(stack *tar_dir_stack, file_info2 *dir)
 154 {
 155   dir -> next = tar_dir_stack -> top;
 156   dir -> prev = NULL;
 157   tar_dir_stack -> items++;
 158   tar_dir_stack -> top = dir;
 159   return(True);
 160
 161 }
 162
 163 static file_info2 *pop_dir(stack *tar_dir_stack)
 164 {
 165   file_info2 *ptr;
 166
 167   ptr = tar_dir_stack -> top;
 168   if (tar_dir_stack -> top != NULL) {
 169
 170     tar_dir_stack -> top = tar_dir_stack -> top -> next;
 171     tar_dir_stack -> items--;
 172
 173   }
 174
 175   return ptr;
 176
 177 }
 178
 179 static char *top_dir_name(stack *tar_dir_stack)
 180 {
 181
 182   return(tar_dir_stack -> top != NULL?tar_dir_stack -> top -> name:NULL);
 183
 184 }
 185
 186 static BOOL sub_dir(char *dir1, char *dir2)
 187 {
 188
 189   return(True);
 190
 191 }
 192
 193 #endif /* Removed to get around gcc 'defined but not used' error. */
 194
 195 /*******************************************************************
 196 Create  a string of size size+1 (for the null)
 197 *******************************************************************/
 198 static char *string_create_s(int size)
 199 {
 200   char *tmp;
 201
 202   tmp = (char *)malloc(size+1);
 203
 204   if (tmp == NULL) {
 205
 206     DEBUG(0, ("Out of memory in string_create_s\n"));
 207
 208   }
 209
 210   return(tmp);
 211
 212 }
 213
 214 /****************************************************************************
 215 Write a tar header to buffer
 216 ****************************************************************************/
 217 static void writetarheader(int f,  char *aname, int size, time_t mtime,
 218                            char *amode, unsigned char ftype)
 219 {
 220   union hblock hb;
 221   int i, chk, l;
 222   char *jp;
 223
 224   DEBUG(5, ("WriteTarHdr, Type = %c, Size= %i, Name = %s\n", ftype, size, aname));
 225
 226   memset(hb.dummy, 0, sizeof(hb.dummy));
 227
 228   l=strlen(aname);
 229   if (l >= NAMSIZ) {
 230           /* write a GNU tar style long header */
 231           char *b;
 232           b = (char *)malloc(l+TBLOCK+100);
 233           if (!b) {
 234                   DEBUG(0,("out of memory\n"));
 235                   exit(1);
 236           }
 237           writetarheader(f, "/./@LongLink", l+1, 0, "     0 \0", 'L');
 238           memset(b, 0, l+TBLOCK+100);
 239           fixtarname(b, aname, l);
 240           i = strlen(b)+1;
 241           DEBUG(5, ("File name in tar file: %s, size=%i, \n", b, strlen(b)));
 242           dotarbuf(f, b, TBLOCK*(((i-1)/TBLOCK)+1));
 243           free(b);
 244   }
 245
 246   /* use l + 1 to do the null too */
 247   fixtarname(hb.dbuf.name, aname, (l >= NAMSIZ) ? NAMSIZ : l + 1);
 248
 249   if (lowercase)
 250     strlower(hb.dbuf.name);
 251
 252   /* write out a "standard" tar format header */
 253
 254   hb.dbuf.name[NAMSIZ-1]='\0';
 255   safe_strcpy(hb.dbuf.mode, amode, strlen(amode));
 256   oct_it(0L, 8, hb.dbuf.uid);
 257   oct_it(0L, 8, hb.dbuf.gid);
 258   oct_it((long) size, 13, hb.dbuf.size);
 259   oct_it((long) mtime, 13, hb.dbuf.mtime);
 260   memcpy(hb.dbuf.chksum, "        ", sizeof(hb.dbuf.chksum));
 261   memset(hb.dbuf.linkname, 0, NAMSIZ);
 262   hb.dbuf.linkflag=ftype;
 263
 264   for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;) chk+=(0xFF & *jp++);
 265
 266   oct_it((long) chk, 8, hb.dbuf.chksum);
 267   hb.dbuf.chksum[6] = '\0';
 268
 269   (void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
 270 }
 271
 272 /****************************************************************************
 273 Read a tar header into a hblock structure, and validate
 274 ***************************************************************************/
 275 static long readtarheader(union hblock *hb, file_info2 *finfo, char *prefix)
 276 {
 277   long chk, fchk;
 278   int i;
 279   char *jp;
 280
 281   /*
 282    * read in a "standard" tar format header - we're not that interested
 283    * in that many fields, though
 284    */
 285
 286   /* check the checksum */
 287   for (chk=0, i=sizeof(hb->dummy), jp=hb->dummy; --i>=0;) chk+=(0xFF & *jp++);
 288
 289   if (chk == 0)
 290     return chk;
 291
 292   /* compensate for blanks in chksum header */
 293   for (i=sizeof(hb->dbuf.chksum), jp=hb->dbuf.chksum; --i>=0;)
 294     chk-=(0xFF & *jp++);
 295
 296   chk += ' ' * sizeof(hb->dbuf.chksum);
 297
 298   fchk=unoct(hb->dbuf.chksum, sizeof(hb->dbuf.chksum));
 299
 300   DEBUG(5, ("checksum totals chk=%d fchk=%d chksum=%s\n",
 301             chk, fchk, hb->dbuf.chksum));
 302
 303   if (fchk != chk)
 304     {
 305       DEBUG(0, ("checksums don't match %d %d\n", fchk, chk));
 306       for (i = 0; i < sizeof(hb -> dummy); i++) {
 307         fprintf(stdout, "%2X ", hb -> dummy[i]);
 308       }
 309       fprintf(stdout, "\n");
 310       fprintf(stdout, "%s\n", hb -> dummy);
 311       fprintf(stdout, "Tarbuf = %X, hb = %X\n", (int)tarbuf, (int)hb);
 312       return -1;
 313     }
 314
 315   if ((finfo->name = string_create_s(strlen(prefix) + strlen(hb -> dbuf.name) + 3)) == NULL) {
 316
 317     DEBUG(0, ("Out of space creating file_info2 for %s\n", hb -> dbuf.name));
 318     return(-1);
 319
 320   }
 321
 322   safe_strcpy(finfo->name, prefix, strlen(prefix) + strlen(hb -> dbuf.name) + 3);
 323
 324   /* use l + 1 to do the null too; do prefix - prefcnt to zap leading slash */
 325   unfixtarname(finfo->name + strlen(prefix), hb->dbuf.name,
 326                strlen(hb->dbuf.name) + 1, True);
 327
 328 /* can't handle some links at present */
 329   if ((hb->dbuf.linkflag != '0') && (hb -> dbuf.linkflag != '5')) {
 330     if (hb->dbuf.linkflag == 0) {
 331       DEBUG(6, ("Warning: NULL link flag (gnu tar archive ?) %s\n",
 332                 finfo->name));
 333     } else {
 334       if (hb -> dbuf.linkflag == 'L') { /* We have a longlink */
 335          /* Do nothing here at the moment. do_tarput will handle this
 336             as long as the longlink gets back to it, as it has to advance
 337             the buffer pointer, etc */
 338
 339       } else {
 340         DEBUG(0, ("this tar file appears to contain some kind of link other than a GNUtar Longlink - ignoring\n"));
 341         return -2;
 342       }
 343     }
 344   }
 345
 346   if ((unoct(hb->dbuf.mode, sizeof(hb->dbuf.mode)) & S_IFDIR)
 347     || (*(finfo->name+strlen(finfo->name)-1) == '\\'))
 348     {
 349       finfo->mode=aDIR;
 350     }
 351   else
 352     finfo->mode=0; /* we don't care about mode at the moment, we'll
 353                     * just make it a regular file */
 354   /*
 355    * Bug fix by richard@sj.co.uk
 356    *
 357    * REC: restore times correctly (as does tar)
 358    * We only get the modification time of the file; set the creation time
 359    * from the mod. time, and the access time to current time
 360    */
 361   finfo->mtime = finfo->ctime = strtol(hb->dbuf.mtime, NULL, 8);
 362   finfo->atime = time(NULL);
 363   finfo->size = unoct(hb->dbuf.size, sizeof(hb->dbuf.size));
 364
 365   return True;
 366 }
 367
 368 /****************************************************************************
 369 Write out the tar buffer to tape or wherever
 370 ****************************************************************************/
 371 static int dotarbuf(int f, char *b, int n)
 372 {
 373   int fail=1, writ=n;
 374
 375   /* This routine and the next one should be the only ones that do write()s */
 376   if (tp + n >= tbufsiz)
 377     {
 378       int diff;
 379
 380       diff=tbufsiz-tp;
 381       memcpy(tarbuf + tp, b, diff);
 382       fail=fail && (1+write(f, tarbuf, tbufsiz));
 383       n-=diff;
 384       b+=diff;
 385       tp=0;
 386
 387       while (n >= tbufsiz)
 388         {
 389           fail=fail && (1 + write(f, b, tbufsiz));
 390           n-=tbufsiz;
 391           b+=tbufsiz;
 392         }
 393     }
 394   if (n>0) {
 395     memcpy(tarbuf+tp, b, n);
 396     tp+=n;
 397   }
 398
 399   return(fail ? writ : 0);
 400 }
 401
 402 /****************************************************************************
 403 Write zeros to buffer / tape
 404 ****************************************************************************/
 405 static void dozerobuf(int f, int n)
 406 {
 407   /* short routine just to write out n zeros to buffer -
 408    * used to round files to nearest block
 409    * and to do tar EOFs */
 410
 411   if (n+tp >= tbufsiz)
 412     {
 413       memset(tarbuf+tp, 0, tbufsiz-tp);
 414
 415       write(f, tarbuf, tbufsiz);
 416       memset(tarbuf, 0, (tp+=n-tbufsiz));
 417     }
 418   else
 419     {
 420       memset(tarbuf+tp, 0, n);
 421       tp+=n;
 422     }
 423 }
 424
 425 /****************************************************************************
 426 Malloc tape buffer
 427 ****************************************************************************/
 428 static void initarbuf()
 429 {
 430   /* initialize tar buffer */
 431   tbufsiz=blocksize*TBLOCK;
 432   tarbuf=malloc(tbufsiz);      /* FIXME: We might not get the buffer */
 433
 434   /* reset tar buffer pointer and tar file counter and total dumped */
 435   tp=0; ntarf=0; ttarf=0;
 436 }
 437
 438 /****************************************************************************
 439 Write two zero blocks at end of file
 440 ****************************************************************************/
 441 static void dotareof(int f)
 442 {
 443   struct stat stbuf;
 444   /* Two zero blocks at end of file, write out full buffer */
 445
 446   (void) dozerobuf(f, TBLOCK);
 447   (void) dozerobuf(f, TBLOCK);
 448
 449   if (fstat(f, &stbuf) == -1)
 450     {
 451       DEBUG(0, ("Couldn't stat file handle\n"));
 452       return;
 453     }
 454
 455   /* Could be a pipe, in which case S_ISREG should fail,
 456    * and we should write out at full size */
 457   if (tp > 0) write(f, tarbuf, S_ISREG(stbuf.st_mode) ? tp : tbufsiz);
 458 }
 459
 460 /****************************************************************************
 461 (Un)mangle DOS pathname, make nonabsolute
 462 ****************************************************************************/
 463 static void fixtarname(char *tptr, char *fp, int l)
 464 {
 465   /* add a '.' to start of file name, convert from ugly dos \'s in path
 466    * to lovely unix /'s :-} */
 467
 468   *tptr++='.';
 469
 470   while (l > 0) {
 471     int skip;
 472     if((skip = skip_multibyte_char( *fp)) != 0) {
 473       if (skip == 2) {
 474         *tptr++ = *fp++;
 475         *tptr++ = *fp++;
 476         l -= 2;
 477       } else if (skip == 1) {
 478         *tptr++ = *fp++;
 479         l--;
 480       }
 481     } else if (*fp == '\\') {
 482       *tptr++ = '/';
 483       fp++;
 484       l--;
 485     } else {
 486       *tptr++ = *fp++;
 487       l--;
 488     }
 489   }
 490 }
 491
 492 /****************************************************************************
 493 Convert from decimal to octal string
 494 ****************************************************************************/
 495 static void oct_it (long value, int ndgs, char *p)
 496 {
 497   /* Converts long to octal string, pads with leading zeros */
 498
 499   /* skip final null, but do final space */
 500   --ndgs;
 501   p[--ndgs] = ' ';
 502
 503   /* Loop does at least one digit */
 504   do {
 505       p[--ndgs] = '0' + (char) (value & 7);
 506       value >>= 3;
 507     }
 508   while (ndgs > 0 && value != 0);
 509
 510   /* Do leading zeros */
 511   while (ndgs > 0)
 512     p[--ndgs] = '0';
 513 }
 514
 515 /****************************************************************************
 516 Convert from octal string to long
 517 ***************************************************************************/
 518 static long unoct(char *p, int ndgs)
 519 {
 520   long value=0;
 521   /* Converts octal string to long, ignoring any non-digit */
 522
 523   while (--ndgs)
 524     {
 525       if (isdigit(*p))
 526         value = (value << 3) | (long) (*p - '0');
 527
 528       p++;
 529     }
 530
 531   return value;
 532 }
 533
 534 /****************************************************************************
 535 Compare two strings in a slash insensitive way, allowing s1 to match s2
 536 if s1 is an "initial" string (up to directory marker).  Thus, if s2 is
 537 a file in any subdirectory of s1, declare a match.
 538 ***************************************************************************/
 539 static int strslashcmp(char *s1, char *s2)
 540 {
 541   char *s1_0=s1;
 542
 543   while(*s1 && *s2 &&
 544         (*s1 == *s2
 545          || tolower(*s1) == tolower(*s2)
 546          || (*s1 == '\\' && *s2=='/')
 547          || (*s1 == '/' && *s2=='\\'))) {
 548           s1++; s2++;
 549   }
 550
 551   /* if s1 has a trailing slash, it compared equal, so s1 is an "initial"
 552      string of s2.
 553    */
 554   if (!*s1 && s1 != s1_0 && (*(s1-1) == '/' || *(s1-1) == '\\')) return 0;
 555
 556   /* ignore trailing slash on s1 */
 557   if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1)) return 0;
 558
 559   /* check for s1 is an "initial" string of s2 */
 560   if (*s2 == '/' || *s2 == '\\') return 0;
 561
 562   return *s1-*s2;
 563 }
 564
 565 /*
 566  * general smb utility functions
 567  */
 568 /**********************************************************************
 569 do_setrtime, set time on a file or dir ...
 570 **********************************************************************/
 571
 572 static int do_setrtime(char *fname, int mtime, BOOL err_silent)
 573 {
 574   char *inbuf, *outbuf, *p;
 575   char *name;
 576
 577   DEBUG(5, ("Setting time on: %s, fnlen=%i.\n", fname, strlen(fname)));
 578
 579   name = (char *)malloc(strlen(fname) + 1 + 1);
 580   if (name == NULL) {
 581
 582      DEBUG(0, ("Failed to allocate space while setting time on file: %s", fname));
 583      return False;
 584
 585   }
 586
 587   if (*fname != '\\')
 588     safe_strcpy(name, "\\", strlen(fname) + 1);
 589   else
 590     safe_strcpy(name, "", strlen(fname) + 1);
 591   safe_strcat(name, fname, strlen(fname) + 1);
 592
 593   if (fname[strlen(name) - 1] == '\\')
 594     name[strlen(name) - 1] = '\0';
 595
 596   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
 597   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
 598
 599   if (!inbuf || !outbuf) {
 600
 601     DEBUG(0, ("Could not allocate memory for inbuf or outbuf while changing time on: %s\n", fname));
 602     free(name);
 603     return False;
 604
 605   }
 606
 607   memset(outbuf, 0, smb_size);
 608   set_message(outbuf, 8, 4 + strlen(name), True);
 609   CVAL(outbuf, smb_com) = SMBsetatr;
 610   SSVAL(outbuf, smb_tid, cnum);
 611   cli_setup_pkt(outbuf);
 612
 613   SSVAL(outbuf, smb_vwv0, 0);
 614   put_dos_date3(outbuf, smb_vwv1, mtime);
 615
 616   p = smb_buf(outbuf);
 617   *p++ = 4;
 618   safe_strcpy(p, name, strlen(name));
 619   p+= (strlen(fname)+1);
 620
 621   *p++ = 4;
 622   *p++ = 0;
 623
 624   send_smb(Client, outbuf);
 625   client_receive_smb(Client, inbuf, CLIENT_TIMEOUT);
 626
 627   if (CVAL(inbuf,smb_rcls) != 0)
 628     {
 629       if (!err_silent) {
 630         DEBUG(0,("%s setting attributes on file %s\n",
 631                  smb_errstr(inbuf), fname));
 632       }
 633       free(name);free(inbuf);free(outbuf);
 634       return(False);
 635     }
 636
 637   free(name);
 638   free(inbuf);free(outbuf);
 639   return(True);
 640
 641 }
 642
 643 /****************************************************************************
 644 Set DOS file attributes
 645 ***************************************************************************/
 646 static int do_setrattr(char *fname, int attr, int setit)
 647 {
 648   /*
 649    * First get the existing attribs from existing file
 650    */
 651   char *inbuf,*outbuf;
 652   char *p;
 653   char *name;
 654   int fattr;
 655
 656   name = (char *)malloc(strlen(fname) + 1 + 1);
 657   if (name == NULL) {
 658
 659      DEBUG(0, ("Failed to allocate space in do_setrattr while setting time on file: %s", fname));
 660      return False;
 661
 662   }
 663
 664   safe_strcpy(name, "\\", strlen(fname) + 1);
 665   safe_strcat(name, fname, strlen(fname) + 1);
 666
 667   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
 668   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
 669
 670   if (!inbuf || !outbuf)
 671     {
 672       DEBUG(0,("out of memory\n"));
 673       free(name);
 674       return False;
 675     }
 676
 677   /* send an smb getatr message */
 678
 679   memset(outbuf,0,smb_size);
 680   set_message(outbuf,0,2 + strlen(fname),True);
 681   CVAL(outbuf,smb_com) = SMBgetatr;
 682   SSVAL(outbuf,smb_tid,cnum);
 683   cli_setup_pkt(outbuf);
 684
 685   p = smb_buf(outbuf);
 686   *p++ = 4;
 687   safe_strcpy(p,name, strlen(name));
 688   p += (strlen(name)+1);
 689
 690   *p++ = 4;
 691   *p++ = 0;
 692
 693   send_smb(Client,outbuf);
 694   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 695
 696   if (CVAL(inbuf,smb_rcls) != 0)
 697     DEBUG(5,("getatr: %s\n",smb_errstr(inbuf)));
 698   else
 699     {
 700       DEBUG(5,("\nattr 0x%X  time %d  size %d\n",
 701                (int)CVAL(inbuf,smb_vwv0),
 702                SVAL(inbuf,smb_vwv1),
 703                SVAL(inbuf,smb_vwv3)));
 704     }
 705
 706   fattr=CVAL(inbuf,smb_vwv0);
 707
 708   /* combine found attributes with bits to be set or reset */
 709
 710   attr=setit ? (fattr | attr) : (fattr & ~attr);
 711
 712   /* now try and set attributes by sending smb reset message */
 713
 714   /* clear out buffer and start again */
 715   memset(outbuf,0,smb_size);
 716   set_message(outbuf,8,4 + strlen(name),True);
 717   CVAL(outbuf,smb_com) = SMBsetatr;
 718   SSVAL(outbuf,smb_tid,cnum);
 719   cli_setup_pkt(outbuf);
 720
 721   SSVAL(outbuf,smb_vwv0,attr);
 722
 723   p = smb_buf(outbuf);
 724   *p++ = 4;
 725   safe_strcpy(p,name, strlen(name));
 726   p += (strlen(name)+1);
 727
 728   *p++ = 4;
 729   *p++ = 0;
 730
 731   send_smb(Client,outbuf);
 732   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 733
 734   if (CVAL(inbuf,smb_rcls) != 0)
 735     {
 736       DEBUG(0,("%s setting attributes on file %s\n",
 737             smb_errstr(inbuf), name));
 738       free(name);free(inbuf);free(outbuf);
 739       return(False);
 740     }
 741
 742   free(name);
 743   free(inbuf);free(outbuf);
 744   return(True);
 745 }
 746
 747 /****************************************************************************
 748 Create a file on a share
 749 ***************************************************************************/
 750 static BOOL smbcreat(file_info2 finfo, int *fnum, char *inbuf, char *outbuf)
 751 {
 752   char *p;
 753   /* *must* be called with buffer ready malloc'ed */
 754   /* open remote file */
 755
 756   memset(outbuf,0,smb_size);
 757   set_message(outbuf,3,2 + strlen(finfo.name),True);
 758   CVAL(outbuf,smb_com) = SMBcreate;
 759   SSVAL(outbuf,smb_tid,cnum);
 760   cli_setup_pkt(outbuf);
 761
 762   SSVAL(outbuf,smb_vwv0,finfo.mode);
 763   put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
 764
 765   p = smb_buf(outbuf);
 766   *p++ = 4;
 767   safe_strcpy(p,finfo.name, strlen(finfo.name));
 768
 769   send_smb(Client,outbuf);
 770   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 771
 772   if (CVAL(inbuf,smb_rcls) != 0)
 773     {
 774       DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),
 775                finfo.name));
 776       return 0;
 777     }
 778
 779   *fnum = SVAL(inbuf,smb_vwv0);
 780   return True;
 781 }
 782
 783 /****************************************************************************
 784 Write a file to a share
 785 ***************************************************************************/
 786 static BOOL smbwrite(int fnum, int n, int low, int high, int left,
 787                      char *bufferp, char *inbuf, char *outbuf)
 788 {
 789   /* *must* be called with buffer ready malloc'ed */
 790
 791   memset(outbuf,0,smb_size);
 792   set_message(outbuf,5,n + 3,True);
 793
 794   memcpy(smb_buf(outbuf)+3, bufferp, n);
 795
 796   set_message(outbuf,5,n + 3, False);
 797   CVAL(outbuf,smb_com) = SMBwrite;
 798   SSVAL(outbuf,smb_tid,cnum);
 799   cli_setup_pkt(outbuf);
 800
 801   SSVAL(outbuf,smb_vwv0,fnum);
 802   SSVAL(outbuf,smb_vwv1,n);
 803   SIVAL(outbuf,smb_vwv2,low);
 804   SSVAL(outbuf,smb_vwv4,left);
 805   CVAL(smb_buf(outbuf),0) = 1;
 806   SSVAL(smb_buf(outbuf),1,n);
 807
 808   send_smb(Client,outbuf);
 809   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 810
 811   if (CVAL(inbuf,smb_rcls) != 0)
 812     {
 813       DEBUG(0,("%s writing remote file\n",smb_errstr(inbuf)));
 814       return False;
 815     }
 816
 817   if (n != SVAL(inbuf,smb_vwv0))
 818     {
 819       DEBUG(0,("Error: only wrote %d bytes out of %d\n",
 820                SVAL(inbuf,smb_vwv0), n));
 821       return False;
 822     }
 823
 824   return True;
 825 }
 826
 827 /****************************************************************************
 828 Close a file on a share
 829 ***************************************************************************/
 830 static BOOL smbshut(file_info2 finfo, int fnum, char *inbuf, char *outbuf)
 831 {
 832   /* *must* be called with buffer ready malloc'ed */
 833
 834   memset(outbuf,0,smb_size);
 835   set_message(outbuf,3,0,True);
 836   CVAL(outbuf,smb_com) = SMBclose;
 837   SSVAL(outbuf,smb_tid,cnum);
 838   cli_setup_pkt(outbuf);
 839
 840   SSVAL(outbuf,smb_vwv0,fnum);
 841   put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
 842
 843   DEBUG(3,("Setting date to %s (0x%X)",
 844            asctime(LocalTime(&finfo.mtime)),
 845            finfo.mtime));
 846
 847   send_smb(Client,outbuf);
 848   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 849
 850   if (CVAL(inbuf,smb_rcls) != 0)
 851     {
 852       DEBUG(0,("%s closing remote file %s\n",smb_errstr(inbuf),
 853                finfo.name));
 854       return False;
 855     }
 856
 857   return True;
 858 }
 859
 860 /****************************************************************************
 861 Verify existence of path on share
 862 ***************************************************************************/
 863 static BOOL smbchkpath(char *fname, char *inbuf, char *outbuf)
 864 {
 865   char *p;
 866
 867   memset(outbuf,0,smb_size);
 868   set_message(outbuf,0,4 + strlen(fname),True);
 869   CVAL(outbuf,smb_com) = SMBchkpth;
 870   SSVAL(outbuf,smb_tid,cnum);
 871   cli_setup_pkt(outbuf);
 872
 873   p = smb_buf(outbuf);
 874   *p++ = 4;
 875   safe_strcpy(p,fname, strlen(fname));
 876
 877   send_smb(Client,outbuf);
 878   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 879
 880   DEBUG(5,("smbchkpath: %s\n",smb_errstr(inbuf)));
 881
 882   return(CVAL(inbuf,smb_rcls) == 0);
 883 }
 884
 885 /****************************************************************************
 886 Make a directory on share
 887 ***************************************************************************/
 888 static BOOL smbmkdir(char *fname, char *inbuf, char *outbuf)
 889 {
 890   /* *must* be called with buffer ready malloc'ed */
 891   char *p;
 892
 893   memset(outbuf,0,smb_size);
 894   set_message(outbuf,0,2 + strlen(fname),True);
 895
 896   CVAL(outbuf,smb_com) = SMBmkdir;
 897   SSVAL(outbuf,smb_tid,cnum);
 898   cli_setup_pkt(outbuf);
 899
 900   p = smb_buf(outbuf);
 901   *p++ = 4;
 902   safe_strcpy(p,fname, strlen(fname));
 903
 904   send_smb(Client,outbuf);
 905   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 906
 907   if (CVAL(inbuf,smb_rcls) != 0)
 908     {
 909       DEBUG(0,("%s making remote directory %s\n",
 910                smb_errstr(inbuf),fname));
 911       return(False);
 912     }
 913
 914   return(True);
 915 }
 916
 917 /****************************************************************************
 918 Ensure a remote path exists (make if necessary)
 919 ***************************************************************************/
 920 static BOOL ensurepath(char *fname, char *inbuf, char *outbuf)
 921 {
 922   /* *must* be called with buffer ready malloc'ed */
 923   /* ensures path exists */
 924
 925   char *partpath, *ffname;
 926   char *p=fname, *basehack;
 927
 928   DEBUG(5, ( "Ensurepath called with: %s\n", fname));
 929
 930   partpath = string_create_s(strlen(fname));
 931   ffname = string_create_s(strlen(fname));
 932
 933   if ((partpath == NULL) || (ffname == NULL)){
 934
 935     DEBUG(0, ("Out of memory in ensurepath: %s\n", fname));
 936     return(False);
 937
 938   }
 939
 940   *partpath = 0;
 941
 942   /* fname copied to ffname so can strtok */
 943
 944   safe_strcpy(ffname, fname, strlen(fname));
 945
 946   /* do a `basename' on ffname, so don't try and make file name directory */
 947   if ((basehack=strrchr(ffname, '\\')) == NULL)
 948     return True;
 949   else
 950     *basehack='\0';
 951
 952   p=strtok(ffname, "\\");
 953
 954   while (p)
 955     {
 956       safe_strcat(partpath, p, strlen(fname) + 1);
 957
 958       if (!smbchkpath(partpath, inbuf, outbuf)) {
 959         if (!smbmkdir(partpath, inbuf, outbuf))
 960           {
 961             DEBUG(0, ("Error mkdirhiering\n"));
 962             return False;
 963           }
 964         else
 965           DEBUG(3, ("mkdirhiering %s\n", partpath));
 966
 967       }
 968
 969       safe_strcat(partpath, "\\", strlen(fname) + 1);
 970       p = strtok(NULL,"/\\");
 971     }
 972
 973     return True;
 974 }
 975
 976 int padit(char *buf, int bufsize, int padsize)
 977 {
 978   int berr= 0;
 979   int bytestowrite;
 980
 981   DEBUG(5, ("Padding with %d zeros\n", padsize));
 982   memset(buf, 0, bufsize);
 983   while( !berr && padsize > 0 ) {
 984     bytestowrite= MIN(bufsize, padsize);
 985     berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite;
 986     padsize -= bytestowrite;
 987   }
 988
 989   return berr;
 990 }
 991
 992 /*
 993  * smbclient functions
 994  */
 995 /****************************************************************************
 996 append one remote file to the tar file
 997 ***************************************************************************/
 998 static void do_atar(char *rname,char *lname,file_info *finfo1)
 999 {
1000   int fnum;
1001   uint32 nread=0;
1002   char *p, ftype;
1003   char *inbuf,*outbuf;
1004   file_info2 finfo;
1005   BOOL close_done = False;
1006   BOOL shallitime=True;
1007   BOOL ignore_close_error = False;
1008   char *dataptr=NULL;
1009   int datalen=0;
1010
1011   struct timeval tp_start;
1012   GetTimeOfDay(&tp_start);
1013
1014   ftype = '0'; /* An ordinary file ... */
1015
1016   if (finfo1) {
1017     finfo.size  = finfo1 -> size;
1018     finfo.mode  = finfo1 -> mode;
1019     finfo.uid   = finfo1 -> uid;
1020     finfo.gid   = finfo1 -> gid;
1021     finfo.mtime = finfo1 -> mtime;
1022     finfo.atime = finfo1 -> atime;
1023     finfo.ctime = finfo1 -> ctime;
1024   }
1025   else {
1026     finfo.size  = def_finfo.size;
1027     finfo.mode  = def_finfo.mode;
1028     finfo.uid   = def_finfo.uid;
1029     finfo.gid   = def_finfo.gid;
1030     finfo.mtime = def_finfo.mtime;
1031     finfo.atime = def_finfo.atime;
1032     finfo.ctime = def_finfo.ctime;
1033   }
1034
1035
1036   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1037   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1038
1039   if (!inbuf || !outbuf)
1040     {
1041       DEBUG(0,("out of memory\n"));
1042       return;
1043     }
1044
1045   memset(outbuf,0,smb_size);
1046   set_message(outbuf,15,1 + strlen(rname),True);
1047
1048   CVAL(outbuf,smb_com) = SMBopenX;
1049   SSVAL(outbuf,smb_tid,cnum);
1050   cli_setup_pkt(outbuf);
1051
1052   SSVAL(outbuf,smb_vwv0,0xFF);
1053   SSVAL(outbuf,smb_vwv2,1);
1054   SSVAL(outbuf,smb_vwv3,(DENY_NONE<<4));
1055   SSVAL(outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
1056   SSVAL(outbuf,smb_vwv5,aSYSTEM | aHIDDEN);
1057   SSVAL(outbuf,smb_vwv8,1);
1058
1059   p = smb_buf(outbuf);
1060   safe_strcpy(p, rname, strlen(rname));
1061   p = skip_string(p,1);
1062
1063   dos_clean_name(rname);
1064
1065   /* do a chained openX with a readX? */
1066   if (finfo.size > 0)
1067     {
1068       SSVAL(outbuf,smb_vwv0,SMBreadX);
1069       SSVAL(outbuf,smb_vwv1,PTR_DIFF(p,outbuf) - 4);
1070       memset(p,0,200);
1071       p -= smb_wct;
1072       SSVAL(p,smb_wct,10);
1073       SSVAL(p,smb_vwv0,0xFF);
1074       SSVAL(p,smb_vwv5,MIN(max_xmit-500,finfo.size));
1075       SSVAL(p,smb_vwv9,MIN(0xFFFF,finfo.size));
1076       smb_setlen(outbuf,smb_len(outbuf)+11*2+1);
1077     }
1078
1079   send_smb(Client,outbuf);
1080   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
1081
1082   if (CVAL(inbuf,smb_rcls) != 0)
1083     {
1084       if (CVAL(inbuf,smb_rcls) == ERRSRV &&
1085           SVAL(inbuf,smb_err) == ERRnoresource &&
1086           cli_reopen_connection(inbuf,outbuf))
1087         {
1088           do_atar(rname,lname,finfo1);
1089           free(inbuf);free(outbuf);
1090           return;
1091         }
1092
1093       DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),rname));
1094       free(inbuf);free(outbuf);
1095       return;
1096     }
1097
1098   finfo.name = string_create_s(strlen(rname));
1099   if (finfo.name == NULL) {
1100
1101     DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n"));
1102     free(inbuf); free(outbuf);
1103     return;
1104
1105   }
1106
1107   safe_strcpy(finfo.name,rname, strlen(rname));
1108   if (!finfo1)
1109     {
1110       finfo.mode = SVAL(inbuf,smb_vwv3);
1111       finfo.size = IVAL(inbuf,smb_vwv4);
1112       finfo.mtime = make_unix_date3(inbuf+smb_vwv6);
1113       finfo.atime = finfo.ctime = finfo.mtime;
1114     }
1115
1116   DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
1117
1118   fnum = SVAL(inbuf,smb_vwv2);
1119
1120   if (tar_inc && !(finfo.mode & aARCH))
1121     {
1122       DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name));
1123       shallitime=0;
1124     }
1125   else if (!tar_system && (finfo.mode & aSYSTEM))
1126     {
1127       DEBUG(4, ("skipping %s - system bit is set\n", finfo.name));
1128       shallitime=0;
1129     }
1130   else if (!tar_hidden && (finfo.mode & aHIDDEN))
1131     {
1132       DEBUG(4, ("skipping %s - hidden bit is set\n", finfo.name));
1133       shallitime=0;
1134     }
1135   else
1136     {
1137       if (SVAL(inbuf,smb_vwv0) == SMBreadX)
1138         {
1139           p = (inbuf+4+SVAL(inbuf,smb_vwv1)) - smb_wct;
1140           datalen = SVAL(p,smb_vwv5);
1141           dataptr = inbuf + 4 + SVAL(p,smb_vwv6);
1142         }
1143       else
1144         {
1145           dataptr = NULL;
1146           datalen = 0;
1147         }
1148
1149       DEBUG(3,("getting file %s of size %d bytes as a tar file %s",
1150                finfo.name,
1151                finfo.size,
1152                lname));
1153
1154       /* write a tar header, don't bother with mode - just set to 100644 */
1155       writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0", ftype);
1156
1157       while (nread < finfo.size && !close_done)
1158         {
1159           int method = -1;
1160           static BOOL can_chain_close=True;
1161
1162           p=NULL;
1163
1164           DEBUG(3,("nread=%d\n",nread));
1165
1166           /* 3 possible read types. readbraw if a large block is required.
1167              readX + close if not much left and read if neither is supported */
1168
1169           /* we might have already read some data from a chained readX */
1170           if (dataptr && datalen>0)
1171             method=3;
1172
1173           /* if we can finish now then readX+close */
1174           if (method<0 && can_chain_close && (Protocol >= PROTOCOL_LANMAN1) &&
1175               ((finfo.size - nread) <
1176                (max_xmit - (2*smb_size + 13*SIZEOFWORD + 300))))
1177             method = 0;
1178
1179           /* if we support readraw then use that */
1180           if (method<0 && readbraw_supported)
1181             method = 1;
1182
1183           /* if we can then use readX */
1184           if (method<0 && (Protocol >= PROTOCOL_LANMAN1))
1185             method = 2;
1186
1187
1188           switch (method)
1189             {
1190               /* use readX */
1191             case 0:
1192             case 2:
1193               if (method == 0)
1194                 close_done = True;
1195
1196               /* use readX + close */
1197               memset(outbuf,0,smb_size);
1198               set_message(outbuf,10,0,True);
1199               CVAL(outbuf,smb_com) = SMBreadX;
1200               SSVAL(outbuf,smb_tid,cnum);
1201               cli_setup_pkt(outbuf);
1202
1203               if (close_done)
1204                 {
1205                   CVAL(outbuf,smb_vwv0) = SMBclose;
1206                   SSVAL(outbuf,smb_vwv1,PTR_DIFF(smb_buf(outbuf),outbuf) - 4);
1207                 }
1208               else
1209                 CVAL(outbuf,smb_vwv0) = 0xFF;
1210
1211
1212               SSVAL(outbuf,smb_vwv2,fnum);
1213               SIVAL(outbuf,smb_vwv3,nread);
1214               SSVAL(outbuf,smb_vwv5,MIN(max_xmit-200,finfo.size - nread));
1215               SSVAL(outbuf,smb_vwv6,0);
1216               SIVAL(outbuf,smb_vwv7,0);
1217               SSVAL(outbuf,smb_vwv9,MIN(0xFFFF,finfo.size-nread));
1218
1219               if (close_done)
1220                 {
1221                   p = smb_buf(outbuf);
1222                   memset(p,0,9);
1223
1224                   CVAL(p,0) = 3;
1225                   SSVAL(p,1,fnum);
1226                   SIVALS(p,3,-1);
1227
1228                   /* now set the total packet length */
1229                   smb_setlen(outbuf,smb_len(outbuf)+9);
1230                 }
1231
1232               send_smb(Client,outbuf);
1233               client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
1234
1235               if (CVAL(inbuf,smb_rcls) != 0)
1236                 {
1237                   DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
1238                   break;
1239                 }
1240
1241               if (close_done &&
1242                   SVAL(inbuf,smb_vwv0) != SMBclose)
1243                 {
1244                   /* NOTE: WfWg sometimes just ignores the chained
1245                      command! This seems to break the spec? */
1246                   DEBUG(3,("Rejected chained close?\n"));
1247                   close_done = False;
1248                   can_chain_close = False;
1249                   ignore_close_error = True;
1250                 }
1251
1252               datalen = SVAL(inbuf,smb_vwv5);
1253               dataptr = inbuf + 4 + SVAL(inbuf,smb_vwv6);
1254               break;
1255
1256
1257               /* use readbraw */
1258             case 1:
1259               {
1260                 static int readbraw_size = 0xFFFF;
1261
1262                 extern int Client;
1263                 memset(outbuf,0,smb_size);
1264                 set_message(outbuf,8,0,True);
1265                 CVAL(outbuf,smb_com) = SMBreadbraw;
1266                 SSVAL(outbuf,smb_tid,cnum);
1267                 cli_setup_pkt(outbuf);
1268                 SSVAL(outbuf,smb_vwv0,fnum);
1269                 SIVAL(outbuf,smb_vwv1,nread);
1270                 SSVAL(outbuf,smb_vwv3,MIN(finfo.size-nread,readbraw_size));
1271                 SSVAL(outbuf,smb_vwv4,0);
1272                 SIVALS(outbuf,smb_vwv5,-1);
1273                 send_smb(Client,outbuf);
1274
1275                 /* Now read the raw data into the buffer and write it */
1276                 if(read_smb_length(Client,inbuf,0) == -1) {
1277                   DEBUG(0,("Failed to read length in readbraw\n"));
1278                   exit(1);
1279                 }
1280
1281                 /* Even though this is not an smb message, smb_len
1282                    returns the generic length of an smb message */
1283                 datalen = smb_len(inbuf);
1284
1285                 if (datalen == 0)
1286                   {
1287                     /* we got a readbraw error */
1288                     DEBUG(4,("readbraw error - reducing size\n"));
1289                     readbraw_size = (readbraw_size * 9) / 10;
1290
1291                     if (readbraw_size < max_xmit)
1292                       {
1293                         DEBUG(0,("disabling readbraw\n"));
1294                         readbraw_supported = False;
1295                       }
1296
1297                     dataptr=NULL;
1298                     continue;
1299                   }
1300
1301                 if(read_data(Client,inbuf,datalen) != datalen) {
1302                   DEBUG(0,("Failed to read data in readbraw\n"));
1303                   exit(1);
1304                 }
1305                 dataptr = inbuf;
1306               }
1307               break;
1308
1309             case 3:
1310               /* we've already read some data with a chained readX */
1311               break;
1312
1313             default:
1314               /* use plain read */
1315               memset(outbuf,0,smb_size);
1316               set_message(outbuf,5,0,True);
1317               CVAL(outbuf,smb_com) = SMBread;
1318               SSVAL(outbuf,smb_tid,cnum);
1319               cli_setup_pkt(outbuf);
1320
1321               SSVAL(outbuf,smb_vwv0,fnum);
1322               SSVAL(outbuf,smb_vwv1,MIN(max_xmit-200,finfo.size - nread));
1323               SIVAL(outbuf,smb_vwv2,nread);
1324               SSVAL(outbuf,smb_vwv4,finfo.size - nread);
1325
1326               send_smb(Client,outbuf);
1327               client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
1328
1329               if (CVAL(inbuf,smb_rcls) != 0)
1330                 {
1331                   DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
1332                   break;
1333                 }
1334
1335               datalen = SVAL(inbuf,smb_vwv0);
1336               dataptr = smb_buf(inbuf) + 3;
1337               break;
1338             }
1339
1340
1341           /* add received bits of file to buffer - dotarbuf will
1342            * write out in 512 byte intervals */
1343           if (dotarbuf(tarhandle,dataptr,datalen) != datalen)
1344             {
1345               DEBUG(0,("Error writing to tar file - %s\n", strerror(errno)));
1346               break;
1347             }
1348
1349           nread += datalen;
1350           if (datalen == 0)
1351             {
1352               DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
1353               break;
1354             }
1355
1356           dataptr=NULL;
1357           datalen=0;
1358         }
1359
1360        /* pad tar file with zero's if we couldn't get entire file */
1361        if (nread < finfo.size)
1362         {
1363           DEBUG(0, ("Didn't get entire file. size=%d, nread=%d\n", finfo.size, nread));
1364           if (padit(inbuf, BUFFER_SIZE, finfo.size - nread))
1365               DEBUG(0,("Error writing tar file - %s\n", strerror(errno)));
1366         }
1367
1368       /* round tar file to nearest block */
1369       if (finfo.size % TBLOCK)
1370         dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));
1371
1372       ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
1373       ntarf++;
1374     }
1375
1376   if (!close_done)
1377     {
1378       memset(outbuf,0,smb_size);
1379       set_message(outbuf,3,0,True);
1380       CVAL(outbuf,smb_com) = SMBclose;
1381       SSVAL(outbuf,smb_tid,cnum);
1382       cli_setup_pkt(outbuf);
1383
1384       SSVAL(outbuf,smb_vwv0,fnum);
1385       SIVALS(outbuf,smb_vwv1,-1);
1386
1387       send_smb(Client,outbuf);
1388       client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
1389
1390       if (!ignore_close_error && CVAL(inbuf,smb_rcls) != 0)
1391         {
1392           DEBUG(0,("Error %s closing remote file\n",smb_errstr(inbuf)));
1393           free(inbuf);free(outbuf);
1394           return;
1395         }
1396     }
1397
1398   if (shallitime)
1399     {
1400       struct timeval tp_end;
1401       int this_time;
1402
1403       /* if shallitime is true then we didn't skip */
1404       if (tar_reset) (void) do_setrattr(finfo.name, aARCH, ATTRRESET);
1405
1406       GetTimeOfDay(&tp_end);
1407       this_time =
1408         (tp_end.tv_sec - tp_start.tv_sec)*1000 +
1409           (tp_end.tv_usec - tp_start.tv_usec)/1000;
1410       get_total_time_ms += this_time;
1411       get_total_size += finfo.size;
1412
1413       /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
1414       DEBUG(3,("(%g kb/s) (average %g kb/s)\n",
1415                finfo.size / MAX(0.001, (1.024*this_time)),
1416                get_total_size / MAX(0.001, (1.024*get_total_time_ms))));
1417       if (tar_noisy)
1418         {
1419           printf("%10d (%7.1f kb/s) %s\n",
1420                finfo.size, finfo.size / MAX(0.001, (1.024*this_time)),
1421                finfo.name);
1422         }
1423
1424     }
1425
1426   free(inbuf);free(outbuf);
1427 }
1428
1429 /****************************************************************************
1430 Append single file to tar file (or not)
1431 ***************************************************************************/
1432 static void do_tar(file_info *finfo)
1433 {
1434   pstring rname;
1435
1436   if (strequal(finfo->name,".."))
1437     return;
1438
1439   /* Is it on the exclude list ? */
1440   if (!tar_excl && clipn) {
1441     pstring exclaim;
1442
1443     DEBUG(5, ("Excl: strlen(cur_dir) = %i\n", strlen(cur_dir)));
1444
1445     safe_strcpy(exclaim, cur_dir, sizeof(pstring));
1446     *(exclaim+strlen(exclaim)-1)='\0';
1447
1448     safe_strcat(exclaim, "\\", sizeof(pstring));
1449     safe_strcat(exclaim, finfo->name, sizeof(exclaim));
1450
1451     DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));
1452
1453     if ((!tar_re_search && clipfind(cliplist, clipn, exclaim)) ||
1454 #ifdef HAVE_REGEX_H
1455         (tar_re_search && !regexec(preg, exclaim, 0, NULL, 0))) {
1456 #else
1457         (tar_re_search && mask_match(exclaim, cliplist[0], True, False))) {
1458 #endif
1459       DEBUG(3,("Skipping file %s\n", exclaim));
1460       return;
1461     }
1462   }
1463
1464   if (finfo->mode & aDIR)
1465     {
1466       pstring saved_curdir;
1467       pstring mtar_mask;
1468       char *inbuf,*outbuf;
1469
1470       inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1471       outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1472
1473       if (!inbuf || !outbuf)
1474         {
1475           DEBUG(0,("out of memory\n"));
1476           return;
1477         }
1478
1479       safe_strcpy(saved_curdir, cur_dir, sizeof(saved_curdir));
1480
1481       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));
1482
1483       safe_strcat(cur_dir,finfo->name, sizeof(cur_dir));
1484       safe_strcat(cur_dir,"\\", sizeof(cur_dir));
1485
1486       DEBUG(5, ("Writing a dir, Name = %s\n", cur_dir));
1487
1488       /* write a tar directory, don't bother with mode - just set it to
1489        * 40755 */
1490       writetarheader(tarhandle, cur_dir, 0, finfo->mtime, "040755 \0", '5');
1491       if (tar_noisy) {
1492
1493           printf("                directory %s\n", cur_dir);
1494
1495       }
1496       ntarf++;  /* Make sure we have a file on there */
1497       safe_strcpy(mtar_mask,cur_dir, sizeof(pstring));
1498       safe_strcat(mtar_mask,"*", sizeof(pstring));
1499       /*      do_dir((char *)inbuf,(char *)outbuf,mtar_mask,attribute,do_tar,recurse,True); */
1500       safe_strcpy(cur_dir,saved_curdir, sizeof(pstring));
1501       free(inbuf);free(outbuf);
1502     }
1503   else
1504     {
1505       safe_strcpy(rname,cur_dir, sizeof(pstring));
1506       safe_strcat(rname,finfo->name, sizeof(pstring));
1507       do_atar(rname,finfo->name,finfo);
1508     }
1509 }
1510
1511 /****************************************************************************
1512 Convert from UNIX to DOS file names
1513 ***************************************************************************/
1514 static void unfixtarname(char *tptr, char *fp, int l, BOOL first)
1515 {
1516   /* remove '.' from start of file name, convert from unix /'s to
1517    * dos \'s in path. Kill any absolute path names. But only if first!
1518    */
1519
1520   DEBUG(5, ("firstb=%X, secondb=%X, len=%i\n", tptr, fp, l));
1521
1522   if (first) {
1523     if (*fp == '.') {
1524       fp++;
1525       l--;
1526     }
1527     if (*fp == '\\' || *fp == '/') {
1528       fp++;
1529       l--;
1530     }
1531   }
1532
1533   while (l > 0) {
1534     int skip;
1535     if(( skip = skip_multibyte_char( *fp )) != 0) {
1536       if (skip == 2) {
1537         *tptr++ = *fp++;
1538         *tptr++ = *fp++;
1539         l -= 2;
1540       } else if (skip == 1) {
1541         *tptr++ = *fp++;
1542         l--;
1543       }
1544     } else if (*fp == '/') {
1545       *tptr++ = '\\';
1546       fp++;
1547       l--;
1548     } else {
1549       *tptr++ = *fp++;
1550       l--;
1551     }
1552   }
1553 }
1554
1555 #if 0 /* Removed to get around gcc 'defined but not used' error. */
1556
1557 /****************************************************************************
1558 Move to the next block in the buffer, which may mean read in another set of
1559 blocks.
1560 ****************************************************************************/
1561 static int next_block(char *ltarbuf, char *bufferp, int bufsiz)
1562 {
1563   int bufread, total = 0;
1564
1565   if (bufferp >= (ltarbuf + bufsiz)) {
1566
1567     for (bufread = read(tarhandle, ltarbuf, bufsiz); total < bufsiz; total += bufread) {
1568
1569       if (bufread <= 0) { /* An error, return false */
1570         return (total > 0 ? -2 : bufread);
1571       }
1572
1573     }
1574
1575     bufferp = ltarbuf;
1576
1577   }
1578   else {
1579
1580     bufferp += TBLOCK;
1581
1582   }
1583
1584   return(0);
1585
1586 }
1587
1588 static int skip_file(int skip)
1589 {
1590
1591   return(0);
1592 }
1593
1594 static int get_file(file_info2 finfo)
1595 {
1596
1597   return(0);
1598
1599 }
1600
1601 static int get_dir(file_info2 finfo)
1602 {
1603
1604   return(0);
1605
1606 }
1607
1608 static char * get_longfilename(file_info2 finfo)
1609 {
1610
1611   return(NULL);
1612
1613 }
1614
1615 static char * bufferp;
1616
1617 static void do_tarput2(void)
1618 {
1619   file_info2 finfo, *finfo2;
1620   struct timeval tp_start;
1621   char *inbuf, *outbuf, *longfilename = NULL;
1622   int skip = False;
1623
1624   GetTimeOfDay(&tp_start);
1625
1626   bufferp = tarbuf + tbufsiz;  /* init this to force first read */
1627
1628   if (push_dir(&dir_stack, &finfo)) {
1629
1630     finfo2 = pop_dir(&dir_stack);
1631     inbuf = top_dir_name(&dir_stack); /* FIXME */
1632     if (sub_dir(inbuf, finfo2 -> name)){
1633
1634       DEBUG(0, (""));
1635
1636     }
1637   }
1638
1639   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1640   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1641
1642   if (!inbuf || !outbuf) {
1643
1644     DEBUG(0, ("Out of memory during allocate of inbuf and outbuf!\n"));
1645     return;
1646
1647   }
1648
1649   if (next_block(tarbuf, bufferp, tbufsiz) <= 0) {
1650
1651     DEBUG(0, ("Empty file or short tar file: %s\n", strerror(errno)));
1652
1653   }
1654
1655   /* Now read through those files ... */
1656
1657   while (True) {
1658
1659     switch (readtarheader((union hblock *) bufferp, &finfo, cur_dir)) {
1660
1661     case -2:    /* Hmm, not good, but not fatal */
1662       DEBUG(0, ("Skipping %s...\n", finfo.name));
1663       if ((next_block(tarbuf, bufferp, tbufsiz) <= 0) &&
1664           !skip_file(finfo.size)) {
1665
1666         DEBUG(0, ("Short file, bailing out...\n"));
1667         free(inbuf); free(outbuf);
1668         continue;
1669
1670       }
1671
1672       break;
1673
1674     case -1:
1675       DEBUG(0, ("abandoning restore, -1 from read tar header\n"));
1676       free(inbuf); free(outbuf);
1677       return;
1678
1679     case 0: /* chksum is zero - looks like an EOF */
1680       DEBUG(0, ("total of %d tar files restored to share\n", ntarf));
1681       free(inbuf); free(outbuf);
1682       return;        /* Hmmm, bad here ... */
1683
1684     default:
1685       break;
1686
1687     }
1688
1689     /* Now, do we have a long file name? */
1690
1691     if (longfilename != NULL) {
1692       if (strlen(longfilename) < sizeof(finfo.name)) { /* if we have space */
1693
1694         strncpy(finfo.name, longfilename, sizeof(finfo.name) - 1);
1695         free(longfilename);
1696         longfilename = NULL;
1697
1698       }
1699       else {
1700
1701         DEBUG(0, ("filename: %s too long, skipping\n", strlen(longfilename)));
1702         skip = True;
1703
1704       }
1705     }
1706
1707     /* Well, now we have a header, process the file ... */
1708
1709     /* Should we skip the file?                         */
1710
1711     if (skip) {
1712
1713       skip_file(finfo.size);
1714       continue;
1715
1716     }
1717
1718     /* We only get this far if we should process the file */
1719
1720     switch (((union hblock *)bufferp) -> dbuf.linkflag) {
1721
1722     case '0':  /* Should use symbolic names--FIXME */
1723       get_file(finfo);
1724       break;
1725
1726     case '5':
1727       get_dir(finfo);
1728       break;
1729
1730     case 'L':
1731       longfilename = get_longfilename(finfo);
1732       break;
1733
1734     default:
1735       skip_file(finfo.size);  /* Don't handle these yet */
1736       break;
1737
1738     }
1739
1740   }
1741
1742
1743 }
1744 #endif /* Removed to get around gcc 'defined but not used' error. */
1745
1746 static void do_tarput()
1747 {
1748   file_info2 finfo;
1749   int nread=0, bufread;
1750   char *inbuf,*outbuf, *longname = NULL;
1751   int fsize=0;
1752   int fnum;
1753   struct timeval tp_start;
1754   BOOL tskip=False;       /* We'll take each file as it comes */
1755
1756   finfo.name = NULL;      /* No name in here ... */
1757
1758   GetTimeOfDay(&tp_start);
1759
1760   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1761   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1762
1763   if (!inbuf || !outbuf)
1764     {
1765       DEBUG(0,("out of memory\n"));
1766       return;
1767     }
1768
1769   /*
1770    * Must read in tbufsiz dollops
1771    */
1772
1773   /* These should be the only reads in clitar.c */
1774   while ((bufread=read(tarhandle, tarbuf, tbufsiz))>0) {
1775     char *buffer_p, *endofbuffer;
1776     int chunk;
1777
1778     /* Code to handle a short read.
1779      * We always need a TBLOCK full of stuff
1780      */
1781     if (bufread % TBLOCK) {
1782       int lchunk=TBLOCK-(bufread % TBLOCK);
1783       int lread;
1784
1785       /* It's a shorty - a short read that is */
1786       DEBUG(3, ("Short read, read %d so far (need %d)\n", bufread, lchunk));
1787
1788       while ((lread=read(tarhandle, tarbuf+bufread, lchunk))>0) {
1789         bufread+=lread;
1790         if (!(lchunk-=lread)) break;
1791       }
1792
1793       /* If we've reached EOF then that must be a short file */
1794       if (lread<=0) break;
1795     }
1796
1797     buffer_p=tarbuf;
1798     endofbuffer=tarbuf+bufread;
1799
1800     if (tskip) {
1801       if (fsize<bufread) {
1802         tskip=False;
1803         buffer_p+=fsize;
1804         fsize=0;
1805       } else {
1806         if (fsize==bufread) tskip=False;
1807         fsize-=bufread;
1808         continue;
1809       }
1810     }
1811
1812     do {
1813       if (!fsize)
1814         {
1815           int next_header = 1;  /* Want at least one header */
1816           while (next_header)
1817             {
1818             if (buffer_p >= endofbuffer) {
1819
1820               bufread = read(tarhandle, tarbuf, tbufsiz);
1821               buffer_p = tarbuf;
1822
1823             }
1824             next_header = 0;    /* Don't want the next one ... */
1825
1826             if (finfo.name != NULL) { /* Free the space */
1827
1828               free(finfo.name);
1829               finfo.name = NULL;
1830
1831             }
1832             DEBUG(5, ("Tarbuf=%X, buffer=%X, endofbuf=%X\n", tarbuf, buffer_p, endofbuffer));
1833             switch (readtarheader((union hblock *) buffer_p, &finfo, cur_dir))
1834               {
1835               case -2:             /* something dodgy but not fatal about this */
1836                 DEBUG(0, ("skipping %s...\n", finfo.name));
1837                 buffer_p+=TBLOCK;   /* header - like a link */
1838                 continue;
1839               case -1:
1840                 DEBUG(0, ("abandoning restore, -1 from readtarheader\n"));
1841                 free(inbuf); free(outbuf);
1842                 return;
1843               case 0: /* chksum is zero - we assume that one all zero
1844                        *header block will do for eof */
1845                 DEBUG(0,
1846                       ("total of %d tar files restored to share\n", ntarf));
1847                 free(inbuf); free(outbuf);
1848                 return;
1849               default:
1850                 break;
1851               }
1852
1853             /* If we have a longname left from the last time through,
1854                copy it into finfo.name and free it.
1855
1856                The size of a pstring is the limiting factor on filenames
1857                and directory names now. The total pathname length must be
1858                less than sizeof(pstring) - 1, which is currently 1023. */
1859
1860             if (longname != NULL) {
1861
1862               free(finfo.name);  /* Free the name in the finfo */
1863               finfo.name = string_create_s(strlen(longname) + 2);
1864               strncpy(finfo.name, longname, strlen(longname) + 1);
1865               DEBUG(5, ("Long name = \"%s\", filename=\"%s\"\n", longname, finfo.name));
1866               free(longname);
1867               longname = NULL;
1868
1869             }
1870
1871             /* Check if a long-link. We do this before the clip checking
1872                because clip-checking should clip on real name - RJS */
1873
1874             if (((union hblock *)buffer_p) -> dbuf.linkflag == 'L') {
1875               int file_len, first = 0; char *cp;
1876
1877               /* Skip this header, but pick up length, get the name and
1878                  fix the name and skip the name. Hmmm, what about end of
1879                  buffer??? */
1880
1881               longname = malloc(finfo.size + strlen(cur_dir) + 1);
1882               if (longname == NULL) {
1883
1884                  DEBUG(0, ("could not allocate buffer of size %d for longname\n",
1885                            finfo.size + strlen(cur_dir) + 1)
1886                       );
1887                  free(inbuf); free(outbuf);
1888                  return;
1889               }
1890
1891
1892               bzero(longname, finfo.size + strlen(cur_dir) +1);
1893
1894               buffer_p += TBLOCK;   /* Skip that longlink header */
1895
1896               /* This needs restructuring ... */
1897
1898               safe_strcpy(longname, cur_dir, strlen(cur_dir) + 1);
1899               cp = longname + strlen(cur_dir);
1900               file_len = finfo.size;
1901
1902               DEBUG(5, ("longname=%0X, cp=%0X, file_len=%i\n", longname, cp, file_len));
1903
1904               while (file_len > 0) {
1905
1906                 if (buffer_p >= endofbuffer) {
1907
1908                   bufread = read(tarhandle, tarbuf, tbufsiz);
1909
1910                   buffer_p = tarbuf;
1911
1912                 }
1913
1914                 unfixtarname(cp, buffer_p, file_len >= TBLOCK?TBLOCK:file_len, first == 0);
1915
1916                 first++;              /* Not the first anymore */
1917                 cp = cp + strlen(cp); /* Move to end of string */
1918                 buffer_p += TBLOCK;
1919                 file_len -= TBLOCK;
1920                 DEBUG(5, ("cp=%0X, file_len=%i\n", cp, file_len));
1921                 next_header = 1;  /* Force read of next header */
1922
1923               }
1924             }
1925           }
1926           tskip=clipn
1927             && ((!tar_re_search && clipfind(cliplist, clipn, finfo.name) ^ tar_excl)
1928 #ifdef HAVE_REGEX_H
1929                 || (tar_re_search && !regexec(preg, finfo.name, 0, NULL, 0)));
1930 #else
1931                 || (tar_re_search && mask_match(finfo.name, cliplist[0], True, False)));
1932 #endif
1933           if (tskip) {
1934             buffer_p+=TBLOCK;
1935             if (finfo.mode & aDIR)
1936               continue;
1937             else if ((fsize=finfo.size) % TBLOCK) {
1938               fsize+=TBLOCK-(fsize%TBLOCK);
1939             }
1940             if (fsize<endofbuffer-buffer_p) {
1941               buffer_p+=fsize;
1942               fsize=0;
1943               continue;
1944             } else {
1945               fsize-=endofbuffer-buffer_p;
1946               break;
1947             }
1948           }
1949
1950           DEBUG(5, ("do_tarput: File is: %s\n", finfo.name));
1951
1952           if (finfo.mode & aDIR)
1953             {
1954
1955               DEBUG(5, ("Creating directory: %s\n", finfo.name));
1956               DEBUG(0, ("restore tar dir  %s of size %d bytes\n",
1957                         finfo.name, finfo.size));
1958
1959               if (!ensurepath(finfo.name, inbuf, outbuf))
1960                 {
1961                   DEBUG(0, ("abandoning restore, problems ensuring path\n"));
1962                   free(inbuf); free(outbuf);
1963                   return;
1964               }
1965               else
1966                 {
1967                   /* Now we update the creation date ... */
1968
1969                   DEBUG(5, ("Updating creation date on %s\n", finfo.name));
1970
1971                   if (!do_setrtime(finfo.name, finfo.mtime, True)) {
1972
1973                     if (tar_real_noisy) {
1974                       DEBUG(0, ("Could not set time on file: %s\n", finfo.name));
1975                     }
1976                     /*return;  - Win 95 does not like setting time on dirs */
1977
1978                   }
1979
1980                   ntarf++;
1981                   buffer_p+=TBLOCK;
1982                   continue;
1983                 }
1984             }
1985
1986           fsize=finfo.size;
1987
1988           if (ensurepath(finfo.name, inbuf, outbuf)
1989               && !smbcreat(finfo, &fnum, inbuf, outbuf))
1990             {
1991               DEBUG(0, ("abandoning restore\n"));
1992               free(inbuf);free(outbuf);
1993               return;
1994             }
1995
1996           DEBUG(0 ,("restore tar file %s of size %d bytes\n",
1997                    finfo.name, finfo.size));
1998
1999           /*          if (!finfo.size) {
2000             if (!smbshut(finfo, fnum, inbuf, outbuf)){
2001               DEBUG(0, ("Error closing remote file of length 0: %s\n", finfo.name));
2002               free(inbuf);free(outbuf);
2003               return;
2004             }
2005             } */
2006
2007           nread=0;
2008           if ((buffer_p+=TBLOCK) >= endofbuffer) break;
2009         } /* if (!fsize) */
2010
2011       /* write out the file in chunk sized chunks - don't
2012        * go past end of buffer though */
2013       chunk=(fsize-nread < endofbuffer - buffer_p)
2014         ? fsize - nread : endofbuffer - buffer_p;
2015
2016       while (chunk > 0) {
2017         int minichunk=MIN(chunk, max_xmit-200);
2018
2019         if (!smbwrite(fnum, /* file descriptor */
2020                       minichunk, /* n */
2021                       nread, /* offset low */
2022                       0, /* offset high - not implemented */
2023                       fsize-nread, /* left - only hint to server */
2024                       buffer_p,
2025                       inbuf,
2026                       outbuf))
2027           {
2028             DEBUG(0, ("Error writing remote file\n"));
2029             free(inbuf); free(outbuf);
2030             return;
2031           }
2032         DEBUG(5, ("chunk writing fname=%s fnum=%d nread=%d minichunk=%d chunk=%d size=%d\n", finfo.name, fnum, nread, minichunk, chunk, fsize));
2033
2034         buffer_p+=minichunk; nread+=minichunk;
2035         chunk-=minichunk;
2036       }
2037
2038       if (nread>=fsize)
2039         {
2040           if (!smbshut(finfo, fnum, inbuf, outbuf))
2041             {
2042               DEBUG(0, ("Error closing remote file\n"));
2043               free(inbuf);free(outbuf);
2044               return;
2045             }
2046           if (fsize % TBLOCK) buffer_p+=TBLOCK - (fsize % TBLOCK);
2047           DEBUG(5, ("buffer_p is now %d (psn=%d)\n",
2048                     (long) buffer_p, (long)(buffer_p - tarbuf)));
2049           ntarf++;
2050           fsize=0;
2051
2052         }
2053     } while (buffer_p < endofbuffer);
2054   }
2055
2056   DEBUG(0, ("premature eof on tar file ?\n"));
2057   DEBUG(0,("total of %d tar files restored to share\n", ntarf));
2058
2059   free(inbuf); free(outbuf);
2060 }
2061
2062 /*
2063  * samba interactive commands
2064  */
2065
2066 /****************************************************************************
2067 Blocksize command
2068 ***************************************************************************/
2069 void cmd_block(char *dum_in, char *dum_out)
2070 {
2071   fstring buf;
2072   int block;
2073
2074   if (!next_token(NULL,buf,NULL))
2075     {
2076       DEBUG(0, ("blocksize <n>\n"));
2077       return;
2078     }
2079
2080   block=atoi(buf);
2081   if (block < 0 || block > 65535)
2082     {
2083       DEBUG(0, ("blocksize out of range"));
2084       return;
2085     }
2086
2087   blocksize=block;
2088   DEBUG(2,("blocksize is now %d\n", blocksize));
2089 }
2090
2091 /****************************************************************************
2092 command to set incremental / reset mode
2093 ***************************************************************************/
2094 void cmd_tarmode(char *dum_in, char *dum_out)
2095 {
2096   fstring buf;
2097
2098   while (next_token(NULL,buf,NULL)) {
2099     if (strequal(buf, "full"))
2100       tar_inc=False;
2101     else if (strequal(buf, "inc"))
2102       tar_inc=True;
2103     else if (strequal(buf, "reset"))
2104       tar_reset=True;
2105     else if (strequal(buf, "noreset"))
2106       tar_reset=False;
2107     else if (strequal(buf, "system"))
2108       tar_system=True;
2109     else if (strequal(buf, "nosystem"))
2110       tar_system=False;
2111     else if (strequal(buf, "hidden"))
2112       tar_hidden=True;
2113     else if (strequal(buf, "nohidden"))
2114       tar_hidden=False;
2115     else if (strequal(buf, "verbose") || strequal(buf, "noquiet"))
2116       tar_noisy=True;
2117     else if (strequal(buf, "quiet") || strequal(buf, "noverbose"))
2118       tar_noisy=False;
2119     else DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
2120   }
2121
2122   DEBUG(0, ("tarmode is now %s, %s, %s, %s, %s\n",
2123             tar_inc ? "incremental" : "full",
2124             tar_system ? "system" : "nosystem",
2125             tar_hidden ? "hidden" : "nohidden",
2126             tar_reset ? "reset" : "noreset",
2127             tar_noisy ? "verbose" : "quiet"));
2128
2129 }
2130
2131 /****************************************************************************
2132 Feeble attrib command
2133 ***************************************************************************/
2134 void cmd_setmode(char *dum_in, char *dum_out)
2135 {
2136   char *q;
2137   fstring buf;
2138   pstring fname;
2139   int attra[2];
2140   int direct=1;
2141
2142   attra[0] = attra[1] = 0;
2143
2144   if (!next_token(NULL,buf,NULL))
2145     {
2146       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
2147       return;
2148     }
2149
2150   safe_strcpy(fname, cur_dir, sizeof(pstring));
2151   safe_strcat(fname, buf, sizeof(pstring));
2152
2153   while (next_token(NULL,buf,NULL)) {
2154     q=buf;
2155
2156     while(*q)
2157       switch (*q++) {
2158       case '+': direct=1;
2159         break;
2160       case '-': direct=0;
2161         break;
2162       case 'r': attra[direct]|=aRONLY;
2163         break;
2164       case 'h': attra[direct]|=aHIDDEN;
2165         break;
2166       case 's': attra[direct]|=aSYSTEM;
2167         break;
2168       case 'a': attra[direct]|=aARCH;
2169         break;
2170       default: DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
2171         return;
2172       }
2173   }
2174
2175   if (attra[ATTRSET]==0 && attra[ATTRRESET]==0)
2176     {
2177       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
2178       return;
2179     }
2180
2181   DEBUG(2, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
2182   (void) do_setrattr(fname, attra[ATTRSET], ATTRSET);
2183   (void) do_setrattr(fname, attra[ATTRRESET], ATTRRESET);
2184 }
2185
2186 /****************************************************************************
2187 Principal command for creating / extracting
2188 ***************************************************************************/
2189 void cmd_tar(char *inbuf, char *outbuf)
2190 {
2191   fstring buf;
2192   char **argl;
2193   int argcl;
2194
2195   if (!next_token(NULL,buf,NULL))
2196     {
2197       DEBUG(0,("tar <c|x>[IXbga] <filename>\n"));
2198       return;
2199     }
2200
2201   argl=toktocliplist(&argcl, NULL);
2202   if (!tar_parseargs(argcl, argl, buf, 0))
2203     return;
2204
2205   process_tar(inbuf, outbuf);
2206
2207   free(argl);
2208 }
2209
2210 /****************************************************************************
2211 Command line (option) version
2212 ***************************************************************************/
2213 int process_tar(char *inbuf, char *outbuf)
2214 {
2215   initarbuf();
2216   switch(tar_type) {
2217   case 'x':
2218
2219 #if 0
2220     do_tarput2();
2221 #else
2222     do_tarput();
2223 #endif
2224     free(tarbuf);
2225     close(tarhandle);
2226     break;
2227   case 'r':
2228   case 'c':
2229     if (clipn && tar_excl) {
2230       int i;
2231       pstring tarmac;
2232
2233       for (i=0; i<clipn; i++) {
2234         DEBUG(5,("arg %d = %s\n", i, cliplist[i]));
2235
2236         if (*(cliplist[i]+strlen(cliplist[i])-1)=='\\') {
2237           *(cliplist[i]+strlen(cliplist[i])-1)='\0';
2238         }
2239
2240         if (strrchr(cliplist[i], '\\')) {
2241           pstring saved_dir;
2242
2243           safe_strcpy(saved_dir, cur_dir, sizeof(pstring));
2244
2245           if (*cliplist[i]=='\\') {
2246             safe_strcpy(tarmac, cliplist[i], sizeof(pstring));
2247           } else {
2248             safe_strcpy(tarmac, cur_dir, sizeof(pstring));
2249             safe_strcat(tarmac, cliplist[i], sizeof(pstring));
2250           }
2251           safe_strcpy(cur_dir, tarmac, sizeof(pstring));
2252           *(strrchr(cur_dir, '\\')+1)='\0';
2253
2254           do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse, True);
2255           safe_strcpy(cur_dir,saved_dir, sizeof(pstring));
2256         } else {
2257           safe_strcpy(tarmac, cur_dir, sizeof(pstring));
2258           safe_strcat(tarmac, cliplist[i], sizeof(pstring));
2259           do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse, True);
2260         }
2261       }
2262     } else {
2263       pstring mask;
2264       safe_strcpy(mask,cur_dir, sizeof(pstring));
2265       safe_strcat(mask,"\\*", sizeof(pstring));
2266       do_dir((char *)inbuf,(char *)outbuf,mask,attribute,do_tar,recurse, True);
2267     }
2268
2269     if (ntarf) dotareof(tarhandle);
2270     close(tarhandle);
2271     free(tarbuf);
2272
2273     DEBUG(0, ("tar: dumped %d tar files\n", ntarf));
2274     DEBUG(0, ("Total bytes written: %d\n", ttarf));
2275     break;
2276   }
2277
2278   if (must_free_cliplist) {
2279     int i;
2280     for (i = 0; i < clipn; ++i) {
2281       free(cliplist[i]);
2282     }
2283     free(cliplist);
2284     cliplist = NULL;
2285     clipn = 0;
2286     must_free_cliplist = False;
2287   }
2288
2289   return(0);
2290 }
2291
2292 /****************************************************************************
2293 Find a token (filename) in a clip list
2294 ***************************************************************************/
2295 int clipfind(char **aret, int ret, char *tok)
2296 {
2297   if (aret==NULL) return 0;
2298
2299   /* ignore leading slashes or dots in token */
2300   while(strchr("/\\.", *tok)) tok++;
2301
2302   while(ret--) {
2303     char *pkey=*aret++;
2304
2305     /* ignore leading slashes or dots in list */
2306     while(strchr("/\\.", *pkey)) pkey++;
2307
2308     if (!strslashcmp(pkey, tok)) return 1;
2309   }
2310
2311   return 0;
2312 }
2313
2314 /****************************************************************************
2315 Read list of files to include from the file and initialize cliplist
2316 accordingly.
2317 ***************************************************************************/
2318 static int read_inclusion_file(char *filename)
2319 {
2320   FILE *inclusion = NULL;
2321   char buf[MAXPATHLEN + 1];
2322   char *inclusion_buffer = NULL;
2323   int inclusion_buffer_size = 0;
2324   int inclusion_buffer_sofar = 0;
2325   char *p;
2326   char *tmpstr;
2327   int i;
2328   int error = 0;
2329
2330   clipn = 0;
2331   buf[MAXPATHLEN] = '\0'; /* guarantee null-termination */
2332   if ((inclusion = fopen(filename, "r")) == NULL) {
2333     /* XXX It would be better to include a reason for failure, but without
2334      * autoconf, it's hard to use strerror, sys_errlist, etc.
2335      */
2336     DEBUG(0,("Unable to open inclusion file %s\n", filename));
2337     return 0;
2338   }
2339
2340   while ((! error) && (fgets(buf, sizeof(buf)-1, inclusion))) {
2341     if (inclusion_buffer == NULL) {
2342       inclusion_buffer_size = 1024;
2343       if ((inclusion_buffer = malloc(inclusion_buffer_size)) == NULL) {
2344         DEBUG(0,("failure allocating buffer to read inclusion file\n"));
2345         error = 1;
2346         break;
2347       }
2348     }
2349
2350     if (buf[strlen(buf)-1] == '\n') {
2351       buf[strlen(buf)-1] = '\0';
2352     }
2353
2354     if ((strlen(buf) + 1 + inclusion_buffer_sofar) >= inclusion_buffer_size) {
2355       inclusion_buffer_size *= 2;
2356       inclusion_buffer = Realloc(inclusion_buffer,inclusion_buffer_size);
2357       if (! inclusion_buffer) {
2358         DEBUG(0,("failure enlarging inclusion buffer to %d bytes\n",
2359                  inclusion_buffer_size));
2360         error = 1;
2361         break;
2362       }
2363     }
2364
2365     safe_strcpy(inclusion_buffer + inclusion_buffer_sofar, buf, inclusion_buffer_size - inclusion_buffer_sofar);
2366     inclusion_buffer_sofar += strlen(buf) + 1;
2367     clipn++;
2368   }
2369   fclose(inclusion);
2370
2371   if (! error) {
2372     /* Allocate an array of clipn + 1 char*'s for cliplist */
2373     cliplist = malloc((clipn + 1) * sizeof(char *));
2374     if (cliplist == NULL) {
2375       DEBUG(0,("failure allocating memory for cliplist\n"));
2376       error = 1;
2377     } else {
2378       cliplist[clipn] = NULL;
2379       p = inclusion_buffer;
2380       for (i = 0; (! error) && (i < clipn); i++) {
2381         /* set current item to NULL so array will be null-terminated even if
2382          * malloc fails below. */
2383         cliplist[i] = NULL;
2384         if ((tmpstr = (char *)malloc(strlen(p)+1)) == NULL) {
2385           DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", i));
2386           error = 1;
2387         } else {
2388           unfixtarname(tmpstr, p, strlen(p) + 1, True);
2389           cliplist[i] = tmpstr;
2390           if ((p = strchr(p, '\000')) == NULL) {
2391             DEBUG(0,("INTERNAL ERROR: inclusion_buffer is of unexpected contents.\n"));
2392             abort();
2393           }
2394         }
2395         ++p;
2396       }
2397       must_free_cliplist = True;
2398     }
2399   }
2400
2401   if (inclusion_buffer) {
2402     free(inclusion_buffer);
2403   }
2404   if (error) {
2405     if (cliplist) {
2406       char **pp;
2407       /* We know cliplist is always null-terminated */
2408       for (pp = cliplist; *pp; ++pp) {
2409         free(*pp);
2410       }
2411       free(cliplist);
2412       cliplist = NULL;
2413       must_free_cliplist = False;
2414     }
2415     return 0;
2416   }
2417
2418   /* cliplist and its elements are freed at the end of process_tar. */
2419   return 1;
2420 }
2421
2422 /****************************************************************************
2423 Parse tar arguments. Sets tar_type, tar_excl, etc.
2424 ***************************************************************************/
2425 int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind)
2426 {
2427   char tar_clipfl='\0';
2428
2429   /* Reset back to defaults - could be from interactive version
2430    * reset mode and archive mode left as they are though
2431    */
2432   tar_type='\0';
2433   tar_excl=True;
2434
2435   while (*Optarg)
2436     switch(*Optarg++) {
2437     case 'c':
2438       tar_type='c';
2439       break;
2440     case 'x':
2441       if (tar_type=='c') {
2442         printf("Tar must be followed by only one of c or x.\n");
2443         return 0;
2444       }
2445       tar_type='x';
2446       break;
2447     case 'b':
2448       if (Optind>=argc || !(blocksize=atoi(argv[Optind]))) {
2449         DEBUG(0,("Option b must be followed by valid blocksize\n"));
2450         return 0;
2451       } else {
2452         Optind++;
2453       }
2454       break;
2455     case 'g':
2456       tar_inc=True;
2457       break;
2458     case 'N':
2459       if (Optind>=argc) {
2460         DEBUG(0,("Option N must be followed by valid file name\n"));
2461         return 0;
2462       } else {
2463         struct stat stbuf;
2464         extern time_t newer_than;
2465
2466         if (sys_stat(argv[Optind], &stbuf) == 0) {
2467           newer_than = stbuf.st_mtime;
2468           DEBUG(1,("Getting files newer than %s",
2469                    asctime(LocalTime(&newer_than))));
2470           Optind++;
2471         } else {
2472           DEBUG(0,("Error setting newer-than time\n"));
2473           return 0;
2474         }
2475       }
2476       break;
2477     case 'a':
2478       tar_reset=True;
2479       break;
2480     case 'I':
2481       if (tar_clipfl) {
2482         DEBUG(0,("Only one of I,X,F must be specified\n"));
2483         return 0;
2484       }
2485       tar_clipfl='I';
2486       break;
2487     case 'X':
2488       if (tar_clipfl) {
2489         DEBUG(0,("Only one of I,X,F must be specified\n"));
2490         return 0;
2491       }
2492       tar_clipfl='X';
2493       break;
2494     case 'F':
2495       if (tar_clipfl) {
2496         DEBUG(0,("Only one of I,X,F must be specified\n"));
2497         return 0;
2498       }
2499       tar_clipfl='F';
2500       break;
2501     case 'r':
2502       DEBUG(0, ("tar_re_search set\n"));
2503       tar_re_search = True;
2504       break;
2505     default:
2506       DEBUG(0,("Unknown tar option\n"));
2507       return 0;
2508     }
2509
2510   if (!tar_type) {
2511     printf("Option T must be followed by one of c or x.\n");
2512     return 0;
2513   }
2514
2515   /* tar_excl is true if cliplist lists files to be included.
2516    * Both 'I' and 'F' mean include. */
2517   tar_excl=tar_clipfl!='X';
2518
2519   if (tar_clipfl=='F') {
2520     if (argc-Optind-1 != 1) {
2521       DEBUG(0,("Option F must be followed by exactly one filename.\n"));
2522       return 0;
2523     }
2524     if (! read_inclusion_file(argv[Optind+1])) {
2525       return 0;
2526     }
2527   } else if (Optind+1<argc && !tar_re_search) { /* For backwards compatibility */
2528     char *tmpstr;
2529     char **tmplist;
2530     int clipcount;
2531
2532     cliplist=argv+Optind+1;
2533     clipn=argc-Optind-1;
2534     clipcount = clipn;
2535
2536     if ((tmplist=malloc(clipn*sizeof(char *))) == NULL) {
2537       DEBUG(0, ("Could not allocate space to process cliplist, count = %i\n",
2538                clipn)
2539            );
2540       return 0;
2541     }
2542
2543     for (clipcount = 0; clipcount < clipn; clipcount++) {
2544
2545       DEBUG(5, ("Processing an item, %s\n", cliplist[clipcount]));
2546
2547       if ((tmpstr = (char *)malloc(strlen(cliplist[clipcount])+1)) == NULL) {
2548         DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n",
2549                  clipcount)
2550              );
2551         return 0;
2552       }
2553       unfixtarname(tmpstr, cliplist[clipcount], strlen(cliplist[clipcount]) + 1, True);
2554       tmplist[clipcount] = tmpstr;
2555       DEBUG(5, ("Processed an item, %s\n", tmpstr));
2556
2557       DEBUG(5, ("Cliplist is: %s\n", cliplist[0]));
2558     }
2559     cliplist = tmplist;
2560     must_free_cliplist = True;
2561   }
2562
2563   if (Optind+1<argc && tar_re_search) {  /* Doing regular expression seaches */
2564 #ifdef HAVE_REGEX_H
2565     int errcode;
2566
2567     if ((preg = (regex_t *)malloc(65536)) == NULL) {
2568
2569       DEBUG(0, ("Could not allocate buffer for regular expression search\n"));
2570       return;
2571
2572     }
2573
2574     if (errcode = regcomp(preg, argv[Optind + 1], REG_EXTENDED)) {
2575       char errstr[1024];
2576       size_t errlen;
2577
2578       errlen = regerror(errcode, preg, errstr, sizeof(errstr) - 1);
2579
2580       DEBUG(0, ("Could not compile pattern buffer for re search: %s\n%s\n", argv[Optind + 1], errstr));
2581       return;
2582
2583     }
2584 #endif
2585
2586     clipn=argc-Optind-1;
2587     cliplist=argv+Optind+1;
2588
2589   }
2590
2591   if (Optind>=argc || !strcmp(argv[Optind], "-")) {
2592     /* Sets tar handle to either 0 or 1, as appropriate */
2593     tarhandle=(tar_type=='c');
2594   } else {
2595     if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY)) == -1)
2596         || (tar_type=='c' && (tarhandle=creat(argv[Optind], 0644)) < 0))
2597       {
2598         DEBUG(0,("Error opening local file %s - %s\n",
2599                  argv[Optind], strerror(errno)));
2600         return(0);
2601       }
2602   }
2603
2604   return 1;
2605 }