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