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