source/client/clitar.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Tar Extensions
   5    Copyright (C) Ricky Poulten 1995-1997
   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 2 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, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22
  23 #include "includes.h"
  24 #include "clitar.h"
  25
  26 extern BOOL recurse;
  27
  28 #define SEPARATORS " \t\n\r"
  29 extern int DEBUGLEVEL;
  30 extern int Client;
  31
  32 /* These defines are for the do_setrattr routine, to indicate
  33  * setting and reseting of file attributes in the function call */
  34 #define ATTRSET 1
  35 #define ATTRRESET 0
  36
  37 static int attribute = aDIR | aSYSTEM | aHIDDEN;
  38
  39 #ifndef CLIENT_TIMEOUT
  40 #define CLIENT_TIMEOUT (30*1000)
  41 #endif
  42
  43 static char *tarbuf;
  44 static int tp, ntarf, tbufsiz;
  45 /* Incremental mode */
  46 BOOL tar_inc=False;
  47 /* Reset archive bit */
  48 BOOL tar_reset=False;
  49 /* Include / exclude mode (true=include, false=exclude) */
  50 BOOL tar_excl=True;
  51 char tar_type='\0';
  52 static char **cliplist=NULL;
  53 static int clipn=0;
  54
  55 extern file_info def_finfo;
  56 extern BOOL lowercase;
  57 extern int cnum;
  58 extern BOOL readbraw_supported;
  59 extern int max_xmit;
  60 extern pstring cur_dir;
  61 extern int get_total_time_ms;
  62 extern int get_total_size;
  63 extern int Protocol;
  64
  65 int blocksize=20;
  66 int tarhandle;
  67
  68 static void writetarheader();
  69 static void do_atar();
  70 static void do_tar();
  71 static void oct_it();
  72 static void fixtarname();
  73 static int dotarbuf();
  74 static void dozerobuf();
  75 static void dotareof();
  76 static void initarbuf();
  77 static int do_setrattr();
  78
  79 /* restore functions */
  80 static long readtarheader();
  81 static long unoct();
  82 static void do_tarput();
  83 static void unfixtarname();
  84
  85 /*
  86  * tar specific utitlities
  87  */
  88
  89 /****************************************************************************
  90 Write a tar header to buffer
  91 ****************************************************************************/
  92 static void writetarheader(int f,  char *aname, int size, time_t mtime,
  93                     char *amode)
  94 {
  95   union hblock hb;
  96   int i, chk, l;
  97   char *jp;
  98
  99   memset(hb.dummy, 0, sizeof(hb.dummy));
 100
 101   l=strlen(aname);
 102   if (l >= NAMSIZ)
 103     {
 104       DEBUG(0, ("tar file %s name length exceeds NAMSIZ\n", aname));
 105     }
 106
 107   /* use l + 1 to do the null too */
 108   fixtarname(hb.dbuf.name, aname, (l >= NAMSIZ) ? NAMSIZ : l + 1);
 109
 110   if (lowercase)
 111     strlower(hb.dbuf.name);
 112
 113   /* write out a "standard" tar format header */
 114
 115   hb.dbuf.name[NAMSIZ-1]='\0';
 116   strcpy(hb.dbuf.mode, amode);
 117   oct_it(0L, 8, hb.dbuf.uid);
 118   oct_it(0L, 8, hb.dbuf.gid);
 119   oct_it((long) size, 13, hb.dbuf.size);
 120   oct_it((long) mtime, 13, hb.dbuf.mtime);
 121   memcpy(hb.dbuf.chksum, "        ", sizeof(hb.dbuf.chksum));
 122   hb.dbuf.linkflag='0';
 123   memset(hb.dbuf.linkname, 0, NAMSIZ);
 124
 125   for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;) chk+=(0xFF & *jp++);
 126
 127   oct_it((long) chk, 8, hb.dbuf.chksum);
 128   hb.dbuf.chksum[6] = '\0';
 129
 130   (void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
 131 }
 132
 133 /****************************************************************************
 134 Read a tar header into a hblock structure, and validate
 135 ***************************************************************************/
 136 static long readtarheader(union hblock *hb, file_info *finfo, char *prefix)
 137 {
 138   long chk, fchk;
 139   int i;
 140   char *jp;
 141
 142   /*
 143    * read in a "standard" tar format header - we're not that interested
 144    * in that many fields, though
 145    */
 146
 147   /* check the checksum */
 148   for (chk=0, i=sizeof(hb->dummy), jp=hb->dummy; --i>=0;) chk+=(0xFF & *jp++);
 149
 150   if (chk == 0)
 151     return chk;
 152
 153   /* compensate for blanks in chksum header */
 154   for (i=sizeof(hb->dbuf.chksum), jp=hb->dbuf.chksum; --i>=0;)
 155     chk-=(0xFF & *jp++);
 156
 157   chk += ' ' * sizeof(hb->dbuf.chksum);
 158
 159   fchk=unoct(hb->dbuf.chksum, sizeof(hb->dbuf.chksum));
 160
 161   DEBUG(5, ("checksum totals chk=%d fchk=%d chksum=%s\n",
 162             chk, fchk, hb->dbuf.chksum));
 163
 164   if (fchk != chk)
 165     {
 166       DEBUG(0, ("checksums don't match %d %d\n", fchk, chk));
 167       return -1;
 168     }
 169
 170   strcpy(finfo->name, prefix);
 171
 172   /* use l + 1 to do the null too; do prefix - prefcnt to zap leading slash */
 173   unfixtarname(finfo->name + strlen(prefix), hb->dbuf.name,
 174                strlen(hb->dbuf.name) + 1);
 175
 176 /* can't handle links at present */
 177   if (hb->dbuf.linkflag != '0') {
 178     if (hb->dbuf.linkflag == 0) {
 179       DEBUG(6, ("Warning: NULL link flag (gnu tar archive ?) %s\n",
 180                 finfo->name));
 181     } else {
 182       DEBUG(0, ("this tar file appears to contain some kind of link - ignoring\n"));
 183       return -2;
 184     }
 185   }
 186
 187   if ((unoct(hb->dbuf.mode, sizeof(hb->dbuf.mode)) & S_IFDIR)
 188     || (*(finfo->name+strlen(finfo->name)-1) == '\\'))
 189     {
 190       finfo->mode=aDIR;
 191     }
 192   else
 193     finfo->mode=0; /* we don't care about mode at the moment, we'll
 194                     * just make it a regular file */
 195   /*
 196    * Bug fix by richard@sj.co.uk
 197    *
 198    * REC: restore times correctly (as does tar)
 199    * We only get the modification time of the file; set the creation time
 200    * from the mod. time, and the access time to current time
 201    */
 202   finfo->mtime = finfo->ctime = strtol(hb->dbuf.mtime, NULL, 8);
 203   finfo->atime = time(NULL);
 204   finfo->size = unoct(hb->dbuf.size, sizeof(hb->dbuf.size));
 205
 206   return True;
 207 }
 208
 209 /****************************************************************************
 210 Write out the tar buffer to tape or wherever
 211 ****************************************************************************/
 212 static int dotarbuf(int f, char *b, int n)
 213 {
 214   int fail=1, writ=n;
 215
 216   /* This routine and the next one should be the only ones that do write()s */
 217   if (tp + n >= tbufsiz)
 218     {
 219       int diff;
 220
 221       diff=tbufsiz-tp;
 222       memcpy(tarbuf + tp, b, diff);
 223       fail=fail && (1+write(f, tarbuf, tbufsiz));
 224       n-=diff;
 225       b+=diff;
 226       tp=0;
 227
 228       while (n >= tbufsiz)
 229         {
 230           fail=fail && (1 + write(f, b, tbufsiz));
 231           n-=tbufsiz;
 232           b+=tbufsiz;
 233         }
 234     }
 235   if (n>0) {
 236     memcpy(tarbuf+tp, b, n);
 237     tp+=n;
 238   }
 239
 240   return(fail ? writ : 0);
 241 }
 242
 243 /****************************************************************************
 244 Write a zeros to buffer / tape
 245 ****************************************************************************/
 246 static void dozerobuf(int f, int n)
 247 {
 248   /* short routine just to write out n zeros to buffer -
 249    * used to round files to nearest block
 250    * and to do tar EOFs */
 251
 252   if (n+tp >= tbufsiz)
 253     {
 254       memset(tarbuf+tp, 0, tbufsiz-tp);
 255       write(f, tarbuf, tbufsiz);
 256       memset(tarbuf, 0, (tp+=n-tbufsiz));
 257     }
 258   else
 259     {
 260       memset(tarbuf+tp, 0, n);
 261       tp+=n;
 262     }
 263 }
 264
 265 /****************************************************************************
 266 Malloc tape buffer
 267 ****************************************************************************/
 268 static void initarbuf()
 269 {
 270   /* initialize tar buffer */
 271   tbufsiz=blocksize*TBLOCK;
 272   tarbuf=malloc(tbufsiz);
 273
 274   /* reset tar buffer pointer and tar file counter */
 275   tp=0; ntarf=0;
 276 }
 277
 278 /****************************************************************************
 279 Write two zero blocks at end of file
 280 ****************************************************************************/
 281 static void dotareof(int f)
 282 {
 283   struct stat stbuf;
 284   /* Two zero blocks at end of file, write out full buffer */
 285
 286   (void) dozerobuf(f, TBLOCK);
 287   (void) dozerobuf(f, TBLOCK);
 288
 289   if (fstat(f, &stbuf) == -1)
 290     {
 291       DEBUG(0, ("Couldn't stat file handle\n"));
 292       return;
 293     }
 294
 295   /* Could be a pipe, in which case S_ISREG should fail,
 296    * and we should write out at full size */
 297   if (tp > 0) write(f, tarbuf, S_ISREG(stbuf.st_mode) ? tp : tbufsiz);
 298 }
 299
 300 /****************************************************************************
 301 (Un)mangle DOS pathname, make nonabsolute
 302 ****************************************************************************/
 303 static void fixtarname(char *tptr, char *fp, int l)
 304 {
 305   /* add a '.' to start of file name, convert from ugly dos \'s in path
 306    * to lovely unix /'s :-} */
 307
 308   *tptr++='.';
 309 #ifdef KANJI
 310   while (l > 0) {
 311     if (is_shift_jis (*fp)) {
 312       *tptr++ = *fp++;
 313       *tptr++ = *fp++;
 314       l -= 2;
 315     } else if (is_kana (*fp)) {
 316       *tptr++ = *fp++;
 317       l--;
 318     } else if (*fp == '\\') {
 319       *tptr++ = '/';
 320       fp++;
 321       l--;
 322     } else {
 323       *tptr++ = *fp++;
 324       l--;
 325     }
 326   }
 327 #else
 328   while (l--) { *tptr=(*fp == '\\') ? '/' : *fp; tptr++; fp++; }
 329 #endif
 330 }
 331
 332 /****************************************************************************
 333 Convert from decimal to octal string
 334 ****************************************************************************/
 335 static void oct_it (register long value, register int ndgs, register char *p)
 336 {
 337   /* Converts long to octal string, pads with leading zeros */
 338
 339   /* skip final null, but do final space */
 340   --ndgs;
 341   p[--ndgs] = ' ';
 342
 343   /* Loop does at least one digit */
 344   do {
 345       p[--ndgs] = '0' + (char) (value & 7);
 346       value >>= 3;
 347     }
 348   while (ndgs > 0 && value != 0);
 349
 350   /* Do leading zeros */
 351   while (ndgs > 0)
 352     p[--ndgs] = '0';
 353 }
 354
 355 /****************************************************************************
 356 Convert from octal string to long
 357 ***************************************************************************/
 358 static long unoct(char *p, int ndgs)
 359 {
 360   long value=0;
 361   /* Converts octal string to long, ignoring any non-digit */
 362
 363   while (--ndgs)
 364     {
 365       if (isdigit(*p))
 366         value = (value << 3) | (long) (*p - '0');
 367
 368       p++;
 369     }
 370
 371   return value;
 372 }
 373
 374 /****************************************************************************
 375 Compare two strings in a slash insensitive way
 376 ***************************************************************************/
 377 int strslashcmp(char *s1,char *s2)
 378 {
 379   while(*s1 && *s2 &&
 380         (*s1 == *s2
 381          || tolower(*s1) == tolower(*s2)
 382          || (*s1 == '\\' && *s2=='/')
 383          || (*s1 == '/' && *s2=='\\'))) {
 384           s1++; s2++;
 385   }
 386
 387   return *s1-*s2;
 388 }
 389
 390 /*
 391  * general smb utility functions
 392  */
 393 /****************************************************************************
 394 Set DOS file attributes
 395 ***************************************************************************/
 396 static int do_setrattr(char *fname, int attr, int setit)
 397 {
 398   /*
 399    * First get the existing attribs from existing file
 400    */
 401   char *inbuf,*outbuf;
 402   char *p;
 403   pstring name;
 404   int fattr;
 405
 406   strcpy(name,fname);
 407   strcpy(fname,"\\");
 408   strcat(fname,name);
 409
 410   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
 411   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
 412
 413   if (!inbuf || !outbuf)
 414     {
 415       DEBUG(0,("out of memory\n"));
 416       return False;
 417     }
 418
 419   /* send an smb getatr message */
 420
 421   memset(outbuf,0,smb_size);
 422   set_message(outbuf,0,2 + strlen(fname),True);
 423   CVAL(outbuf,smb_com) = SMBgetatr;
 424   SSVAL(outbuf,smb_tid,cnum);
 425   setup_pkt(outbuf);
 426
 427   p = smb_buf(outbuf);
 428   *p++ = 4;
 429   strcpy(p,fname);
 430   p += (strlen(fname)+1);
 431
 432   *p++ = 4;
 433   *p++ = 0;
 434
 435   send_smb(Client,outbuf);
 436   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 437
 438   if (CVAL(inbuf,smb_rcls) != 0)
 439     DEBUG(5,("getatr: %s\n",smb_errstr(inbuf)));
 440   else
 441     {
 442       DEBUG(5,("\nattr 0x%X  time %d  size %d\n",
 443                (int)CVAL(inbuf,smb_vwv0),
 444                SVAL(inbuf,smb_vwv1),
 445                SVAL(inbuf,smb_vwv3)));
 446     }
 447
 448   fattr=CVAL(inbuf,smb_vwv0);
 449
 450   /* combine found attributes with bits to be set or reset */
 451
 452   attr=setit ? (fattr | attr) : (fattr & ~attr);
 453
 454   /* now try and set attributes by sending smb reset message */
 455
 456   /* clear out buffer and start again */
 457   memset(outbuf,0,smb_size);
 458   set_message(outbuf,8,4 + strlen(fname),True);
 459   CVAL(outbuf,smb_com) = SMBsetatr;
 460   SSVAL(outbuf,smb_tid,cnum);
 461   setup_pkt(outbuf);
 462
 463   SSVAL(outbuf,smb_vwv0,attr);
 464
 465   p = smb_buf(outbuf);
 466   *p++ = 4;
 467   strcpy(p,fname);
 468   p += (strlen(fname)+1);
 469
 470   *p++ = 4;
 471   *p++ = 0;
 472
 473   send_smb(Client,outbuf);
 474   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 475
 476   if (CVAL(inbuf,smb_rcls) != 0)
 477     {
 478       DEBUG(0,("%s setting attributes on file %s\n",
 479             smb_errstr(inbuf), fname));
 480       free(inbuf);free(outbuf);
 481       return(False);
 482     }
 483
 484   free(inbuf);free(outbuf);
 485   return(True);
 486 }
 487
 488 /****************************************************************************
 489 Create a file on a share
 490 ***************************************************************************/
 491 static BOOL smbcreat(file_info finfo, int *fnum, char *inbuf, char *outbuf)
 492 {
 493   char *p;
 494   /* *must* be called with buffer ready malloc'ed */
 495   /* open remote file */
 496
 497   memset(outbuf,0,smb_size);
 498   set_message(outbuf,3,2 + strlen(finfo.name),True);
 499   CVAL(outbuf,smb_com) = SMBcreate;
 500   SSVAL(outbuf,smb_tid,cnum);
 501   setup_pkt(outbuf);
 502
 503   SSVAL(outbuf,smb_vwv0,finfo.mode);
 504   put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
 505
 506   p = smb_buf(outbuf);
 507   *p++ = 4;
 508   strcpy(p,finfo.name);
 509
 510   send_smb(Client,outbuf);
 511   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 512
 513   if (CVAL(inbuf,smb_rcls) != 0)
 514     {
 515       DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),
 516                finfo.name));
 517       return 0;
 518     }
 519
 520   *fnum = SVAL(inbuf,smb_vwv0);
 521   return True;
 522 }
 523
 524 /****************************************************************************
 525 Write a file to a share
 526 ***************************************************************************/
 527 static BOOL smbwrite(int fnum, int n, int low, int high, int left,
 528                      char *bufferp, char *inbuf, char *outbuf)
 529 {
 530   /* *must* be called with buffer ready malloc'ed */
 531
 532   memset(outbuf,0,smb_size);
 533   set_message(outbuf,5,n + 3,True);
 534
 535   memcpy(smb_buf(outbuf)+3, bufferp, n);
 536
 537   set_message(outbuf,5,n + 3, False);
 538   CVAL(outbuf,smb_com) = SMBwrite;
 539   SSVAL(outbuf,smb_tid,cnum);
 540   setup_pkt(outbuf);
 541
 542   SSVAL(outbuf,smb_vwv0,fnum);
 543   SSVAL(outbuf,smb_vwv1,n);
 544   SIVAL(outbuf,smb_vwv2,low);
 545   SSVAL(outbuf,smb_vwv4,left);
 546   CVAL(smb_buf(outbuf),0) = 1;
 547   SSVAL(smb_buf(outbuf),1,n);
 548
 549   send_smb(Client,outbuf);
 550   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 551
 552   if (CVAL(inbuf,smb_rcls) != 0)
 553     {
 554       DEBUG(0,("%s writing remote file\n",smb_errstr(inbuf)));
 555       return False;
 556     }
 557
 558   if (n != SVAL(inbuf,smb_vwv0))
 559     {
 560       DEBUG(0,("Error: only wrote %d bytes out of %d\n",
 561                SVAL(inbuf,smb_vwv0), n));
 562       return False;
 563     }
 564
 565   return True;
 566 }
 567
 568 /****************************************************************************
 569 Close a file on a share
 570 ***************************************************************************/
 571 static BOOL smbshut(file_info finfo, int fnum, char *inbuf, char *outbuf)
 572 {
 573   /* *must* be called with buffer ready malloc'ed */
 574
 575   memset(outbuf,0,smb_size);
 576   set_message(outbuf,3,0,True);
 577   CVAL(outbuf,smb_com) = SMBclose;
 578   SSVAL(outbuf,smb_tid,cnum);
 579   setup_pkt(outbuf);
 580
 581   SSVAL(outbuf,smb_vwv0,fnum);
 582   put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
 583
 584   DEBUG(3,("Setting date to %s (0x%X)",
 585            asctime(LocalTime(&finfo.mtime)),
 586            finfo.mtime));
 587
 588   send_smb(Client,outbuf);
 589   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 590
 591   if (CVAL(inbuf,smb_rcls) != 0)
 592     {
 593       DEBUG(0,("%s closing remote file %s\n",smb_errstr(inbuf),
 594                finfo.name));
 595       return False;
 596     }
 597
 598   return True;
 599 }
 600
 601 /****************************************************************************
 602 Verify existence of path on share
 603 ***************************************************************************/
 604 static BOOL smbchkpath(char *fname, char *inbuf, char *outbuf)
 605 {
 606   char *p;
 607
 608   memset(outbuf,0,smb_size);
 609   set_message(outbuf,0,4 + strlen(fname),True);
 610   CVAL(outbuf,smb_com) = SMBchkpth;
 611   SSVAL(outbuf,smb_tid,cnum);
 612   setup_pkt(outbuf);
 613
 614   p = smb_buf(outbuf);
 615   *p++ = 4;
 616   strcpy(p,fname);
 617
 618   send_smb(Client,outbuf);
 619   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 620
 621   DEBUG(5,("smbchkpath: %s\n",smb_errstr(inbuf)));
 622
 623   return(CVAL(inbuf,smb_rcls) == 0);
 624 }
 625
 626 /****************************************************************************
 627 Make a directory on share
 628 ***************************************************************************/
 629 static BOOL smbmkdir(char *fname, char *inbuf, char *outbuf)
 630 {
 631   /* *must* be called with buffer ready malloc'ed */
 632   char *p;
 633
 634   memset(outbuf,0,smb_size);
 635   set_message(outbuf,0,2 + strlen(fname),True);
 636
 637   CVAL(outbuf,smb_com) = SMBmkdir;
 638   SSVAL(outbuf,smb_tid,cnum);
 639   setup_pkt(outbuf);
 640
 641   p = smb_buf(outbuf);
 642   *p++ = 4;
 643   strcpy(p,fname);
 644
 645   send_smb(Client,outbuf);
 646   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 647
 648   if (CVAL(inbuf,smb_rcls) != 0)
 649     {
 650       DEBUG(0,("%s making remote directory %s\n",
 651                smb_errstr(inbuf),fname));
 652       return(False);
 653     }
 654
 655   return(True);
 656 }
 657
 658 /****************************************************************************
 659 Ensure a remote path exists (make if necessary)
 660 ***************************************************************************/
 661 static BOOL ensurepath(char *fname, char *inbuf, char *outbuf)
 662 {
 663   /* *must* be called with buffer ready malloc'ed */
 664   /* ensures path exists */
 665
 666   pstring partpath, ffname;
 667   char *p=fname, *basehack;
 668
 669   *partpath = 0;
 670
 671   /* fname copied to ffname so can strtok */
 672
 673   strcpy(ffname, fname);
 674
 675   /* do a `basename' on ffname, so don't try and make file name directory */
 676   if ((basehack=strrchr(ffname, '\\')) == NULL)
 677     return True;
 678   else
 679     *basehack='\0';
 680
 681   p=strtok(ffname, "\\");
 682
 683   while (p)
 684     {
 685       strcat(partpath, p);
 686
 687       if (!smbchkpath(partpath, inbuf, outbuf)) {
 688         if (!smbmkdir(partpath, inbuf, outbuf))
 689           {
 690             DEBUG(0, ("Error mkdirhiering\n"));
 691             return False;
 692           }
 693         else
 694           DEBUG(3, ("mkdirhiering %s\n", partpath));
 695
 696       }
 697
 698       strcat(partpath, "\\");
 699       p = strtok(NULL,"/\\");
 700     }
 701
 702     return True;
 703 }
 704
 705 int padit(char *buf, int bufsize, int padsize)
 706 {
 707   int berr= 0;
 708   int bytestowrite;
 709
 710   DEBUG(0, ("Padding with %d zeros\n", padsize));
 711   memset(buf, 0, bufsize);
 712   while( !berr && padsize > 0 ) {
 713     bytestowrite= MIN(bufsize, padsize);
 714     berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite;
 715     padsize -= bytestowrite;
 716   }
 717
 718   return berr;
 719 }
 720
 721 /*
 722  * smbclient functions
 723  */
 724 /****************************************************************************
 725 append one remote file to the tar file
 726 ***************************************************************************/
 727 static void do_atar(char *rname,char *lname,file_info *finfo1)
 728 {
 729   int fnum;
 730   uint32 nread=0;
 731   char *p;
 732   char *inbuf,*outbuf;
 733   file_info finfo;
 734   BOOL close_done = False;
 735   BOOL shallitime=True;
 736   BOOL ignore_close_error = False;
 737   char *dataptr=NULL;
 738   int datalen=0;
 739
 740   struct timeval tp_start;
 741   GetTimeOfDay(&tp_start);
 742
 743   if (finfo1)
 744     finfo = *finfo1;
 745   else
 746     finfo = def_finfo;
 747
 748   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
 749   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
 750
 751   if (!inbuf || !outbuf)
 752     {
 753       DEBUG(0,("out of memory\n"));
 754       return;
 755     }
 756
 757   memset(outbuf,0,smb_size);
 758   set_message(outbuf,15,1 + strlen(rname),True);
 759
 760   CVAL(outbuf,smb_com) = SMBopenX;
 761   SSVAL(outbuf,smb_tid,cnum);
 762   setup_pkt(outbuf);
 763
 764   SSVAL(outbuf,smb_vwv0,0xFF);
 765   SSVAL(outbuf,smb_vwv2,1);
 766   SSVAL(outbuf,smb_vwv3,(DENY_NONE<<4));
 767   SSVAL(outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
 768   SSVAL(outbuf,smb_vwv5,aSYSTEM | aHIDDEN);
 769   SSVAL(outbuf,smb_vwv8,1);
 770
 771   p = smb_buf(outbuf);
 772   strcpy(p,rname);
 773   p = skip_string(p,1);
 774
 775   dos_clean_name(rname);
 776
 777   /* do a chained openX with a readX? */
 778   if (finfo.size > 0)
 779     {
 780       SSVAL(outbuf,smb_vwv0,SMBreadX);
 781       SSVAL(outbuf,smb_vwv1,PTR_DIFF(p,outbuf) - 4);
 782       memset(p,0,200);
 783       p -= smb_wct;
 784       SSVAL(p,smb_wct,10);
 785       SSVAL(p,smb_vwv0,0xFF);
 786       SSVAL(p,smb_vwv5,MIN(max_xmit-500,finfo.size));
 787       SSVAL(p,smb_vwv9,MIN(0xFFFF,finfo.size));
 788       smb_setlen(outbuf,smb_len(outbuf)+11*2+1);
 789     }
 790
 791   send_smb(Client,outbuf);
 792   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 793
 794   if (CVAL(inbuf,smb_rcls) != 0)
 795     {
 796       if (CVAL(inbuf,smb_rcls) == ERRSRV &&
 797           SVAL(inbuf,smb_err) == ERRnoresource &&
 798           reopen_connection(inbuf,outbuf))
 799         {
 800           do_atar(rname,lname,finfo1);
 801           free(inbuf);free(outbuf);
 802           return;
 803         }
 804
 805       DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),rname));
 806       free(inbuf);free(outbuf);
 807       return;
 808     }
 809
 810   strcpy(finfo.name,rname);
 811   if (!finfo1)
 812     {
 813       finfo.mode = SVAL(inbuf,smb_vwv3);
 814       finfo.size = IVAL(inbuf,smb_vwv4);
 815       finfo.mtime = make_unix_date3(inbuf+smb_vwv6);
 816       finfo.atime = finfo.ctime = finfo.mtime;
 817     }
 818
 819   DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
 820
 821   fnum = SVAL(inbuf,smb_vwv2);
 822
 823   if (tar_inc && !(finfo.mode & aARCH))
 824     {
 825       DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name));
 826       shallitime=0;
 827     }
 828   else
 829     {
 830       if (SVAL(inbuf,smb_vwv0) == SMBreadX)
 831         {
 832           p = (inbuf+4+SVAL(inbuf,smb_vwv1)) - smb_wct;
 833           datalen = SVAL(p,smb_vwv5);
 834           dataptr = inbuf + 4 + SVAL(p,smb_vwv6);
 835         }
 836       else
 837         {
 838           dataptr = NULL;
 839           datalen = 0;
 840         }
 841
 842       DEBUG(1,("getting file %s of size %d bytes as a tar file %s",
 843                finfo.name,
 844                finfo.size,
 845                lname));
 846
 847       /* write a tar header, don't bother with mode - just set to 100644 */
 848       writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0");
 849
 850       while (nread < finfo.size && !close_done)
 851         {
 852           int method = -1;
 853           static BOOL can_chain_close=True;
 854
 855           p=NULL;
 856
 857           DEBUG(3,("nread=%d\n",nread));
 858
 859           /* 3 possible read types. readbraw if a large block is required.
 860              readX + close if not much left and read if neither is supported */
 861
 862           /* we might have already read some data from a chained readX */
 863           if (dataptr && datalen>0)
 864             method=3;
 865
 866           /* if we can finish now then readX+close */
 867           if (method<0 && can_chain_close && (Protocol >= PROTOCOL_LANMAN1) &&
 868               ((finfo.size - nread) <
 869                (max_xmit - (2*smb_size + 13*SIZEOFWORD + 300))))
 870             method = 0;
 871
 872           /* if we support readraw then use that */
 873           if (method<0 && readbraw_supported)
 874             method = 1;
 875
 876           /* if we can then use readX */
 877           if (method<0 && (Protocol >= PROTOCOL_LANMAN1))
 878             method = 2;
 879
 880
 881           switch (method)
 882             {
 883               /* use readX */
 884             case 0:
 885             case 2:
 886               if (method == 0)
 887                 close_done = True;
 888
 889               /* use readX + close */
 890               memset(outbuf,0,smb_size);
 891               set_message(outbuf,10,0,True);
 892               CVAL(outbuf,smb_com) = SMBreadX;
 893               SSVAL(outbuf,smb_tid,cnum);
 894               setup_pkt(outbuf);
 895
 896               if (close_done)
 897                 {
 898                   CVAL(outbuf,smb_vwv0) = SMBclose;
 899                   SSVAL(outbuf,smb_vwv1,PTR_DIFF(smb_buf(outbuf),outbuf) - 4);
 900                 }
 901               else
 902                 CVAL(outbuf,smb_vwv0) = 0xFF;
 903
 904
 905               SSVAL(outbuf,smb_vwv2,fnum);
 906               SIVAL(outbuf,smb_vwv3,nread);
 907               SSVAL(outbuf,smb_vwv5,MIN(max_xmit-200,finfo.size - nread));
 908               SSVAL(outbuf,smb_vwv6,0);
 909               SIVAL(outbuf,smb_vwv7,0);
 910               SSVAL(outbuf,smb_vwv9,MIN(0xFFFF,finfo.size-nread));
 911
 912               if (close_done)
 913                 {
 914                   p = smb_buf(outbuf);
 915                   memset(p,0,9);
 916
 917                   CVAL(p,0) = 3;
 918                   SSVAL(p,1,fnum);
 919                   SIVALS(p,3,-1);
 920
 921                   /* now set the total packet length */
 922                   smb_setlen(outbuf,smb_len(outbuf)+9);
 923                 }
 924
 925               send_smb(Client,outbuf);
 926               receive_smb(Client,inbuf,CLIENT_TIMEOUT);
 927
 928               if (CVAL(inbuf,smb_rcls) != 0)
 929                 {
 930                   DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
 931                   break;
 932                 }
 933
 934               if (close_done &&
 935                   SVAL(inbuf,smb_vwv0) != SMBclose)
 936                 {
 937                   /* NOTE: WfWg sometimes just ignores the chained
 938                      command! This seems to break the spec? */
 939                   DEBUG(3,("Rejected chained close?\n"));
 940                   close_done = False;
 941                   can_chain_close = False;
 942                   ignore_close_error = True;
 943                 }
 944
 945               datalen = SVAL(inbuf,smb_vwv5);
 946               dataptr = inbuf + 4 + SVAL(inbuf,smb_vwv6);
 947               break;
 948
 949
 950               /* use readbraw */
 951             case 1:
 952               {
 953                 static int readbraw_size = 0xFFFF;
 954
 955                 extern int Client;
 956                 memset(outbuf,0,smb_size);
 957                 set_message(outbuf,8,0,True);
 958                 CVAL(outbuf,smb_com) = SMBreadbraw;
 959                 SSVAL(outbuf,smb_tid,cnum);
 960                 setup_pkt(outbuf);
 961                 SSVAL(outbuf,smb_vwv0,fnum);
 962                 SIVAL(outbuf,smb_vwv1,nread);
 963                 SSVAL(outbuf,smb_vwv3,MIN(finfo.size-nread,readbraw_size));
 964                 SSVAL(outbuf,smb_vwv4,0);
 965                 SIVALS(outbuf,smb_vwv5,-1);
 966                 send_smb(Client,outbuf);
 967
 968                 /* Now read the raw data into the buffer and write it */
 969                 if(read_smb_length(Client,inbuf,0) == -1) {
 970                   DEBUG(0,("Failed to read length in readbraw\n"));
 971                   exit(1);
 972                 }
 973
 974                 /* Even though this is not an smb message, smb_len
 975                    returns the generic length of an smb message */
 976                 datalen = smb_len(inbuf);
 977
 978                 if (datalen == 0)
 979                   {
 980                     /* we got a readbraw error */
 981                     DEBUG(4,("readbraw error - reducing size\n"));
 982                     readbraw_size = (readbraw_size * 9) / 10;
 983
 984                     if (readbraw_size < max_xmit)
 985                       {
 986                         DEBUG(0,("disabling readbraw\n"));
 987                         readbraw_supported = False;
 988                       }
 989
 990                     dataptr=NULL;
 991                     continue;
 992                   }
 993
 994                 if(read_data(Client,inbuf,datalen) != datalen) {
 995                   DEBUG(0,("Failed to read data in readbraw\n"));
 996                   exit(1);
 997                 }
 998                 dataptr = inbuf;
 999               }
1000               break;
1001
1002             case 3:
1003               /* we've already read some data with a chained readX */
1004               break;
1005
1006             default:
1007               /* use plain read */
1008               memset(outbuf,0,smb_size);
1009               set_message(outbuf,5,0,True);
1010               CVAL(outbuf,smb_com) = SMBread;
1011               SSVAL(outbuf,smb_tid,cnum);
1012               setup_pkt(outbuf);
1013
1014               SSVAL(outbuf,smb_vwv0,fnum);
1015               SSVAL(outbuf,smb_vwv1,MIN(max_xmit-200,finfo.size - nread));
1016               SIVAL(outbuf,smb_vwv2,nread);
1017               SSVAL(outbuf,smb_vwv4,finfo.size - nread);
1018
1019               send_smb(Client,outbuf);
1020               receive_smb(Client,inbuf,CLIENT_TIMEOUT);
1021
1022               if (CVAL(inbuf,smb_rcls) != 0)
1023                 {
1024                   DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
1025                   break;
1026                 }
1027
1028               datalen = SVAL(inbuf,smb_vwv0);
1029               dataptr = smb_buf(inbuf) + 3;
1030               break;
1031             }
1032
1033
1034           /* add received bits of file to buffer - dotarbuf will
1035            * write out in 512 byte intervals */
1036           if (dotarbuf(tarhandle,dataptr,datalen) != datalen)
1037             {
1038               DEBUG(0,("Error writing local file\n"));
1039               break;
1040             }
1041
1042           nread += datalen;
1043           if (datalen == 0)
1044             {
1045               DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
1046               break;
1047             }
1048
1049           dataptr=NULL;
1050           datalen=0;
1051         }
1052
1053        /* pad tar file with zero's if we couldn't get entire file */
1054        if (nread < finfo.size)
1055         {
1056           DEBUG(0, ("Didn't get entire file. size=%d, nread=%d\n", finfo.size, nread));
1057           if (padit(inbuf, BUFFER_SIZE, finfo.size - nread))
1058               DEBUG(0,("Error writing local file\n"));
1059         }
1060
1061       /* round tar file to nearest block */
1062       if (finfo.size % TBLOCK)
1063         dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));
1064
1065       ntarf++;
1066     }
1067
1068   if (!close_done)
1069     {
1070       memset(outbuf,0,smb_size);
1071       set_message(outbuf,3,0,True);
1072       CVAL(outbuf,smb_com) = SMBclose;
1073       SSVAL(outbuf,smb_tid,cnum);
1074       setup_pkt(outbuf);
1075
1076       SSVAL(outbuf,smb_vwv0,fnum);
1077       SIVALS(outbuf,smb_vwv1,-1);
1078
1079       send_smb(Client,outbuf);
1080       receive_smb(Client,inbuf,CLIENT_TIMEOUT);
1081
1082       if (!ignore_close_error && CVAL(inbuf,smb_rcls) != 0)
1083         {
1084           DEBUG(0,("Error %s closing remote file\n",smb_errstr(inbuf)));
1085           free(inbuf);free(outbuf);
1086           return;
1087         }
1088     }
1089
1090   if (shallitime)
1091     {
1092       struct timeval tp_end;
1093       int this_time;
1094
1095       /* if shallitime is true then we didn't skip */
1096       if (tar_reset) (void) do_setrattr(finfo.name, aARCH, ATTRRESET);
1097
1098       GetTimeOfDay(&tp_end);
1099       this_time =
1100         (tp_end.tv_sec - tp_start.tv_sec)*1000 +
1101           (tp_end.tv_usec - tp_start.tv_usec)/1000;
1102       get_total_time_ms += this_time;
1103       get_total_size += finfo.size;
1104
1105       /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
1106       DEBUG(1,("(%g kb/s) (average %g kb/s)\n",
1107                finfo.size / MAX(0.001, (1.024*this_time)),
1108                get_total_size / MAX(0.001, (1.024*get_total_time_ms))));
1109     }
1110
1111   free(inbuf);free(outbuf);
1112 }
1113
1114 /****************************************************************************
1115 Append single file to tar file (or not)
1116 ***************************************************************************/
1117 static void do_tar(file_info *finfo)
1118 {
1119   pstring rname;
1120
1121   if (strequal(finfo->name,".") || strequal(finfo->name,".."))
1122     return;
1123
1124   /* Is it on the exclude list ? */
1125   if (!tar_excl && clipn) {
1126     pstring exclaim;
1127
1128     strcpy(exclaim, cur_dir);
1129     *(exclaim+strlen(exclaim)-1)='\0';
1130
1131     if (clipfind(cliplist, clipn, exclaim)) {
1132       DEBUG(3,("Skipping directory %s\n", exclaim));
1133       return;
1134     }
1135
1136     strcat(exclaim, "\\");
1137     strcat(exclaim, finfo->name);
1138
1139     if (clipfind(cliplist, clipn, exclaim)) {
1140       DEBUG(3,("Skipping file %s\n", exclaim));
1141       return;
1142     }
1143   }
1144
1145   if (finfo->mode & aDIR)
1146     {
1147       pstring saved_curdir;
1148       pstring mtar_mask;
1149       char *inbuf,*outbuf;
1150
1151       inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1152       outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1153
1154       if (!inbuf || !outbuf)
1155         {
1156           DEBUG(0,("out of memory\n"));
1157           return;
1158         }
1159
1160       strcpy(saved_curdir,cur_dir);
1161
1162       strcat(cur_dir,finfo->name);
1163       strcat(cur_dir,"\\");
1164
1165       /* write a tar directory, don't bother with mode - just set it to
1166        * 40755 */
1167       writetarheader(tarhandle, cur_dir, 0, finfo->mtime, "040755 \0");
1168       strcpy(mtar_mask,cur_dir);
1169       strcat(mtar_mask,"*");
1170
1171       do_dir((char *)inbuf,(char *)outbuf,mtar_mask,attribute,do_tar,recurse);
1172       strcpy(cur_dir,saved_curdir);
1173       free(inbuf);free(outbuf);
1174     }
1175   else
1176     {
1177       strcpy(rname,cur_dir);
1178       strcat(rname,finfo->name);
1179       do_atar(rname,finfo->name,finfo);
1180     }
1181 }
1182
1183 /****************************************************************************
1184 Convert from UNIX to DOS file names
1185 ***************************************************************************/
1186 static void unfixtarname(char *tptr, char *fp, int l)
1187 {
1188   /* remove '.' from start of file name, convert from unix /'s to
1189    * dos \'s in path. Kill any absolute path names.
1190    */
1191
1192   if (*fp == '.') fp++;
1193   if (*fp == '\\' || *fp == '/') fp++;
1194
1195 #ifdef KANJI
1196   while (l > 0) {
1197     if (is_shift_jis (*fp)) {
1198       *tptr++ = *fp++;
1199       *tptr++ = *fp++;
1200       l -= 2;
1201     } else if (is_kana (*fp)) {
1202       *tptr++ = *fp++;
1203       l--;
1204     } else if (*fp == '/') {
1205       *tptr++ = '\\';
1206       fp++;
1207       l--;
1208     } else {
1209       *tptr++ = *fp++;
1210       l--;
1211     }
1212   }
1213 #else
1214   while (l--) { *tptr=(*fp == '/') ? '\\' : *fp; tptr++; fp++; }
1215 #endif
1216 }
1217
1218 static void do_tarput()
1219 {
1220   file_info finfo;
1221   int nread=0, bufread;
1222   char *inbuf,*outbuf;
1223   int fsize=0;
1224   int fnum;
1225   struct timeval tp_start;
1226   BOOL tskip=False;       /* We'll take each file as it comes */
1227
1228   GetTimeOfDay(&tp_start);
1229
1230   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1231   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1232
1233   if (!inbuf || !outbuf)
1234     {
1235       DEBUG(0,("out of memory\n"));
1236       return;
1237     }
1238
1239   /*
1240    * Must read in tbufsiz dollops
1241    */
1242
1243   /* These should be the only reads in clitar.c */
1244   while ((bufread=read(tarhandle, tarbuf, tbufsiz))>0) {
1245     char *bufferp, *endofbuffer;
1246     int chunk;
1247
1248     /* Code to handle a short read.
1249      * We always need a TBLOCK full of stuff
1250      */
1251     if (bufread % TBLOCK) {
1252       int lchunk=TBLOCK-(bufread % TBLOCK);
1253       int lread;
1254
1255       /* It's a shorty - a short read that is */
1256       DEBUG(3, ("Short read, read %d so far (need %d)\n", bufread, lchunk));
1257
1258       while ((lread=read(tarhandle, tarbuf+bufread, lchunk))>0) {
1259         bufread+=lread;
1260         if (!(lchunk-=lread)) break;
1261       }
1262
1263       /* If we've reached EOF then that must be a short file */
1264       if (lread<=0) break;
1265     }
1266
1267     bufferp=tarbuf;
1268     endofbuffer=tarbuf+bufread;
1269
1270     if (tskip) {
1271       if (fsize<bufread) {
1272         tskip=False;
1273         bufferp+=fsize;
1274         fsize=0;
1275       } else {
1276         if (fsize==bufread) tskip=False;
1277         fsize-=bufread;
1278         continue;
1279       }
1280     }
1281
1282     do {
1283       if (!fsize)
1284         {
1285           switch (readtarheader((union hblock *) bufferp, &finfo, cur_dir))
1286             {
1287             case -2:             /* something dodgy but not fatal about this */
1288               DEBUG(0, ("skipping %s...\n", finfo.name));
1289               bufferp+=TBLOCK;   /* header - like a link */
1290               continue;
1291             case -1:
1292               DEBUG(0, ("abandoning restore\n"));
1293               free(inbuf); free(outbuf);
1294               return;
1295             case 0: /* chksum is zero - we assume that one all zero
1296                      *header block will do for eof */
1297               DEBUG(0,
1298                     ("total of %d tar files restored to share\n", ntarf));
1299               free(inbuf); free(outbuf);
1300               return;
1301             default:
1302               break;
1303             }
1304
1305           tskip=clipn
1306             && (clipfind(cliplist, clipn, finfo.name) ^ tar_excl);
1307           if (tskip) {
1308             bufferp+=TBLOCK;
1309             if (finfo.mode & aDIR)
1310               continue;
1311             else if ((fsize=finfo.size) % TBLOCK) {
1312               fsize+=TBLOCK-(fsize%TBLOCK);
1313             }
1314             if (fsize<endofbuffer-bufferp) {
1315               bufferp+=fsize;
1316               fsize=0;
1317               continue;
1318             } else {
1319               fsize-=endofbuffer-bufferp;
1320               break;
1321             }
1322           }
1323
1324           if (finfo.mode & aDIR)
1325             {
1326               if (!smbchkpath(finfo.name, inbuf, outbuf)
1327                   && !smbmkdir(finfo.name, inbuf, outbuf))
1328                 {
1329                   DEBUG(0, ("abandoning restore\n"));
1330                   free(inbuf); free(outbuf);
1331                   return;
1332               }
1333               else
1334                 {
1335                   bufferp+=TBLOCK;
1336                   continue;
1337                 }
1338             }
1339
1340           fsize=finfo.size;
1341
1342           if (ensurepath(finfo.name, inbuf, outbuf)
1343               && !smbcreat(finfo, &fnum, inbuf, outbuf))
1344             {
1345               DEBUG(0, ("abandoning restore\n"));
1346               free(inbuf);free(outbuf);
1347               return;
1348             }
1349
1350           DEBUG(0,("restore tar file %s of size %d bytes\n",
1351                    finfo.name,finfo.size));
1352
1353           nread=0;
1354           if ((bufferp+=TBLOCK) >= endofbuffer) break;
1355         } /* if (!fsize) */
1356
1357       /* write out the file in chunk sized chunks - don't
1358        * go past end of buffer though */
1359       chunk=(fsize-nread < endofbuffer - bufferp)
1360         ? fsize - nread : endofbuffer - bufferp;
1361
1362       while (chunk > 0) {
1363         int minichunk=MIN(chunk, max_xmit-200);
1364
1365         if (!smbwrite(fnum, /* file descriptor */
1366                       minichunk, /* n */
1367                       nread, /* offset low */
1368                       0, /* offset high - not implemented */
1369                       fsize-nread, /* left - only hint to server */
1370                       bufferp,
1371                       inbuf,
1372                       outbuf))
1373           {
1374             DEBUG(0, ("Error writing remote file\n"));
1375             free(inbuf); free(outbuf);
1376             return;
1377           }
1378         DEBUG(5, ("chunk writing fname=%s fnum=%d nread=%d minichunk=%d chunk=%d size=%d\n", finfo.name, fnum, nread, minichunk, chunk, fsize));
1379
1380         bufferp+=minichunk; nread+=minichunk;
1381         chunk-=minichunk;
1382       }
1383
1384       if (nread>=fsize)
1385         {
1386           if (!smbshut(finfo, fnum, inbuf, outbuf))
1387             {
1388               DEBUG(0, ("Error closing remote file\n"));
1389               free(inbuf);free(outbuf);
1390               return;
1391             }
1392           if (fsize % TBLOCK) bufferp+=TBLOCK - (fsize % TBLOCK);
1393           DEBUG(5, ("bufferp is now %d (psn=%d)\n",
1394                     (long) bufferp, (long)(bufferp - tarbuf)));
1395           ntarf++;
1396           fsize=0;
1397         }
1398     } while (bufferp < endofbuffer);
1399   }
1400
1401   DEBUG(0, ("premature eof on tar file ?\n"));
1402   DEBUG(0,("total of %d tar files restored to share\n", ntarf));
1403
1404   free(inbuf); free(outbuf);
1405 }
1406
1407 /*
1408  * samba interactive commands
1409  */
1410
1411 /****************************************************************************
1412 Blocksize command
1413 ***************************************************************************/
1414 void cmd_block(void)
1415 {
1416   fstring buf;
1417   int block;
1418
1419   if (!next_token(NULL,buf,NULL))
1420     {
1421       DEBUG(0, ("blocksize <n>\n"));
1422       return;
1423     }
1424
1425   block=atoi(buf);
1426   if (block < 0 || block > 65535)
1427     {
1428       DEBUG(0, ("blocksize out of range"));
1429       return;
1430     }
1431
1432   blocksize=block;
1433   DEBUG(1,("blocksize is now %d\n", blocksize));
1434 }
1435
1436 /****************************************************************************
1437 command to set incremental / reset mode
1438 ***************************************************************************/
1439 void cmd_tarmode(void)
1440 {
1441   fstring buf;
1442
1443   while (next_token(NULL,buf,NULL)) {
1444     if (strequal(buf, "full"))
1445       tar_inc=False;
1446     else if (strequal(buf, "inc"))
1447       tar_inc=True;
1448     else if (strequal(buf, "reset"))
1449       tar_reset=True;
1450     else if (strequal(buf, "noreset"))
1451       tar_reset=False;
1452     else DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
1453   }
1454
1455   DEBUG(0, ("tarmode is now %s, %s\n",
1456             tar_inc ? "incremental" : "full",
1457             tar_reset ? "reset" : "noreset"));
1458 }
1459
1460 /****************************************************************************
1461 Feeble attrib command
1462 ***************************************************************************/
1463 void cmd_setmode(void)
1464 {
1465   char *q;
1466   fstring buf;
1467   pstring fname;
1468   int attra[2];
1469   int direct=1;
1470
1471   attra[0] = attra[1] = 0;
1472
1473   if (!next_token(NULL,buf,NULL))
1474     {
1475       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1476       return;
1477     }
1478
1479   strcpy(fname, cur_dir);
1480   strcat(fname, buf);
1481
1482   while (next_token(NULL,buf,NULL)) {
1483     q=buf;
1484
1485     while(*q)
1486       switch (*q++) {
1487       case '+': direct=1;
1488         break;
1489       case '-': direct=0;
1490         break;
1491       case 'r': attra[direct]|=aRONLY;
1492         break;
1493       case 'h': attra[direct]|=aHIDDEN;
1494         break;
1495       case 's': attra[direct]|=aSYSTEM;
1496         break;
1497       case 'a': attra[direct]|=aARCH;
1498         break;
1499       default: DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1500         return;
1501       }
1502   }
1503
1504   if (attra[ATTRSET]==0 && attra[ATTRRESET]==0)
1505     {
1506       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1507       return;
1508     }
1509
1510   DEBUG(1, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
1511   (void) do_setrattr(fname, attra[ATTRSET], ATTRSET);
1512   (void) do_setrattr(fname, attra[ATTRRESET], ATTRRESET);
1513 }
1514
1515 /****************************************************************************
1516 Principal command for creating / extracting
1517 ***************************************************************************/
1518 void cmd_tar(char *inbuf, char *outbuf)
1519 {
1520   fstring buf;
1521   char **argl;
1522   int argcl;
1523
1524   if (!next_token(NULL,buf,NULL))
1525     {
1526       DEBUG(0,("tar <c|x>[IXbga] <filename>\n"));
1527       return;
1528     }
1529
1530   argl=toktocliplist(&argcl, NULL);
1531   if (!tar_parseargs(argcl, argl, buf, 0))
1532     return;
1533
1534   process_tar(inbuf, outbuf);
1535
1536   free(argl);
1537 }
1538
1539 /****************************************************************************
1540 Command line (option) version
1541 ***************************************************************************/
1542 int process_tar(char *inbuf, char *outbuf)
1543 {
1544   initarbuf();
1545   switch(tar_type) {
1546   case 'x':
1547     do_tarput();
1548     free(tarbuf);
1549     close(tarhandle);
1550     break;
1551   case 'r':
1552   case 'c':
1553     if (clipn && tar_excl) {
1554       int i;
1555       pstring tarmac;
1556
1557       for (i=0; i<clipn; i++) {
1558         DEBUG(0,("arg %d = %s\n", i, cliplist[i]));
1559
1560         if (*(cliplist[i]+strlen(cliplist[i])-1)=='\\') {
1561           *(cliplist[i]+strlen(cliplist[i])-1)='\0';
1562         }
1563
1564         if (strrchr(cliplist[i], '\\')) {
1565           pstring saved_dir;
1566
1567           strcpy(saved_dir, cur_dir);
1568
1569           if (*cliplist[i]=='\\') {
1570             strcpy(tarmac, cliplist[i]);
1571           } else {
1572             strcpy(tarmac, cur_dir);
1573             strcat(tarmac, cliplist[i]);
1574           }
1575           strcpy(cur_dir, tarmac);
1576           *(strrchr(cur_dir, '\\')+1)='\0';
1577
1578           do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse);
1579           strcpy(cur_dir,saved_dir);
1580         } else {
1581           strcpy(tarmac, cur_dir);
1582           strcat(tarmac, cliplist[i]);
1583           do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse);
1584         }
1585       }
1586     } else {
1587       pstring mask;
1588       strcpy(mask,cur_dir);
1589       strcat(mask,"\\*");
1590       do_dir((char *)inbuf,(char *)outbuf,mask,attribute,do_tar,recurse);
1591     }
1592
1593     if (ntarf) dotareof(tarhandle);
1594     close(tarhandle);
1595     free(tarbuf);
1596
1597     DEBUG(0, ("tar: dumped %d tar files\n", ntarf));
1598     break;
1599   }
1600
1601   return(0);
1602 }
1603
1604 /****************************************************************************
1605 Find a token (filename) in a clip list
1606 ***************************************************************************/
1607 int clipfind(char **aret, int ret, char *tok)
1608 {
1609   if (aret==NULL) return 0;
1610
1611   /* ignore leading slashes or dots in token */
1612   while(strchr("/\\.", *tok)) tok++;
1613
1614   while(ret--) {
1615     char *pkey=*aret++;
1616
1617     /* ignore leading slashes or dots in list */
1618     while(strchr("/\\.", *pkey)) pkey++;
1619
1620     if (!strslashcmp(pkey, tok)) return 1;
1621   }
1622
1623   return 0;
1624 }
1625
1626 /****************************************************************************
1627 Parse tar arguments. Sets tar_type, tar_excl, etc.
1628 ***************************************************************************/
1629 int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind)
1630 {
1631   char tar_clipfl='\0';
1632
1633   /* Reset back to defaults - could be from interactive version
1634    * reset mode and archive mode left as they are though
1635    */
1636   tar_type='\0';
1637   tar_excl=True;
1638
1639   while (*Optarg)
1640     switch(*Optarg++) {
1641     case 'c':
1642       tar_type='c';
1643       break;
1644     case 'x':
1645       if (tar_type=='c') {
1646         printf("Tar must be followed by only one of c or x.\n");
1647         return 0;
1648       }
1649       tar_type='x';
1650       break;
1651     case 'b':
1652       if (Optind>=argc || !(blocksize=atoi(argv[Optind]))) {
1653         DEBUG(0,("Option b must be followed by valid blocksize\n"));
1654         return 0;
1655       } else {
1656         Optind++;
1657       }
1658       break;
1659     case 'g':
1660       tar_inc=True;
1661       break;
1662     case 'N':
1663       if (Optind>=argc) {
1664         DEBUG(0,("Option N must be followed by valid file name\n"));
1665         return 0;
1666       } else {
1667         struct stat stbuf;
1668         extern time_t newer_than;
1669
1670         if (sys_stat(argv[Optind], &stbuf) == 0) {
1671           newer_than = stbuf.st_mtime;
1672           DEBUG(1,("Getting files newer than %s",
1673                    asctime(LocalTime(&newer_than))));
1674           Optind++;
1675         } else {
1676           DEBUG(0,("Error setting newer-than time\n"));
1677           return 0;
1678         }
1679       }
1680       break;
1681     case 'a':
1682       tar_reset=True;
1683       break;
1684     case 'I':
1685       if (tar_clipfl) {
1686         DEBUG(0,("Only one of I,X must be specified\n"));
1687         return 0;
1688       }
1689       tar_clipfl='I';
1690       break;
1691     case 'X':
1692       if (tar_clipfl) {
1693         DEBUG(0,("Only one of I,X must be specified\n"));
1694         return 0;
1695       }
1696       tar_clipfl='X';
1697       break;
1698     default:
1699       DEBUG(0,("Unknown tar option\n"));
1700       return 0;
1701     }
1702
1703   if (!tar_type) {
1704     printf("Option T must be followed by one of c or x.\n");
1705     return 0;
1706   }
1707
1708   tar_excl=tar_clipfl!='X';
1709   if (Optind+1<argc) {
1710     cliplist=argv+Optind+1;
1711     clipn=argc-Optind-1;
1712   }
1713   if (Optind>=argc || !strcmp(argv[Optind], "-")) {
1714     /* Sets tar handle to either 0 or 1, as appropriate */
1715     tarhandle=(tar_type=='c');
1716   } else {
1717     if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY)) == -1)
1718         || (tar_type=='c' && (tarhandle=creat(argv[Optind], 0644)) < 0))
1719       {
1720         DEBUG(0,("Error opening local file %s\n",argv[Optind]));
1721         return(0);
1722       }
1723   }
1724
1725   return 1;
1726 }