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