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