home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 July & August / Pcwk78a98.iso / Wtestowe / Clico / UNIX / SAMBA / SOURCE / SAMBA.TAR / samba-1.9.17 / source / clitar.c < prev    next >
C/C++ Source or Header  |  1997-07-28  |  43KB  |  1,740 lines
  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, ttarf;
  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 and total dumped */
  275.   tp=0; ntarf=0; ttarf=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, allowing s1 to match s2 
  376. if s1 is an "initial" string (up to directory marker).  Thus, if s2 is 
  377. a file in any subdirectory of s1, declare a match.
  378. ***************************************************************************/
  379. static
  380. int strslashcmp(char *s1, char *s2)
  381. {
  382.   char *s1_0=s1;
  383.  
  384.   while(*s1 && *s2 &&
  385.     (*s1 == *s2
  386.      || tolower(*s1) == tolower(*s2)
  387.      || (*s1 == '\\' && *s2=='/')
  388.      || (*s1 == '/' && *s2=='\\'))) {
  389.       s1++; s2++;
  390.   }
  391.  
  392.   /* if s1 has a trailing slash, it compared equal, so s1 is an "initial" 
  393.      string of s2.
  394.    */
  395.   if (!*s1 && s1 != s1_0 && (*(s1-1) == '/' || *(s1-1) == '\\')) return 0;
  396.  
  397.   /* ignore trailing slash on s1 */
  398.   if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1)) return 0;
  399.  
  400.   /* check for s1 is an "initial" string of s2 */
  401.   if (*s2 == '/' || *s2 == '\\') return 0;
  402.  
  403.   return *s1-*s2;
  404. }
  405.  
  406. /*
  407.  * general smb utility functions
  408.  */
  409. /****************************************************************************
  410. Set DOS file attributes
  411. ***************************************************************************/
  412. static int do_setrattr(char *fname, int attr, int setit)
  413. {
  414.   /*
  415.    * First get the existing attribs from existing file
  416.    */
  417.   char *inbuf,*outbuf;
  418.   char *p;
  419.   pstring name;
  420.   int fattr;
  421.  
  422.   strcpy(name,fname);
  423.   strcpy(fname,"\\");
  424.   strcat(fname,name);
  425.  
  426.   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  427.   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  428.  
  429.   if (!inbuf || !outbuf)
  430.     {
  431.       DEBUG(0,("out of memory\n"));
  432.       return False;
  433.     }
  434.  
  435.   /* send an smb getatr message */
  436.  
  437.   memset(outbuf,0,smb_size);
  438.   set_message(outbuf,0,2 + strlen(fname),True);
  439.   CVAL(outbuf,smb_com) = SMBgetatr;
  440.   SSVAL(outbuf,smb_tid,cnum);
  441.   setup_pkt(outbuf);
  442.  
  443.   p = smb_buf(outbuf);
  444.   *p++ = 4;
  445.   strcpy(p,fname);
  446.   p += (strlen(fname)+1);
  447.   
  448.   *p++ = 4;
  449.   *p++ = 0;
  450.  
  451.   send_smb(Client,outbuf);
  452.   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  453.  
  454.   if (CVAL(inbuf,smb_rcls) != 0)
  455.     DEBUG(5,("getatr: %s\n",smb_errstr(inbuf)));
  456.   else
  457.     {
  458.       DEBUG(5,("\nattr 0x%X  time %d  size %d\n",
  459.            (int)CVAL(inbuf,smb_vwv0),
  460.            SVAL(inbuf,smb_vwv1),
  461.            SVAL(inbuf,smb_vwv3)));
  462.     }
  463.  
  464.   fattr=CVAL(inbuf,smb_vwv0);
  465.  
  466.   /* combine found attributes with bits to be set or reset */
  467.  
  468.   attr=setit ? (fattr | attr) : (fattr & ~attr);
  469.  
  470.   /* now try and set attributes by sending smb reset message */
  471.  
  472.   /* clear out buffer and start again */
  473.   memset(outbuf,0,smb_size);
  474.   set_message(outbuf,8,4 + strlen(fname),True);
  475.   CVAL(outbuf,smb_com) = SMBsetatr;
  476.   SSVAL(outbuf,smb_tid,cnum);
  477.   setup_pkt(outbuf);
  478.  
  479.   SSVAL(outbuf,smb_vwv0,attr);
  480.  
  481.   p = smb_buf(outbuf);
  482.   *p++ = 4;      
  483.   strcpy(p,fname);
  484.   p += (strlen(fname)+1);
  485.   
  486.   *p++ = 4;
  487.   *p++ = 0;
  488.  
  489.   send_smb(Client,outbuf);
  490.   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  491.   
  492.   if (CVAL(inbuf,smb_rcls) != 0)
  493.     {
  494.       DEBUG(0,("%s setting attributes on file %s\n",
  495.         smb_errstr(inbuf), fname));
  496.       free(inbuf);free(outbuf);
  497.       return(False);
  498.     }
  499.  
  500.   free(inbuf);free(outbuf);
  501.   return(True);
  502. }
  503.  
  504. /****************************************************************************
  505. Create a file on a share
  506. ***************************************************************************/
  507. static BOOL smbcreat(file_info finfo, int *fnum, char *inbuf, char *outbuf)
  508. {
  509.   char *p;
  510.   /* *must* be called with buffer ready malloc'ed */
  511.   /* open remote file */
  512.   
  513.   memset(outbuf,0,smb_size);
  514.   set_message(outbuf,3,2 + strlen(finfo.name),True);
  515.   CVAL(outbuf,smb_com) = SMBcreate;
  516.   SSVAL(outbuf,smb_tid,cnum);
  517.   setup_pkt(outbuf);
  518.   
  519.   SSVAL(outbuf,smb_vwv0,finfo.mode);
  520.   put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
  521.   
  522.   p = smb_buf(outbuf);
  523.   *p++ = 4;      
  524.   strcpy(p,finfo.name);
  525.   
  526.   send_smb(Client,outbuf);
  527.   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  528.   
  529.   if (CVAL(inbuf,smb_rcls) != 0)
  530.     {
  531.       DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),
  532.            finfo.name));
  533.       return 0;
  534.     }
  535.   
  536.   *fnum = SVAL(inbuf,smb_vwv0);
  537.   return True;
  538. }
  539.  
  540. /****************************************************************************
  541. Write a file to a share
  542. ***************************************************************************/
  543. static BOOL smbwrite(int fnum, int n, int low, int high, int left,
  544.              char *bufferp, char *inbuf, char *outbuf)
  545. {
  546.   /* *must* be called with buffer ready malloc'ed */
  547.  
  548.   memset(outbuf,0,smb_size);
  549.   set_message(outbuf,5,n + 3,True);
  550.   
  551.   memcpy(smb_buf(outbuf)+3, bufferp, n);
  552.   
  553.   set_message(outbuf,5,n + 3, False);
  554.   CVAL(outbuf,smb_com) = SMBwrite;
  555.   SSVAL(outbuf,smb_tid,cnum);
  556.   setup_pkt(outbuf);
  557.   
  558.   SSVAL(outbuf,smb_vwv0,fnum);
  559.   SSVAL(outbuf,smb_vwv1,n);
  560.   SIVAL(outbuf,smb_vwv2,low);
  561.   SSVAL(outbuf,smb_vwv4,left);
  562.   CVAL(smb_buf(outbuf),0) = 1;
  563.   SSVAL(smb_buf(outbuf),1,n);
  564.  
  565.   send_smb(Client,outbuf); 
  566.   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  567.   
  568.   if (CVAL(inbuf,smb_rcls) != 0)
  569.     {
  570.       DEBUG(0,("%s writing remote file\n",smb_errstr(inbuf)));
  571.       return False;
  572.     }
  573.   
  574.   if (n != SVAL(inbuf,smb_vwv0))
  575.     {
  576.       DEBUG(0,("Error: only wrote %d bytes out of %d\n",
  577.            SVAL(inbuf,smb_vwv0), n));
  578.       return False;
  579.     }
  580.  
  581.   return True;
  582. }
  583.  
  584. /****************************************************************************
  585. Close a file on a share
  586. ***************************************************************************/
  587. static BOOL smbshut(file_info finfo, int fnum, char *inbuf, char *outbuf)
  588. {
  589.   /* *must* be called with buffer ready malloc'ed */
  590.  
  591.   memset(outbuf,0,smb_size);
  592.   set_message(outbuf,3,0,True);
  593.   CVAL(outbuf,smb_com) = SMBclose;
  594.   SSVAL(outbuf,smb_tid,cnum);
  595.   setup_pkt(outbuf);
  596.   
  597.   SSVAL(outbuf,smb_vwv0,fnum);
  598.   put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
  599.   
  600.   DEBUG(3,("Setting date to %s (0x%X)",
  601.        asctime(LocalTime(&finfo.mtime)),
  602.        finfo.mtime));
  603.   
  604.   send_smb(Client,outbuf);
  605.   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  606.   
  607.   if (CVAL(inbuf,smb_rcls) != 0)
  608.     {
  609.       DEBUG(0,("%s closing remote file %s\n",smb_errstr(inbuf),
  610.            finfo.name));
  611.       return False;
  612.     }
  613.  
  614.   return True;
  615. }
  616.  
  617. /****************************************************************************
  618. Verify existence of path on share
  619. ***************************************************************************/
  620. static BOOL smbchkpath(char *fname, char *inbuf, char *outbuf)
  621. {
  622.   char *p;
  623.  
  624.   memset(outbuf,0,smb_size);
  625.   set_message(outbuf,0,4 + strlen(fname),True);
  626.   CVAL(outbuf,smb_com) = SMBchkpth;
  627.   SSVAL(outbuf,smb_tid,cnum);
  628.   setup_pkt(outbuf);
  629.  
  630.   p = smb_buf(outbuf);
  631.   *p++ = 4;
  632.   strcpy(p,fname);
  633.  
  634.   send_smb(Client,outbuf);
  635.   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  636.  
  637.   DEBUG(5,("smbchkpath: %s\n",smb_errstr(inbuf)));
  638.  
  639.   return(CVAL(inbuf,smb_rcls) == 0);
  640. }
  641.  
  642. /****************************************************************************
  643. Make a directory on share
  644. ***************************************************************************/
  645. static BOOL smbmkdir(char *fname, char *inbuf, char *outbuf)
  646. {
  647.   /* *must* be called with buffer ready malloc'ed */
  648.   char *p;
  649.  
  650.   memset(outbuf,0,smb_size);
  651.   set_message(outbuf,0,2 + strlen(fname),True);
  652.   
  653.   CVAL(outbuf,smb_com) = SMBmkdir;
  654.   SSVAL(outbuf,smb_tid,cnum);
  655.   setup_pkt(outbuf);
  656.   
  657.   p = smb_buf(outbuf);
  658.   *p++ = 4;      
  659.   strcpy(p,fname);
  660.   
  661.   send_smb(Client,outbuf);
  662.   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  663.   
  664.   if (CVAL(inbuf,smb_rcls) != 0)
  665.     {
  666.       DEBUG(0,("%s making remote directory %s\n",
  667.            smb_errstr(inbuf),fname));
  668.       return(False);
  669.     }
  670.  
  671.   return(True);
  672. }
  673.  
  674. /****************************************************************************
  675. Ensure a remote path exists (make if necessary)
  676. ***************************************************************************/
  677. static BOOL ensurepath(char *fname, char *inbuf, char *outbuf)
  678. {
  679.   /* *must* be called with buffer ready malloc'ed */
  680.   /* ensures path exists */
  681.  
  682.   pstring partpath, ffname;
  683.   char *p=fname, *basehack;
  684.  
  685.   *partpath = 0;
  686.  
  687.   /* fname copied to ffname so can strtok */
  688.  
  689.   strcpy(ffname, fname);
  690.  
  691.   /* do a `basename' on ffname, so don't try and make file name directory */
  692.   if ((basehack=strrchr(ffname, '\\')) == NULL)
  693.     return True;
  694.   else
  695.     *basehack='\0';
  696.  
  697.   p=strtok(ffname, "\\");
  698.  
  699.   while (p)
  700.     {
  701.       strcat(partpath, p);
  702.  
  703.       if (!smbchkpath(partpath, inbuf, outbuf)) {
  704.     if (!smbmkdir(partpath, inbuf, outbuf))
  705.       {
  706.         DEBUG(0, ("Error mkdirhiering\n"));
  707.         return False;
  708.       }
  709.     else
  710.       DEBUG(3, ("mkdirhiering %s\n", partpath));
  711.  
  712.       }
  713.  
  714.       strcat(partpath, "\\");
  715.       p = strtok(NULL,"/\\");
  716.     }
  717.  
  718.     return True;
  719. }
  720.  
  721. int padit(char *buf, int bufsize, int padsize)
  722. {
  723.   int berr= 0;
  724.   int bytestowrite;
  725.   
  726.   DEBUG(0, ("Padding with %d zeros\n", padsize));
  727.   memset(buf, 0, bufsize);
  728.   while( !berr && padsize > 0 ) {
  729.     bytestowrite= MIN(bufsize, padsize);
  730.     berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite;
  731.     padsize -= bytestowrite;
  732.   }
  733.   
  734.   return berr;
  735. }
  736.  
  737. /*
  738.  * smbclient functions
  739.  */
  740. /****************************************************************************
  741. append one remote file to the tar file
  742. ***************************************************************************/
  743. static void do_atar(char *rname,char *lname,file_info *finfo1)
  744. {
  745.   int fnum;
  746.   uint32 nread=0;
  747.   char *p;
  748.   char *inbuf,*outbuf;
  749.   file_info finfo;
  750.   BOOL close_done = False;
  751.   BOOL shallitime=True;
  752.   BOOL ignore_close_error = False;
  753.   char *dataptr=NULL;
  754.   int datalen=0;
  755.  
  756.   struct timeval tp_start;
  757.   GetTimeOfDay(&tp_start);
  758.  
  759.   if (finfo1) 
  760.     finfo = *finfo1;
  761.   else
  762.     finfo = def_finfo;
  763.  
  764.   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  765.   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  766.  
  767.   if (!inbuf || !outbuf)
  768.     {
  769.       DEBUG(0,("out of memory\n"));
  770.       return;
  771.     }
  772.  
  773.   memset(outbuf,0,smb_size);
  774.   set_message(outbuf,15,1 + strlen(rname),True);
  775.  
  776.   CVAL(outbuf,smb_com) = SMBopenX;
  777.   SSVAL(outbuf,smb_tid,cnum);
  778.   setup_pkt(outbuf);
  779.  
  780.   SSVAL(outbuf,smb_vwv0,0xFF);
  781.   SSVAL(outbuf,smb_vwv2,1);
  782.   SSVAL(outbuf,smb_vwv3,(DENY_NONE<<4));
  783.   SSVAL(outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
  784.   SSVAL(outbuf,smb_vwv5,aSYSTEM | aHIDDEN);
  785.   SSVAL(outbuf,smb_vwv8,1);
  786.  
  787.   p = smb_buf(outbuf);
  788.   strcpy(p,rname);
  789.   p = skip_string(p,1);
  790.  
  791.   dos_clean_name(rname);
  792.  
  793.   /* do a chained openX with a readX? */  
  794.   if (finfo.size > 0)
  795.     {
  796.       SSVAL(outbuf,smb_vwv0,SMBreadX);
  797.       SSVAL(outbuf,smb_vwv1,PTR_DIFF(p,outbuf) - 4);
  798.       memset(p,0,200);
  799.       p -= smb_wct;
  800.       SSVAL(p,smb_wct,10);
  801.       SSVAL(p,smb_vwv0,0xFF);
  802.       SSVAL(p,smb_vwv5,MIN(max_xmit-500,finfo.size));
  803.       SSVAL(p,smb_vwv9,MIN(0xFFFF,finfo.size));
  804.       smb_setlen(outbuf,smb_len(outbuf)+11*2+1);  
  805.     }
  806.   
  807.   send_smb(Client,outbuf);
  808.   receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  809.  
  810.   if (CVAL(inbuf,smb_rcls) != 0)
  811.     {
  812.       if (CVAL(inbuf,smb_rcls) == ERRSRV &&
  813.       SVAL(inbuf,smb_err) == ERRnoresource &&
  814.       reopen_connection(inbuf,outbuf))
  815.     {
  816.       do_atar(rname,lname,finfo1);
  817.       free(inbuf);free(outbuf);
  818.       return;
  819.     }
  820.  
  821.       DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),rname));
  822.       free(inbuf);free(outbuf);
  823.       return;
  824.     }
  825.  
  826.   strcpy(finfo.name,rname);
  827.   if (!finfo1)
  828.     {
  829.       finfo.mode = SVAL(inbuf,smb_vwv3);
  830.       finfo.size = IVAL(inbuf,smb_vwv4);
  831.       finfo.mtime = make_unix_date3(inbuf+smb_vwv6);
  832.       finfo.atime = finfo.ctime = finfo.mtime;
  833.     }
  834.  
  835.   DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
  836.  
  837.   fnum = SVAL(inbuf,smb_vwv2);
  838.  
  839.   if (tar_inc && !(finfo.mode & aARCH))
  840.     {
  841.       DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name));
  842.       shallitime=0;
  843.     }
  844.   else
  845.     {
  846.       if (SVAL(inbuf,smb_vwv0) == SMBreadX)
  847.     {
  848.       p = (inbuf+4+SVAL(inbuf,smb_vwv1)) - smb_wct;
  849.       datalen = SVAL(p,smb_vwv5);
  850.       dataptr = inbuf + 4 + SVAL(p,smb_vwv6);
  851.     }
  852.       else
  853.     {
  854.       dataptr = NULL;
  855.       datalen = 0;
  856.     }
  857.  
  858.       DEBUG(1,("getting file %s of size %d bytes as a tar file %s",
  859.            finfo.name,
  860.            finfo.size,
  861.            lname));
  862.       
  863.       /* write a tar header, don't bother with mode - just set to 100644 */
  864.       writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0");
  865.       
  866.       while (nread < finfo.size && !close_done)
  867.     {
  868.       int method = -1;
  869.       static BOOL can_chain_close=True;
  870.  
  871.       p=NULL;
  872.       
  873.       DEBUG(3,("nread=%d\n",nread));
  874.       
  875.       /* 3 possible read types. readbraw if a large block is required.
  876.          readX + close if not much left and read if neither is supported */
  877.  
  878.       /* we might have already read some data from a chained readX */
  879.       if (dataptr && datalen>0)
  880.         method=3;
  881.       
  882.       /* if we can finish now then readX+close */
  883.       if (method<0 && can_chain_close && (Protocol >= PROTOCOL_LANMAN1) && 
  884.           ((finfo.size - nread) < 
  885.            (max_xmit - (2*smb_size + 13*SIZEOFWORD + 300))))
  886.         method = 0;
  887.       
  888.       /* if we support readraw then use that */
  889.       if (method<0 && readbraw_supported)
  890.         method = 1;
  891.       
  892.       /* if we can then use readX */
  893.       if (method<0 && (Protocol >= PROTOCOL_LANMAN1))
  894.         method = 2;
  895.       
  896.       
  897.       switch (method)
  898.         {
  899.           /* use readX */
  900.         case 0:
  901.         case 2:
  902.           if (method == 0)
  903.         close_done = True;
  904.           
  905.           /* use readX + close */
  906.           memset(outbuf,0,smb_size);
  907.           set_message(outbuf,10,0,True);
  908.           CVAL(outbuf,smb_com) = SMBreadX;
  909.           SSVAL(outbuf,smb_tid,cnum);
  910.           setup_pkt(outbuf);
  911.           
  912.           if (close_done)
  913.         {
  914.           CVAL(outbuf,smb_vwv0) = SMBclose;
  915.           SSVAL(outbuf,smb_vwv1,PTR_DIFF(smb_buf(outbuf),outbuf) - 4);
  916.         }
  917.           else
  918.         CVAL(outbuf,smb_vwv0) = 0xFF;          
  919.           
  920.           
  921.           SSVAL(outbuf,smb_vwv2,fnum);
  922.           SIVAL(outbuf,smb_vwv3,nread);
  923.           SSVAL(outbuf,smb_vwv5,MIN(max_xmit-200,finfo.size - nread));
  924.           SSVAL(outbuf,smb_vwv6,0);
  925.           SIVAL(outbuf,smb_vwv7,0);
  926.           SSVAL(outbuf,smb_vwv9,MIN(0xFFFF,finfo.size-nread));
  927.           
  928.           if (close_done)
  929.         {
  930.           p = smb_buf(outbuf);
  931.           memset(p,0,9);
  932.           
  933.           CVAL(p,0) = 3;
  934.           SSVAL(p,1,fnum);
  935.           SIVALS(p,3,-1);
  936.           
  937.           /* now set the total packet length */
  938.           smb_setlen(outbuf,smb_len(outbuf)+9);
  939.         }
  940.           
  941.           send_smb(Client,outbuf);
  942.           receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  943.           
  944.           if (CVAL(inbuf,smb_rcls) != 0)
  945.         {
  946.           DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
  947.           break;
  948.         }
  949.           
  950.           if (close_done &&
  951.           SVAL(inbuf,smb_vwv0) != SMBclose)
  952.         {
  953.           /* NOTE: WfWg sometimes just ignores the chained
  954.              command! This seems to break the spec? */
  955.           DEBUG(3,("Rejected chained close?\n"));
  956.           close_done = False;
  957.           can_chain_close = False;
  958.           ignore_close_error = True;
  959.         }
  960.           
  961.           datalen = SVAL(inbuf,smb_vwv5);
  962.           dataptr = inbuf + 4 + SVAL(inbuf,smb_vwv6);
  963.           break;
  964.           
  965.           
  966.           /* use readbraw */
  967.         case 1:
  968.           {
  969.         static int readbraw_size = 0xFFFF;
  970.         
  971.         extern int Client;
  972.         memset(outbuf,0,smb_size);
  973.         set_message(outbuf,8,0,True);
  974.         CVAL(outbuf,smb_com) = SMBreadbraw;
  975.         SSVAL(outbuf,smb_tid,cnum);
  976.         setup_pkt(outbuf);
  977.         SSVAL(outbuf,smb_vwv0,fnum);
  978.         SIVAL(outbuf,smb_vwv1,nread);
  979.         SSVAL(outbuf,smb_vwv3,MIN(finfo.size-nread,readbraw_size));
  980.         SSVAL(outbuf,smb_vwv4,0);
  981.         SIVALS(outbuf,smb_vwv5,-1);
  982.         send_smb(Client,outbuf);
  983.         
  984.         /* Now read the raw data into the buffer and write it */      
  985.         if(read_smb_length(Client,inbuf,0) == -1) {
  986.           DEBUG(0,("Failed to read length in readbraw\n"));        
  987.           exit(1);
  988.         }
  989.         
  990.         /* Even though this is not an smb message, smb_len
  991.            returns the generic length of an smb message */
  992.         datalen = smb_len(inbuf);
  993.         
  994.         if (datalen == 0)
  995.           {
  996.             /* we got a readbraw error */
  997.             DEBUG(4,("readbraw error - reducing size\n"));
  998.             readbraw_size = (readbraw_size * 9) / 10;
  999.             
  1000.             if (readbraw_size < max_xmit)
  1001.               {
  1002.             DEBUG(0,("disabling readbraw\n"));
  1003.             readbraw_supported = False;
  1004.               }
  1005.  
  1006.             dataptr=NULL;
  1007.             continue;
  1008.           }
  1009.  
  1010.         if(read_data(Client,inbuf,datalen) != datalen) {
  1011.           DEBUG(0,("Failed to read data in readbraw\n"));
  1012.           exit(1);
  1013.         }
  1014.         dataptr = inbuf;
  1015.           }
  1016.           break;
  1017.  
  1018.         case 3:
  1019.           /* we've already read some data with a chained readX */
  1020.           break;
  1021.           
  1022.         default:
  1023.           /* use plain read */
  1024.           memset(outbuf,0,smb_size);
  1025.           set_message(outbuf,5,0,True);
  1026.           CVAL(outbuf,smb_com) = SMBread;
  1027.           SSVAL(outbuf,smb_tid,cnum);
  1028.           setup_pkt(outbuf);
  1029.           
  1030.           SSVAL(outbuf,smb_vwv0,fnum);
  1031.           SSVAL(outbuf,smb_vwv1,MIN(max_xmit-200,finfo.size - nread));
  1032.           SIVAL(outbuf,smb_vwv2,nread);
  1033.           SSVAL(outbuf,smb_vwv4,finfo.size - nread);
  1034.           
  1035.           send_smb(Client,outbuf);
  1036.           receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  1037.           
  1038.           if (CVAL(inbuf,smb_rcls) != 0)
  1039.         {
  1040.           DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
  1041.           break;
  1042.         }
  1043.           
  1044.           datalen = SVAL(inbuf,smb_vwv0);
  1045.           dataptr = smb_buf(inbuf) + 3;
  1046.           break;
  1047.         }
  1048.       
  1049.       
  1050.       /* add received bits of file to buffer - dotarbuf will
  1051.        * write out in 512 byte intervals */
  1052.       if (dotarbuf(tarhandle,dataptr,datalen) != datalen)
  1053.         {
  1054.           DEBUG(0,("Error writing local file\n"));
  1055.           break;
  1056.         }
  1057.       
  1058.       nread += datalen;
  1059.       if (datalen == 0) 
  1060.         {
  1061.           DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
  1062.           break;
  1063.         }
  1064.  
  1065.       dataptr=NULL;
  1066.       datalen=0;
  1067.     }
  1068.  
  1069.        /* pad tar file with zero's if we couldn't get entire file */
  1070.        if (nread < finfo.size)
  1071.         {
  1072.           DEBUG(0, ("Didn't get entire file. size=%d, nread=%d\n", finfo.size, nread));
  1073.           if (padit(inbuf, BUFFER_SIZE, finfo.size - nread))
  1074.               DEBUG(0,("Error writing local file\n"));
  1075.         }
  1076.  
  1077.       /* round tar file to nearest block */
  1078.       if (finfo.size % TBLOCK)
  1079.     dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));
  1080.       
  1081.       ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
  1082.       ntarf++;
  1083.     }
  1084.   
  1085.   if (!close_done)
  1086.     {
  1087.       memset(outbuf,0,smb_size);
  1088.       set_message(outbuf,3,0,True);
  1089.       CVAL(outbuf,smb_com) = SMBclose;
  1090.       SSVAL(outbuf,smb_tid,cnum);
  1091.       setup_pkt(outbuf);
  1092.       
  1093.       SSVAL(outbuf,smb_vwv0,fnum);
  1094.       SIVALS(outbuf,smb_vwv1,-1);
  1095.       
  1096.       send_smb(Client,outbuf);
  1097.       receive_smb(Client,inbuf,CLIENT_TIMEOUT);
  1098.       
  1099.       if (!ignore_close_error && CVAL(inbuf,smb_rcls) != 0)
  1100.     {
  1101.       DEBUG(0,("Error %s closing remote file\n",smb_errstr(inbuf)));
  1102.       free(inbuf);free(outbuf);
  1103.       return;
  1104.     }
  1105.     }
  1106.  
  1107.   if (shallitime)
  1108.     {
  1109.       struct timeval tp_end;
  1110.       int this_time;
  1111.  
  1112.       /* if shallitime is true then we didn't skip */
  1113.       if (tar_reset) (void) do_setrattr(finfo.name, aARCH, ATTRRESET);
  1114.       
  1115.       GetTimeOfDay(&tp_end);
  1116.       this_time = 
  1117.     (tp_end.tv_sec - tp_start.tv_sec)*1000 +
  1118.       (tp_end.tv_usec - tp_start.tv_usec)/1000;
  1119.       get_total_time_ms += this_time;
  1120.       get_total_size += finfo.size;
  1121.  
  1122.       /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
  1123.       DEBUG(1,("(%g kb/s) (average %g kb/s)\n",
  1124.            finfo.size / MAX(0.001, (1.024*this_time)),
  1125.            get_total_size / MAX(0.001, (1.024*get_total_time_ms))));
  1126.     }
  1127.   
  1128.   free(inbuf);free(outbuf);
  1129. }
  1130.  
  1131. /****************************************************************************
  1132. Append single file to tar file (or not)
  1133. ***************************************************************************/
  1134. static void do_tar(file_info *finfo)
  1135. {
  1136.   pstring rname;
  1137.  
  1138.   if (strequal(finfo->name,".") || strequal(finfo->name,".."))
  1139.     return;
  1140.  
  1141.   /* Is it on the exclude list ? */
  1142.   if (!tar_excl && clipn) {
  1143.     pstring exclaim;
  1144.  
  1145.     strcpy(exclaim, cur_dir);
  1146.     *(exclaim+strlen(exclaim)-1)='\0';
  1147.  
  1148.     strcat(exclaim, "\\");
  1149.     strcat(exclaim, finfo->name);
  1150.  
  1151.     if (clipfind(cliplist, clipn, exclaim)) {
  1152.       DEBUG(3,("Skipping file %s\n", exclaim));
  1153.       return;
  1154.     }
  1155.   }
  1156.  
  1157.   if (finfo->mode & aDIR)
  1158.     {
  1159.       pstring saved_curdir;
  1160.       pstring mtar_mask;
  1161.       char *inbuf,*outbuf;
  1162.  
  1163.       inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  1164.       outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  1165.  
  1166.       if (!inbuf || !outbuf)
  1167.     {
  1168.       DEBUG(0,("out of memory\n"));
  1169.       return;
  1170.     }
  1171.  
  1172.       strcpy(saved_curdir,cur_dir);
  1173.  
  1174.       strcat(cur_dir,finfo->name);
  1175.       strcat(cur_dir,"\\");
  1176.  
  1177.       /* write a tar directory, don't bother with mode - just set it to
  1178.        * 40755 */
  1179.       writetarheader(tarhandle, cur_dir, 0, finfo->mtime, "040755 \0");
  1180.       strcpy(mtar_mask,cur_dir);
  1181.       strcat(mtar_mask,"*");
  1182.       
  1183.       do_dir((char *)inbuf,(char *)outbuf,mtar_mask,attribute,do_tar,recurse);
  1184.       strcpy(cur_dir,saved_curdir);
  1185.       free(inbuf);free(outbuf);
  1186.     }
  1187.   else
  1188.     {
  1189.       strcpy(rname,cur_dir);
  1190.       strcat(rname,finfo->name);
  1191.       do_atar(rname,finfo->name,finfo);
  1192.     }
  1193. }
  1194.  
  1195. /****************************************************************************
  1196. Convert from UNIX to DOS file names
  1197. ***************************************************************************/
  1198. static void unfixtarname(char *tptr, char *fp, int l)
  1199. {
  1200.   /* remove '.' from start of file name, convert from unix /'s to
  1201.    * dos \'s in path. Kill any absolute path names.
  1202.    */
  1203.  
  1204.   if (*fp == '.') fp++;
  1205.   if (*fp == '\\' || *fp == '/') fp++;
  1206.  
  1207. #ifdef KANJI
  1208.   while (l > 0) {
  1209.     if (is_shift_jis (*fp)) {
  1210.       *tptr++ = *fp++;
  1211.       *tptr++ = *fp++;
  1212.       l -= 2;
  1213.     } else if (is_kana (*fp)) {
  1214.       *tptr++ = *fp++;
  1215.       l--;
  1216.     } else if (*fp == '/') {
  1217.       *tptr++ = '\\';
  1218.       fp++;
  1219.       l--;
  1220.     } else {
  1221.       *tptr++ = *fp++;
  1222.       l--;
  1223.     }
  1224.   }
  1225. #else
  1226.   while (l--) { *tptr=(*fp == '/') ? '\\' : *fp; tptr++; fp++; }
  1227. #endif
  1228. }
  1229.  
  1230. static void do_tarput()
  1231. {
  1232.   file_info finfo;
  1233.   int nread=0, bufread;
  1234.   char *inbuf,*outbuf; 
  1235.   int fsize=0;
  1236.   int fnum;
  1237.   struct timeval tp_start;
  1238.   BOOL tskip=False;       /* We'll take each file as it comes */
  1239.  
  1240.   GetTimeOfDay(&tp_start);
  1241.   
  1242.   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  1243.   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
  1244.   
  1245.   if (!inbuf || !outbuf)
  1246.     {
  1247.       DEBUG(0,("out of memory\n"));
  1248.       return;
  1249.     }
  1250.   
  1251.   /*
  1252.    * Must read in tbufsiz dollops
  1253.    */
  1254.  
  1255.   /* These should be the only reads in clitar.c */
  1256.   while ((bufread=read(tarhandle, tarbuf, tbufsiz))>0) {
  1257.     char *bufferp, *endofbuffer;
  1258.     int chunk;
  1259.  
  1260.     /* Code to handle a short read.
  1261.      * We always need a TBLOCK full of stuff
  1262.      */
  1263.     if (bufread % TBLOCK) {
  1264.       int lchunk=TBLOCK-(bufread % TBLOCK);
  1265.       int lread;
  1266.  
  1267.       /* It's a shorty - a short read that is */
  1268.       DEBUG(3, ("Short read, read %d so far (need %d)\n", bufread, lchunk));
  1269.  
  1270.       while ((lread=read(tarhandle, tarbuf+bufread, lchunk))>0) {
  1271.     bufread+=lread;
  1272.     if (!(lchunk-=lread)) break;
  1273.       }
  1274.  
  1275.       /* If we've reached EOF then that must be a short file */
  1276.       if (lread<=0) break;
  1277.     }
  1278.  
  1279.     bufferp=tarbuf; 
  1280.     endofbuffer=tarbuf+bufread;
  1281.  
  1282.     if (tskip) {
  1283.       if (fsize<bufread) {
  1284.     tskip=False;
  1285.     bufferp+=fsize;
  1286.     fsize=0;
  1287.       } else {
  1288.     if (fsize==bufread) tskip=False;
  1289.     fsize-=bufread;
  1290.     continue;
  1291.       }
  1292.     }
  1293.  
  1294.     do {
  1295.       if (!fsize)
  1296.     {
  1297.       switch (readtarheader((union hblock *) bufferp, &finfo, cur_dir))
  1298.         {
  1299.         case -2:             /* something dodgy but not fatal about this */
  1300.           DEBUG(0, ("skipping %s...\n", finfo.name));
  1301.           bufferp+=TBLOCK;   /* header - like a link */
  1302.           continue;
  1303.         case -1:
  1304.           DEBUG(0, ("abandoning restore\n"));
  1305.           free(inbuf); free(outbuf);
  1306.           return;
  1307.         case 0: /* chksum is zero - we assume that one all zero
  1308.              *header block will do for eof */
  1309.           DEBUG(0,
  1310.             ("total of %d tar files restored to share\n", ntarf));
  1311.           free(inbuf); free(outbuf);
  1312.           return;
  1313.         default:
  1314.           break;
  1315.         }
  1316.  
  1317.       tskip=clipn
  1318.         && (clipfind(cliplist, clipn, finfo.name) ^ tar_excl);
  1319.       if (tskip) {
  1320.         bufferp+=TBLOCK;
  1321.         if (finfo.mode & aDIR)
  1322.           continue;
  1323.         else if ((fsize=finfo.size) % TBLOCK) {
  1324.           fsize+=TBLOCK-(fsize%TBLOCK);
  1325.         }
  1326.         if (fsize<endofbuffer-bufferp) {
  1327.           bufferp+=fsize;
  1328.           fsize=0;
  1329.           continue;
  1330.         } else {
  1331.           fsize-=endofbuffer-bufferp;
  1332.           break;
  1333.         }
  1334.       }
  1335.  
  1336.       if (finfo.mode & aDIR)
  1337.         {
  1338.           if (!smbchkpath(finfo.name, inbuf, outbuf)
  1339.           && !smbmkdir(finfo.name, inbuf, outbuf))
  1340.         {
  1341.           DEBUG(0, ("abandoning restore\n"));
  1342.           free(inbuf); free(outbuf);
  1343.           return;
  1344.           }
  1345.           else
  1346.         {
  1347.           bufferp+=TBLOCK;
  1348.           continue;
  1349.         }
  1350.         }
  1351.       
  1352.       fsize=finfo.size;
  1353.  
  1354.       if (ensurepath(finfo.name, inbuf, outbuf)
  1355.           && !smbcreat(finfo, &fnum, inbuf, outbuf))
  1356.         {
  1357.           DEBUG(0, ("abandoning restore\n"));
  1358.           free(inbuf);free(outbuf);
  1359.           return;
  1360.         }
  1361.  
  1362.       DEBUG(0,("restore tar file %s of size %d bytes\n",
  1363.            finfo.name,finfo.size));
  1364.  
  1365.       nread=0;
  1366.       if ((bufferp+=TBLOCK) >= endofbuffer) break;      
  1367.     } /* if (!fsize) */
  1368.     
  1369.       /* write out the file in chunk sized chunks - don't
  1370.        * go past end of buffer though */
  1371.       chunk=(fsize-nread < endofbuffer - bufferp)
  1372.     ? fsize - nread : endofbuffer - bufferp;
  1373.       
  1374.       while (chunk > 0) {
  1375.     int minichunk=MIN(chunk, max_xmit-200);
  1376.     
  1377.     if (!smbwrite(fnum, /* file descriptor */
  1378.               minichunk, /* n */
  1379.               nread, /* offset low */
  1380.               0, /* offset high - not implemented */
  1381.               fsize-nread, /* left - only hint to server */
  1382.               bufferp,
  1383.               inbuf,
  1384.               outbuf))
  1385.       {
  1386.         DEBUG(0, ("Error writing remote file\n"));
  1387.         free(inbuf); free(outbuf);
  1388.         return;
  1389.       }
  1390.     DEBUG(5, ("chunk writing fname=%s fnum=%d nread=%d minichunk=%d chunk=%d size=%d\n", finfo.name, fnum, nread, minichunk, chunk, fsize));
  1391.     
  1392.     bufferp+=minichunk; nread+=minichunk;
  1393.     chunk-=minichunk;
  1394.       }
  1395.       
  1396.       if (nread>=fsize)
  1397.     {
  1398.       if (!smbshut(finfo, fnum, inbuf, outbuf))
  1399.         {
  1400.           DEBUG(0, ("Error closing remote file\n"));
  1401.           free(inbuf);free(outbuf);
  1402.           return;
  1403.         }
  1404.       if (fsize % TBLOCK) bufferp+=TBLOCK - (fsize % TBLOCK);
  1405.       DEBUG(5, ("bufferp is now %d (psn=%d)\n",
  1406.             (long) bufferp, (long)(bufferp - tarbuf)));
  1407.       ntarf++;
  1408.       fsize=0;
  1409.     }
  1410.     } while (bufferp < endofbuffer);
  1411.   }
  1412.  
  1413.   DEBUG(0, ("premature eof on tar file ?\n"));
  1414.   DEBUG(0,("total of %d tar files restored to share\n", ntarf));
  1415.  
  1416.   free(inbuf); free(outbuf);
  1417. }
  1418.  
  1419. /*
  1420.  * samba interactive commands
  1421.  */
  1422.  
  1423. /****************************************************************************
  1424. Blocksize command
  1425. ***************************************************************************/
  1426. void cmd_block(void)
  1427. {
  1428.   fstring buf;
  1429.   int block;
  1430.  
  1431.   if (!next_token(NULL,buf,NULL))
  1432.     {
  1433.       DEBUG(0, ("blocksize <n>\n"));
  1434.       return;
  1435.     }
  1436.  
  1437.   block=atoi(buf);
  1438.   if (block < 0 || block > 65535)
  1439.     {
  1440.       DEBUG(0, ("blocksize out of range"));
  1441.       return;
  1442.     }
  1443.  
  1444.   blocksize=block;
  1445.   DEBUG(1,("blocksize is now %d\n", blocksize));
  1446. }
  1447.  
  1448. /****************************************************************************
  1449. command to set incremental / reset mode
  1450. ***************************************************************************/
  1451. void cmd_tarmode(void)
  1452. {
  1453.   fstring buf;
  1454.  
  1455.   while (next_token(NULL,buf,NULL)) {
  1456.     if (strequal(buf, "full"))
  1457.       tar_inc=False;
  1458.     else if (strequal(buf, "inc"))
  1459.       tar_inc=True;
  1460.     else if (strequal(buf, "reset"))
  1461.       tar_reset=True;
  1462.     else if (strequal(buf, "noreset"))
  1463.       tar_reset=False;
  1464.     else DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
  1465.   }
  1466.  
  1467.   DEBUG(0, ("tarmode is now %s, %s\n",
  1468.         tar_inc ? "incremental" : "full",
  1469.         tar_reset ? "reset" : "noreset"));
  1470. }
  1471.  
  1472. /****************************************************************************
  1473. Feeble attrib command
  1474. ***************************************************************************/
  1475. void cmd_setmode(void)
  1476. {
  1477.   char *q;
  1478.   fstring buf;
  1479.   pstring fname;
  1480.   int attra[2];
  1481.   int direct=1;
  1482.  
  1483.   attra[0] = attra[1] = 0;
  1484.  
  1485.   if (!next_token(NULL,buf,NULL))
  1486.     {
  1487.       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
  1488.       return;
  1489.     }
  1490.  
  1491.   strcpy(fname, cur_dir);
  1492.   strcat(fname, buf);
  1493.  
  1494.   while (next_token(NULL,buf,NULL)) {
  1495.     q=buf;
  1496.  
  1497.     while(*q)
  1498.       switch (*q++) {
  1499.       case '+': direct=1;
  1500.     break;
  1501.       case '-': direct=0;
  1502.     break;
  1503.       case 'r': attra[direct]|=aRONLY;
  1504.     break;
  1505.       case 'h': attra[direct]|=aHIDDEN;
  1506.     break;
  1507.       case 's': attra[direct]|=aSYSTEM;
  1508.     break;
  1509.       case 'a': attra[direct]|=aARCH;
  1510.     break;
  1511.       default: DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
  1512.     return;
  1513.       }
  1514.   }
  1515.  
  1516.   if (attra[ATTRSET]==0 && attra[ATTRRESET]==0)
  1517.     {
  1518.       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
  1519.       return;
  1520.     }
  1521.  
  1522.   DEBUG(1, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
  1523.   (void) do_setrattr(fname, attra[ATTRSET], ATTRSET);
  1524.   (void) do_setrattr(fname, attra[ATTRRESET], ATTRRESET);
  1525. }
  1526.  
  1527. /****************************************************************************
  1528. Principal command for creating / extracting
  1529. ***************************************************************************/
  1530. void cmd_tar(char *inbuf, char *outbuf)
  1531. {
  1532.   fstring buf;
  1533.   char **argl;
  1534.   int argcl;
  1535.  
  1536.   if (!next_token(NULL,buf,NULL))
  1537.     {
  1538.       DEBUG(0,("tar <c|x>[IXbga] <filename>\n"));
  1539.       return;
  1540.     }
  1541.  
  1542.   argl=toktocliplist(&argcl, NULL);
  1543.   if (!tar_parseargs(argcl, argl, buf, 0))
  1544.     return;
  1545.  
  1546.   process_tar(inbuf, outbuf);
  1547.  
  1548.   free(argl);
  1549. }
  1550.  
  1551. /****************************************************************************
  1552. Command line (option) version
  1553. ***************************************************************************/
  1554. int process_tar(char *inbuf, char *outbuf)
  1555. {
  1556.   initarbuf();
  1557.   switch(tar_type) {
  1558.   case 'x':
  1559.     do_tarput();
  1560.     free(tarbuf);
  1561.     close(tarhandle);
  1562.     break;
  1563.   case 'r':
  1564.   case 'c':
  1565.     if (clipn && tar_excl) {
  1566.       int i;
  1567.       pstring tarmac;
  1568.  
  1569.       for (i=0; i<clipn; i++) {
  1570.     DEBUG(0,("arg %d = %s\n", i, cliplist[i]));
  1571.  
  1572.     if (*(cliplist[i]+strlen(cliplist[i])-1)=='\\') {
  1573.       *(cliplist[i]+strlen(cliplist[i])-1)='\0';
  1574.     }
  1575.     
  1576.     if (strrchr(cliplist[i], '\\')) {
  1577.       pstring saved_dir;
  1578.       
  1579.       strcpy(saved_dir, cur_dir);
  1580.       
  1581.       if (*cliplist[i]=='\\') {
  1582.         strcpy(tarmac, cliplist[i]);
  1583.       } else {
  1584.         strcpy(tarmac, cur_dir);
  1585.         strcat(tarmac, cliplist[i]);
  1586.       }
  1587.       strcpy(cur_dir, tarmac);
  1588.       *(strrchr(cur_dir, '\\')+1)='\0';
  1589.  
  1590.       do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse);
  1591.       strcpy(cur_dir,saved_dir);
  1592.     } else {
  1593.       strcpy(tarmac, cur_dir);
  1594.       strcat(tarmac, cliplist[i]);
  1595.       do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse);
  1596.     }
  1597.       }
  1598.     } else {
  1599.       pstring mask;
  1600.       strcpy(mask,cur_dir);
  1601.       strcat(mask,"\\*");
  1602.       do_dir((char *)inbuf,(char *)outbuf,mask,attribute,do_tar,recurse);
  1603.     }
  1604.     
  1605.     if (ntarf) dotareof(tarhandle);
  1606.     close(tarhandle);
  1607.     free(tarbuf);
  1608.     
  1609.     DEBUG(0, ("tar: dumped %d tar files\n", ntarf));
  1610.     DEBUG(0, ("Total bytes written: %d\n", ttarf));
  1611.     break;
  1612.   }
  1613.  
  1614.   return(0);
  1615. }
  1616.  
  1617. /****************************************************************************
  1618. Find a token (filename) in a clip list
  1619. ***************************************************************************/
  1620. int clipfind(char **aret, int ret, char *tok)
  1621. {
  1622.   if (aret==NULL) return 0;
  1623.  
  1624.   /* ignore leading slashes or dots in token */
  1625.   while(strchr("/\\.", *tok)) tok++;
  1626.  
  1627.   while(ret--) {
  1628.     char *pkey=*aret++;
  1629.  
  1630.     /* ignore leading slashes or dots in list */
  1631.     while(strchr("/\\.", *pkey)) pkey++;
  1632.  
  1633.     if (!strslashcmp(pkey, tok)) return 1;
  1634.   }
  1635.  
  1636.   return 0;
  1637. }
  1638.  
  1639. /****************************************************************************
  1640. Parse tar arguments. Sets tar_type, tar_excl, etc.
  1641. ***************************************************************************/
  1642. int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind)
  1643. {
  1644.   char tar_clipfl='\0';
  1645.  
  1646.   /* Reset back to defaults - could be from interactive version 
  1647.    * reset mode and archive mode left as they are though
  1648.    */
  1649.   tar_type='\0';
  1650.   tar_excl=True;
  1651.  
  1652.   while (*Optarg) 
  1653.     switch(*Optarg++) {
  1654.     case 'c':
  1655.       tar_type='c';
  1656.       break;
  1657.     case 'x':
  1658.       if (tar_type=='c') {
  1659.     printf("Tar must be followed by only one of c or x.\n");
  1660.     return 0;
  1661.       }
  1662.       tar_type='x';
  1663.       break;
  1664.     case 'b':
  1665.       if (Optind>=argc || !(blocksize=atoi(argv[Optind]))) {
  1666.     DEBUG(0,("Option b must be followed by valid blocksize\n"));
  1667.     return 0;
  1668.       } else {
  1669.     Optind++;
  1670.       }
  1671.       break;
  1672.     case 'g':
  1673.       tar_inc=True;
  1674.       break;
  1675.     case 'N':
  1676.       if (Optind>=argc) {
  1677.     DEBUG(0,("Option N must be followed by valid file name\n"));
  1678.     return 0;
  1679.       } else {
  1680.     struct stat stbuf;
  1681.     extern time_t newer_than;
  1682.     
  1683.     if (sys_stat(argv[Optind], &stbuf) == 0) {
  1684.       newer_than = stbuf.st_mtime;
  1685.       DEBUG(1,("Getting files newer than %s",
  1686.            asctime(LocalTime(&newer_than))));
  1687.       Optind++;
  1688.     } else {
  1689.       DEBUG(0,("Error setting newer-than time\n"));
  1690.       return 0;
  1691.     }
  1692.       }
  1693.       break;
  1694.     case 'a':
  1695.       tar_reset=True;
  1696.       break;
  1697.     case 'I':
  1698.       if (tar_clipfl) {
  1699.     DEBUG(0,("Only one of I,X must be specified\n"));
  1700.     return 0;
  1701.       }
  1702.       tar_clipfl='I';
  1703.       break;
  1704.     case 'X':
  1705.       if (tar_clipfl) {
  1706.     DEBUG(0,("Only one of I,X must be specified\n"));
  1707.     return 0;
  1708.       }
  1709.       tar_clipfl='X';
  1710.       break;
  1711.     default:
  1712.       DEBUG(0,("Unknown tar option\n"));
  1713.       return 0;
  1714.     }
  1715.  
  1716.   if (!tar_type) {
  1717.     printf("Option T must be followed by one of c or x.\n");
  1718.     return 0;
  1719.   }
  1720.  
  1721.   tar_excl=tar_clipfl!='X';
  1722.   if (Optind+1<argc) {
  1723.     cliplist=argv+Optind+1;
  1724.     clipn=argc-Optind-1;
  1725.   }
  1726.   if (Optind>=argc || !strcmp(argv[Optind], "-")) {
  1727.     /* Sets tar handle to either 0 or 1, as appropriate */
  1728.     tarhandle=(tar_type=='c');
  1729.   } else {
  1730.     if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY)) == -1)
  1731.     || (tar_type=='c' && (tarhandle=creat(argv[Optind], 0644)) < 0))
  1732.       {
  1733.     DEBUG(0,("Error opening local file %s\n",argv[Optind]));
  1734.     return(0);
  1735.       }
  1736.   }
  1737.  
  1738.   return 1;
  1739. }
  1740.