Change the multibyte character set support so that
[kai/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    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22
23 #include "includes.h"
24 #include "clitar.h"
25
26 extern BOOL recurse;
27
28 #define SEPARATORS " \t\n\r"
29 extern int DEBUGLEVEL;
30 extern int Client;
31
32 /* These defines are for the do_setrattr routine, to indicate
33  * setting and reseting of file attributes in the function call */
34 #define ATTRSET 1
35 #define ATTRRESET 0
36
37 static int attribute = aDIR | aSYSTEM | aHIDDEN;
38
39 #ifndef CLIENT_TIMEOUT
40 #define CLIENT_TIMEOUT (30*1000)
41 #endif
42
43 static char *tarbuf;
44 static int tp, ntarf, tbufsiz, ttarf;
45 /* Incremental mode */
46 BOOL tar_inc=False;
47 /* Reset archive bit */
48 BOOL tar_reset=False;
49 /* Include / exclude mode (true=include, false=exclude) */
50 BOOL tar_excl=True;
51 char tar_type='\0';
52 static char **cliplist=NULL;
53 static int clipn=0;
54
55 extern file_info def_finfo;
56 extern BOOL lowercase;
57 extern int cnum;
58 extern BOOL readbraw_supported;
59 extern int max_xmit;
60 extern pstring cur_dir;
61 extern int get_total_time_ms;
62 extern int get_total_size;
63 extern int Protocol;
64
65 int blocksize=20;
66 int tarhandle;
67
68 static void writetarheader();
69 static void do_atar();
70 static void do_tar();
71 static void oct_it();
72 static void fixtarname();
73 static int dotarbuf();
74 static void dozerobuf();
75 static void dotareof();
76 static void initarbuf();
77 static int do_setrattr();
78
79 /* restore functions */
80 static long readtarheader();
81 static long unoct();
82 static void do_tarput();
83 static void unfixtarname();
84
85 /*
86  * tar specific utitlities
87  */
88
89 /****************************************************************************
90 Write a tar header to buffer
91 ****************************************************************************/
92 static void writetarheader(int f,  char *aname, int size, time_t mtime,
93                            char *amode)
94 {
95   union hblock hb;
96   int i, chk, l;
97   char *jp;
98
99   memset(hb.dummy, 0, sizeof(hb.dummy));
100   
101   l=strlen(aname);
102   if (l >= NAMSIZ) {
103           /* write a GNU tar style long header */
104           char *b;
105           b = (char *)malloc(l+TBLOCK+100);
106           if (!b) {
107                   DEBUG(0,("out of memory\n"));
108                   exit(1);
109           }
110           writetarheader(f, "/./@LongLink", l+1, 0, "     0 \0");
111           memset(b, 0, l+TBLOCK+100);
112           fixtarname(b, aname, l+1);
113           i = strlen(b)+1;
114           dotarbuf(f, b, TBLOCK*(((i-1)/TBLOCK)+1));
115           free(b);
116   }
117
118   /* use l + 1 to do the null too */
119   fixtarname(hb.dbuf.name, aname, (l >= NAMSIZ) ? NAMSIZ : l + 1);
120
121   if (lowercase)
122     strlower(hb.dbuf.name);
123
124   /* write out a "standard" tar format header */
125
126   hb.dbuf.name[NAMSIZ-1]='\0';
127   strcpy(hb.dbuf.mode, amode);
128   oct_it(0L, 8, hb.dbuf.uid);
129   oct_it(0L, 8, hb.dbuf.gid);
130   oct_it((long) size, 13, hb.dbuf.size);
131   oct_it((long) mtime, 13, hb.dbuf.mtime);
132   memcpy(hb.dbuf.chksum, "        ", sizeof(hb.dbuf.chksum));
133   memset(hb.dbuf.linkname, 0, NAMSIZ);
134   if (strcmp("/./@LongLink", aname) == 0) {
135           /* we're doing a GNU tar long filename */
136           hb.dbuf.linkflag='L';
137   } else {
138           hb.dbuf.linkflag='0';
139   }
140   
141   for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;) chk+=(0xFF & *jp++);
142
143   oct_it((long) chk, 8, hb.dbuf.chksum);
144   hb.dbuf.chksum[6] = '\0';
145
146   (void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
147 }
148
149 /****************************************************************************
150 Read a tar header into a hblock structure, and validate
151 ***************************************************************************/
152 static long readtarheader(union hblock *hb, file_info *finfo, char *prefix)
153 {
154   long chk, fchk;
155   int i;
156   char *jp;
157
158   /*
159    * read in a "standard" tar format header - we're not that interested
160    * in that many fields, though
161    */
162
163   /* check the checksum */
164   for (chk=0, i=sizeof(hb->dummy), jp=hb->dummy; --i>=0;) chk+=(0xFF & *jp++);
165
166   if (chk == 0)
167     return chk;
168
169   /* compensate for blanks in chksum header */
170   for (i=sizeof(hb->dbuf.chksum), jp=hb->dbuf.chksum; --i>=0;)
171     chk-=(0xFF & *jp++);
172
173   chk += ' ' * sizeof(hb->dbuf.chksum);
174
175   fchk=unoct(hb->dbuf.chksum, sizeof(hb->dbuf.chksum));
176
177   DEBUG(5, ("checksum totals chk=%d fchk=%d chksum=%s\n",
178             chk, fchk, hb->dbuf.chksum));
179
180   if (fchk != chk)
181     {
182       DEBUG(0, ("checksums don't match %d %d\n", fchk, chk));
183       return -1;
184     }
185
186   strcpy(finfo->name, prefix);
187
188   /* use l + 1 to do the null too; do prefix - prefcnt to zap leading slash */
189   unfixtarname(finfo->name + strlen(prefix), hb->dbuf.name,
190                strlen(hb->dbuf.name) + 1);
191
192 /* can't handle links at present */
193   if (hb->dbuf.linkflag != '0') {
194     if (hb->dbuf.linkflag == 0) {
195       DEBUG(6, ("Warning: NULL link flag (gnu tar archive ?) %s\n",
196                 finfo->name));
197     } else { 
198       DEBUG(0, ("this tar file appears to contain some kind of link - ignoring\n"));
199       return -2;
200     }
201   }
202     
203   if ((unoct(hb->dbuf.mode, sizeof(hb->dbuf.mode)) & S_IFDIR)
204     || (*(finfo->name+strlen(finfo->name)-1) == '\\'))
205     {
206       finfo->mode=aDIR;
207     }
208   else
209     finfo->mode=0; /* we don't care about mode at the moment, we'll
210                     * just make it a regular file */
211   /*
212    * Bug fix by richard@sj.co.uk
213    *
214    * REC: restore times correctly (as does tar)
215    * We only get the modification time of the file; set the creation time
216    * from the mod. time, and the access time to current time
217    */
218   finfo->mtime = finfo->ctime = strtol(hb->dbuf.mtime, NULL, 8);
219   finfo->atime = time(NULL);
220   finfo->size = unoct(hb->dbuf.size, sizeof(hb->dbuf.size));
221
222   return True;
223 }
224
225 /****************************************************************************
226 Write out the tar buffer to tape or wherever
227 ****************************************************************************/
228 static int dotarbuf(int f, char *b, int n)
229 {
230   int fail=1, writ=n;
231
232   /* This routine and the next one should be the only ones that do write()s */
233   if (tp + n >= tbufsiz)
234     {
235       int diff;
236
237       diff=tbufsiz-tp;
238       memcpy(tarbuf + tp, b, diff);
239       fail=fail && (1+write(f, tarbuf, tbufsiz));
240       n-=diff;
241       b+=diff;
242       tp=0;
243
244       while (n >= tbufsiz)
245         {
246           fail=fail && (1 + write(f, b, tbufsiz));
247           n-=tbufsiz;
248           b+=tbufsiz;
249         }
250     }
251   if (n>0) {
252     memcpy(tarbuf+tp, b, n);
253     tp+=n;
254   }
255
256   return(fail ? writ : 0);
257 }
258
259 /****************************************************************************
260 Write a zeros to buffer / tape
261 ****************************************************************************/
262 static void dozerobuf(int f, int n)
263 {
264   /* short routine just to write out n zeros to buffer -
265    * used to round files to nearest block
266    * and to do tar EOFs */
267
268   if (n+tp >= tbufsiz)
269     {
270       memset(tarbuf+tp, 0, tbufsiz-tp);
271       write(f, tarbuf, tbufsiz);
272       memset(tarbuf, 0, (tp+=n-tbufsiz));
273     }
274   else
275     {
276       memset(tarbuf+tp, 0, n);
277       tp+=n;
278     }
279 }
280
281 /****************************************************************************
282 Malloc tape buffer
283 ****************************************************************************/
284 static void initarbuf()
285 {
286   /* initialize tar buffer */
287   tbufsiz=blocksize*TBLOCK;
288   tarbuf=malloc(tbufsiz);
289
290   /* reset tar buffer pointer and tar file counter and total dumped */
291   tp=0; ntarf=0; ttarf=0;
292 }
293
294 /****************************************************************************
295 Write two zero blocks at end of file
296 ****************************************************************************/
297 static void dotareof(int f)
298 {
299   struct stat stbuf;
300   /* Two zero blocks at end of file, write out full buffer */
301
302   (void) dozerobuf(f, TBLOCK);
303   (void) dozerobuf(f, TBLOCK);
304
305   if (fstat(f, &stbuf) == -1)
306     {
307       DEBUG(0, ("Couldn't stat file handle\n"));
308       return;
309     }
310
311   /* Could be a pipe, in which case S_ISREG should fail,
312    * and we should write out at full size */
313   if (tp > 0) write(f, tarbuf, S_ISREG(stbuf.st_mode) ? tp : tbufsiz);
314 }
315
316 /****************************************************************************
317 (Un)mangle DOS pathname, make nonabsolute
318 ****************************************************************************/
319 static void fixtarname(char *tptr, char *fp, int l)
320 {
321   /* add a '.' to start of file name, convert from ugly dos \'s in path
322    * to lovely unix /'s :-} */
323
324   *tptr++='.';
325
326   while (l > 0) {
327     int skip;
328     if((skip = skip_multibyte_char( *fp)) != 0) {
329       if (skip == 2) {
330         *tptr++ = *fp++;
331         *tptr++ = *fp++;
332         l -= 2;
333       } else if (skip == 1) {
334         *tptr++ = *fp++;
335         l--;
336       }
337     } else if (*fp == '\\') {
338       *tptr++ = '/';
339       fp++;
340       l--;
341     } else {
342       *tptr++ = *fp++;
343       l--;
344     }
345   }
346 }
347
348 /****************************************************************************
349 Convert from decimal to octal string
350 ****************************************************************************/
351 static void oct_it (register long value, register int ndgs, register char *p)
352 {
353   /* Converts long to octal string, pads with leading zeros */
354
355   /* skip final null, but do final space */
356   --ndgs;
357   p[--ndgs] = ' ';
358  
359   /* Loop does at least one digit */
360   do {
361       p[--ndgs] = '0' + (char) (value & 7);
362       value >>= 3;
363     }
364   while (ndgs > 0 && value != 0);
365  
366   /* Do leading zeros */
367   while (ndgs > 0)
368     p[--ndgs] = '0';
369 }
370
371 /****************************************************************************
372 Convert from octal string to long
373 ***************************************************************************/
374 static long unoct(char *p, int ndgs)
375 {
376   long value=0;
377   /* Converts octal string to long, ignoring any non-digit */
378
379   while (--ndgs)
380     {
381       if (isdigit(*p))
382         value = (value << 3) | (long) (*p - '0');
383
384       p++;
385     }
386
387   return value;
388 }
389
390 /****************************************************************************
391 Compare two strings in a slash insensitive way, allowing s1 to match s2 
392 if s1 is an "initial" string (up to directory marker).  Thus, if s2 is 
393 a file in any subdirectory of s1, declare a match.
394 ***************************************************************************/
395 static int strslashcmp(char *s1, char *s2)
396 {
397   char *s1_0=s1;
398
399   while(*s1 && *s2 &&
400         (*s1 == *s2
401          || tolower(*s1) == tolower(*s2)
402          || (*s1 == '\\' && *s2=='/')
403          || (*s1 == '/' && *s2=='\\'))) {
404           s1++; s2++;
405   }
406
407   /* if s1 has a trailing slash, it compared equal, so s1 is an "initial" 
408      string of s2.
409    */
410   if (!*s1 && s1 != s1_0 && (*(s1-1) == '/' || *(s1-1) == '\\')) return 0;
411
412   /* ignore trailing slash on s1 */
413   if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1)) return 0;
414
415   /* check for s1 is an "initial" string of s2 */
416   if (*s2 == '/' || *s2 == '\\') return 0;
417
418   return *s1-*s2;
419 }
420
421 /*
422  * general smb utility functions
423  */
424 /****************************************************************************
425 Set DOS file attributes
426 ***************************************************************************/
427 static int do_setrattr(char *fname, int attr, int setit)
428 {
429   /*
430    * First get the existing attribs from existing file
431    */
432   char *inbuf,*outbuf;
433   char *p;
434   pstring name;
435   int fattr;
436
437   strcpy(name,fname);
438   strcpy(fname,"\\");
439   strcat(fname,name);
440
441   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
442   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
443
444   if (!inbuf || !outbuf)
445     {
446       DEBUG(0,("out of memory\n"));
447       return False;
448     }
449
450   /* send an smb getatr message */
451
452   memset(outbuf,0,smb_size);
453   set_message(outbuf,0,2 + strlen(fname),True);
454   CVAL(outbuf,smb_com) = SMBgetatr;
455   SSVAL(outbuf,smb_tid,cnum);
456   cli_setup_pkt(outbuf);
457
458   p = smb_buf(outbuf);
459   *p++ = 4;
460   strcpy(p,fname);
461   p += (strlen(fname)+1);
462   
463   *p++ = 4;
464   *p++ = 0;
465
466   send_smb(Client,outbuf);
467   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
468
469   if (CVAL(inbuf,smb_rcls) != 0)
470     DEBUG(5,("getatr: %s\n",smb_errstr(inbuf)));
471   else
472     {
473       DEBUG(5,("\nattr 0x%X  time %d  size %d\n",
474                (int)CVAL(inbuf,smb_vwv0),
475                SVAL(inbuf,smb_vwv1),
476                SVAL(inbuf,smb_vwv3)));
477     }
478
479   fattr=CVAL(inbuf,smb_vwv0);
480
481   /* combine found attributes with bits to be set or reset */
482
483   attr=setit ? (fattr | attr) : (fattr & ~attr);
484
485   /* now try and set attributes by sending smb reset message */
486
487   /* clear out buffer and start again */
488   memset(outbuf,0,smb_size);
489   set_message(outbuf,8,4 + strlen(fname),True);
490   CVAL(outbuf,smb_com) = SMBsetatr;
491   SSVAL(outbuf,smb_tid,cnum);
492   cli_setup_pkt(outbuf);
493
494   SSVAL(outbuf,smb_vwv0,attr);
495
496   p = smb_buf(outbuf);
497   *p++ = 4;      
498   strcpy(p,fname);
499   p += (strlen(fname)+1);
500   
501   *p++ = 4;
502   *p++ = 0;
503
504   send_smb(Client,outbuf);
505   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
506   
507   if (CVAL(inbuf,smb_rcls) != 0)
508     {
509       DEBUG(0,("%s setting attributes on file %s\n",
510             smb_errstr(inbuf), fname));
511       free(inbuf);free(outbuf);
512       return(False);
513     }
514
515   free(inbuf);free(outbuf);
516   return(True);
517 }
518
519 /****************************************************************************
520 Create a file on a share
521 ***************************************************************************/
522 static BOOL smbcreat(file_info finfo, int *fnum, char *inbuf, char *outbuf)
523 {
524   char *p;
525   /* *must* be called with buffer ready malloc'ed */
526   /* open remote file */
527   
528   memset(outbuf,0,smb_size);
529   set_message(outbuf,3,2 + strlen(finfo.name),True);
530   CVAL(outbuf,smb_com) = SMBcreate;
531   SSVAL(outbuf,smb_tid,cnum);
532   cli_setup_pkt(outbuf);
533   
534   SSVAL(outbuf,smb_vwv0,finfo.mode);
535   put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
536   
537   p = smb_buf(outbuf);
538   *p++ = 4;      
539   strcpy(p,finfo.name);
540   
541   send_smb(Client,outbuf);
542   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
543   
544   if (CVAL(inbuf,smb_rcls) != 0)
545     {
546       DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),
547                finfo.name));
548       return 0;
549     }
550   
551   *fnum = SVAL(inbuf,smb_vwv0);
552   return True;
553 }
554
555 /****************************************************************************
556 Write a file to a share
557 ***************************************************************************/
558 static BOOL smbwrite(int fnum, int n, int low, int high, int left,
559                      char *bufferp, char *inbuf, char *outbuf)
560 {
561   /* *must* be called with buffer ready malloc'ed */
562
563   memset(outbuf,0,smb_size);
564   set_message(outbuf,5,n + 3,True);
565   
566   memcpy(smb_buf(outbuf)+3, bufferp, n);
567   
568   set_message(outbuf,5,n + 3, False);
569   CVAL(outbuf,smb_com) = SMBwrite;
570   SSVAL(outbuf,smb_tid,cnum);
571   cli_setup_pkt(outbuf);
572   
573   SSVAL(outbuf,smb_vwv0,fnum);
574   SSVAL(outbuf,smb_vwv1,n);
575   SIVAL(outbuf,smb_vwv2,low);
576   SSVAL(outbuf,smb_vwv4,left);
577   CVAL(smb_buf(outbuf),0) = 1;
578   SSVAL(smb_buf(outbuf),1,n);
579
580   send_smb(Client,outbuf); 
581   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
582   
583   if (CVAL(inbuf,smb_rcls) != 0)
584     {
585       DEBUG(0,("%s writing remote file\n",smb_errstr(inbuf)));
586       return False;
587     }
588   
589   if (n != SVAL(inbuf,smb_vwv0))
590     {
591       DEBUG(0,("Error: only wrote %d bytes out of %d\n",
592                SVAL(inbuf,smb_vwv0), n));
593       return False;
594     }
595
596   return True;
597 }
598
599 /****************************************************************************
600 Close a file on a share
601 ***************************************************************************/
602 static BOOL smbshut(file_info finfo, int fnum, char *inbuf, char *outbuf)
603 {
604   /* *must* be called with buffer ready malloc'ed */
605
606   memset(outbuf,0,smb_size);
607   set_message(outbuf,3,0,True);
608   CVAL(outbuf,smb_com) = SMBclose;
609   SSVAL(outbuf,smb_tid,cnum);
610   cli_setup_pkt(outbuf);
611   
612   SSVAL(outbuf,smb_vwv0,fnum);
613   put_dos_date3(outbuf,smb_vwv1,finfo.mtime);
614   
615   DEBUG(3,("Setting date to %s (0x%X)",
616            asctime(LocalTime(&finfo.mtime)),
617            finfo.mtime));
618   
619   send_smb(Client,outbuf);
620   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
621   
622   if (CVAL(inbuf,smb_rcls) != 0)
623     {
624       DEBUG(0,("%s closing remote file %s\n",smb_errstr(inbuf),
625                finfo.name));
626       return False;
627     }
628
629   return True;
630 }
631
632 /****************************************************************************
633 Verify existence of path on share
634 ***************************************************************************/
635 static BOOL smbchkpath(char *fname, char *inbuf, char *outbuf)
636 {
637   char *p;
638
639   memset(outbuf,0,smb_size);
640   set_message(outbuf,0,4 + strlen(fname),True);
641   CVAL(outbuf,smb_com) = SMBchkpth;
642   SSVAL(outbuf,smb_tid,cnum);
643   cli_setup_pkt(outbuf);
644
645   p = smb_buf(outbuf);
646   *p++ = 4;
647   strcpy(p,fname);
648
649   send_smb(Client,outbuf);
650   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
651
652   DEBUG(5,("smbchkpath: %s\n",smb_errstr(inbuf)));
653
654   return(CVAL(inbuf,smb_rcls) == 0);
655 }
656
657 /****************************************************************************
658 Make a directory on share
659 ***************************************************************************/
660 static BOOL smbmkdir(char *fname, char *inbuf, char *outbuf)
661 {
662   /* *must* be called with buffer ready malloc'ed */
663   char *p;
664
665   memset(outbuf,0,smb_size);
666   set_message(outbuf,0,2 + strlen(fname),True);
667   
668   CVAL(outbuf,smb_com) = SMBmkdir;
669   SSVAL(outbuf,smb_tid,cnum);
670   cli_setup_pkt(outbuf);
671   
672   p = smb_buf(outbuf);
673   *p++ = 4;      
674   strcpy(p,fname);
675   
676   send_smb(Client,outbuf);
677   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
678   
679   if (CVAL(inbuf,smb_rcls) != 0)
680     {
681       DEBUG(0,("%s making remote directory %s\n",
682                smb_errstr(inbuf),fname));
683       return(False);
684     }
685
686   return(True);
687 }
688
689 /****************************************************************************
690 Ensure a remote path exists (make if necessary)
691 ***************************************************************************/
692 static BOOL ensurepath(char *fname, char *inbuf, char *outbuf)
693 {
694   /* *must* be called with buffer ready malloc'ed */
695   /* ensures path exists */
696
697   pstring partpath, ffname;
698   char *p=fname, *basehack;
699
700   *partpath = 0;
701
702   /* fname copied to ffname so can strtok */
703
704   strcpy(ffname, fname);
705
706   /* do a `basename' on ffname, so don't try and make file name directory */
707   if ((basehack=strrchr(ffname, '\\')) == NULL)
708     return True;
709   else
710     *basehack='\0';
711
712   p=strtok(ffname, "\\");
713
714   while (p)
715     {
716       strcat(partpath, p);
717
718       if (!smbchkpath(partpath, inbuf, outbuf)) {
719         if (!smbmkdir(partpath, inbuf, outbuf))
720           {
721             DEBUG(0, ("Error mkdirhiering\n"));
722             return False;
723           }
724         else
725           DEBUG(3, ("mkdirhiering %s\n", partpath));
726
727       }
728
729       strcat(partpath, "\\");
730       p = strtok(NULL,"/\\");
731     }
732
733     return True;
734 }
735
736 int padit(char *buf, int bufsize, int padsize)
737 {
738   int berr= 0;
739   int bytestowrite;
740   
741   DEBUG(0, ("Padding with %d zeros\n", padsize));
742   memset(buf, 0, bufsize);
743   while( !berr && padsize > 0 ) {
744     bytestowrite= MIN(bufsize, padsize);
745     berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite;
746     padsize -= bytestowrite;
747   }
748   
749   return berr;
750 }
751
752 /*
753  * smbclient functions
754  */
755 /****************************************************************************
756 append one remote file to the tar file
757 ***************************************************************************/
758 static void do_atar(char *rname,char *lname,file_info *finfo1)
759 {
760   int fnum;
761   uint32 nread=0;
762   char *p;
763   char *inbuf,*outbuf;
764   file_info finfo;
765   BOOL close_done = False;
766   BOOL shallitime=True;
767   BOOL ignore_close_error = False;
768   char *dataptr=NULL;
769   int datalen=0;
770
771   struct timeval tp_start;
772   GetTimeOfDay(&tp_start);
773
774   if (finfo1) 
775     finfo = *finfo1;
776   else
777     finfo = def_finfo;
778
779   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
780   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
781
782   if (!inbuf || !outbuf)
783     {
784       DEBUG(0,("out of memory\n"));
785       return;
786     }
787
788   memset(outbuf,0,smb_size);
789   set_message(outbuf,15,1 + strlen(rname),True);
790
791   CVAL(outbuf,smb_com) = SMBopenX;
792   SSVAL(outbuf,smb_tid,cnum);
793   cli_setup_pkt(outbuf);
794
795   SSVAL(outbuf,smb_vwv0,0xFF);
796   SSVAL(outbuf,smb_vwv2,1);
797   SSVAL(outbuf,smb_vwv3,(DENY_NONE<<4));
798   SSVAL(outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
799   SSVAL(outbuf,smb_vwv5,aSYSTEM | aHIDDEN);
800   SSVAL(outbuf,smb_vwv8,1);
801
802   p = smb_buf(outbuf);
803   strcpy(p,rname);
804   p = skip_string(p,1);
805
806   dos_clean_name(rname);
807
808   /* do a chained openX with a readX? */  
809   if (finfo.size > 0)
810     {
811       SSVAL(outbuf,smb_vwv0,SMBreadX);
812       SSVAL(outbuf,smb_vwv1,PTR_DIFF(p,outbuf) - 4);
813       memset(p,0,200);
814       p -= smb_wct;
815       SSVAL(p,smb_wct,10);
816       SSVAL(p,smb_vwv0,0xFF);
817       SSVAL(p,smb_vwv5,MIN(max_xmit-500,finfo.size));
818       SSVAL(p,smb_vwv9,MIN(0xFFFF,finfo.size));
819       smb_setlen(outbuf,smb_len(outbuf)+11*2+1);  
820     }
821   
822   send_smb(Client,outbuf);
823   client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
824
825   if (CVAL(inbuf,smb_rcls) != 0)
826     {
827       if (CVAL(inbuf,smb_rcls) == ERRSRV &&
828           SVAL(inbuf,smb_err) == ERRnoresource &&
829           cli_reopen_connection(inbuf,outbuf))
830         {
831           do_atar(rname,lname,finfo1);
832           free(inbuf);free(outbuf);
833           return;
834         }
835
836       DEBUG(0,("%s opening remote file %s\n",smb_errstr(inbuf),rname));
837       free(inbuf);free(outbuf);
838       return;
839     }
840
841   strcpy(finfo.name,rname);
842   if (!finfo1)
843     {
844       finfo.mode = SVAL(inbuf,smb_vwv3);
845       finfo.size = IVAL(inbuf,smb_vwv4);
846       finfo.mtime = make_unix_date3(inbuf+smb_vwv6);
847       finfo.atime = finfo.ctime = finfo.mtime;
848     }
849
850   DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
851
852   fnum = SVAL(inbuf,smb_vwv2);
853
854   if (tar_inc && !(finfo.mode & aARCH))
855     {
856       DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name));
857       shallitime=0;
858     }
859   else
860     {
861       if (SVAL(inbuf,smb_vwv0) == SMBreadX)
862         {
863           p = (inbuf+4+SVAL(inbuf,smb_vwv1)) - smb_wct;
864           datalen = SVAL(p,smb_vwv5);
865           dataptr = inbuf + 4 + SVAL(p,smb_vwv6);
866         }
867       else
868         {
869           dataptr = NULL;
870           datalen = 0;
871         }
872
873       DEBUG(1,("getting file %s of size %d bytes as a tar file %s",
874                finfo.name,
875                finfo.size,
876                lname));
877       
878       /* write a tar header, don't bother with mode - just set to 100644 */
879       writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0");
880       
881       while (nread < finfo.size && !close_done)
882         {
883           int method = -1;
884           static BOOL can_chain_close=True;
885
886           p=NULL;
887           
888           DEBUG(3,("nread=%d\n",nread));
889           
890           /* 3 possible read types. readbraw if a large block is required.
891              readX + close if not much left and read if neither is supported */
892
893           /* we might have already read some data from a chained readX */
894           if (dataptr && datalen>0)
895             method=3;
896           
897           /* if we can finish now then readX+close */
898           if (method<0 && can_chain_close && (Protocol >= PROTOCOL_LANMAN1) && 
899               ((finfo.size - nread) < 
900                (max_xmit - (2*smb_size + 13*SIZEOFWORD + 300))))
901             method = 0;
902           
903           /* if we support readraw then use that */
904           if (method<0 && readbraw_supported)
905             method = 1;
906           
907           /* if we can then use readX */
908           if (method<0 && (Protocol >= PROTOCOL_LANMAN1))
909             method = 2;
910           
911           
912           switch (method)
913             {
914               /* use readX */
915             case 0:
916             case 2:
917               if (method == 0)
918                 close_done = True;
919               
920               /* use readX + close */
921               memset(outbuf,0,smb_size);
922               set_message(outbuf,10,0,True);
923               CVAL(outbuf,smb_com) = SMBreadX;
924               SSVAL(outbuf,smb_tid,cnum);
925               cli_setup_pkt(outbuf);
926               
927               if (close_done)
928                 {
929                   CVAL(outbuf,smb_vwv0) = SMBclose;
930                   SSVAL(outbuf,smb_vwv1,PTR_DIFF(smb_buf(outbuf),outbuf) - 4);
931                 }
932               else
933                 CVAL(outbuf,smb_vwv0) = 0xFF;         
934               
935               
936               SSVAL(outbuf,smb_vwv2,fnum);
937               SIVAL(outbuf,smb_vwv3,nread);
938               SSVAL(outbuf,smb_vwv5,MIN(max_xmit-200,finfo.size - nread));
939               SSVAL(outbuf,smb_vwv6,0);
940               SIVAL(outbuf,smb_vwv7,0);
941               SSVAL(outbuf,smb_vwv9,MIN(0xFFFF,finfo.size-nread));
942               
943               if (close_done)
944                 {
945                   p = smb_buf(outbuf);
946                   memset(p,0,9);
947                   
948                   CVAL(p,0) = 3;
949                   SSVAL(p,1,fnum);
950                   SIVALS(p,3,-1);
951                   
952                   /* now set the total packet length */
953                   smb_setlen(outbuf,smb_len(outbuf)+9);
954                 }
955               
956               send_smb(Client,outbuf);
957               client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
958               
959               if (CVAL(inbuf,smb_rcls) != 0)
960                 {
961                   DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
962                   break;
963                 }
964               
965               if (close_done &&
966                   SVAL(inbuf,smb_vwv0) != SMBclose)
967                 {
968                   /* NOTE: WfWg sometimes just ignores the chained
969                      command! This seems to break the spec? */
970                   DEBUG(3,("Rejected chained close?\n"));
971                   close_done = False;
972                   can_chain_close = False;
973                   ignore_close_error = True;
974                 }
975               
976               datalen = SVAL(inbuf,smb_vwv5);
977               dataptr = inbuf + 4 + SVAL(inbuf,smb_vwv6);
978               break;
979               
980               
981               /* use readbraw */
982             case 1:
983               {
984                 static int readbraw_size = 0xFFFF;
985                 
986                 extern int Client;
987                 memset(outbuf,0,smb_size);
988                 set_message(outbuf,8,0,True);
989                 CVAL(outbuf,smb_com) = SMBreadbraw;
990                 SSVAL(outbuf,smb_tid,cnum);
991                 cli_setup_pkt(outbuf);
992                 SSVAL(outbuf,smb_vwv0,fnum);
993                 SIVAL(outbuf,smb_vwv1,nread);
994                 SSVAL(outbuf,smb_vwv3,MIN(finfo.size-nread,readbraw_size));
995                 SSVAL(outbuf,smb_vwv4,0);
996                 SIVALS(outbuf,smb_vwv5,-1);
997                 send_smb(Client,outbuf);
998                 
999                 /* Now read the raw data into the buffer and write it */          
1000                 if(read_smb_length(Client,inbuf,0) == -1) {
1001                   DEBUG(0,("Failed to read length in readbraw\n"));         
1002                   exit(1);
1003                 }
1004                 
1005                 /* Even though this is not an smb message, smb_len
1006                    returns the generic length of an smb message */
1007                 datalen = smb_len(inbuf);
1008                 
1009                 if (datalen == 0)
1010                   {
1011                     /* we got a readbraw error */
1012                     DEBUG(4,("readbraw error - reducing size\n"));
1013                     readbraw_size = (readbraw_size * 9) / 10;
1014                     
1015                     if (readbraw_size < max_xmit)
1016                       {
1017                         DEBUG(0,("disabling readbraw\n"));
1018                         readbraw_supported = False;
1019                       }
1020
1021                     dataptr=NULL;
1022                     continue;
1023                   }
1024
1025                 if(read_data(Client,inbuf,datalen) != datalen) {
1026                   DEBUG(0,("Failed to read data in readbraw\n"));
1027                   exit(1);
1028                 }
1029                 dataptr = inbuf;
1030               }
1031               break;
1032
1033             case 3:
1034               /* we've already read some data with a chained readX */
1035               break;
1036               
1037             default:
1038               /* use plain read */
1039               memset(outbuf,0,smb_size);
1040               set_message(outbuf,5,0,True);
1041               CVAL(outbuf,smb_com) = SMBread;
1042               SSVAL(outbuf,smb_tid,cnum);
1043               cli_setup_pkt(outbuf);
1044               
1045               SSVAL(outbuf,smb_vwv0,fnum);
1046               SSVAL(outbuf,smb_vwv1,MIN(max_xmit-200,finfo.size - nread));
1047               SIVAL(outbuf,smb_vwv2,nread);
1048               SSVAL(outbuf,smb_vwv4,finfo.size - nread);
1049               
1050               send_smb(Client,outbuf);
1051               client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
1052               
1053               if (CVAL(inbuf,smb_rcls) != 0)
1054                 {
1055                   DEBUG(0,("Error %s reading remote file\n",smb_errstr(inbuf)));
1056                   break;
1057                 }
1058               
1059               datalen = SVAL(inbuf,smb_vwv0);
1060               dataptr = smb_buf(inbuf) + 3;
1061               break;
1062             }
1063           
1064           
1065           /* add received bits of file to buffer - dotarbuf will
1066            * write out in 512 byte intervals */
1067           if (dotarbuf(tarhandle,dataptr,datalen) != datalen)
1068             {
1069               DEBUG(0,("Error writing to tar file - %s\n", strerror(errno)));
1070               break;
1071             }
1072           
1073           nread += datalen;
1074           if (datalen == 0) 
1075             {
1076               DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
1077               break;
1078             }
1079
1080           dataptr=NULL;
1081           datalen=0;
1082         }
1083
1084        /* pad tar file with zero's if we couldn't get entire file */
1085        if (nread < finfo.size)
1086         {
1087           DEBUG(0, ("Didn't get entire file. size=%d, nread=%d\n", finfo.size, nread));
1088           if (padit(inbuf, BUFFER_SIZE, finfo.size - nread))
1089               DEBUG(0,("Error writing tar file - %s\n", strerror(errno)));
1090         }
1091
1092       /* round tar file to nearest block */
1093       if (finfo.size % TBLOCK)
1094         dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));
1095       
1096       ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
1097       ntarf++;
1098     }
1099   
1100   if (!close_done)
1101     {
1102       memset(outbuf,0,smb_size);
1103       set_message(outbuf,3,0,True);
1104       CVAL(outbuf,smb_com) = SMBclose;
1105       SSVAL(outbuf,smb_tid,cnum);
1106       cli_setup_pkt(outbuf);
1107       
1108       SSVAL(outbuf,smb_vwv0,fnum);
1109       SIVALS(outbuf,smb_vwv1,-1);
1110       
1111       send_smb(Client,outbuf);
1112       client_receive_smb(Client,inbuf,CLIENT_TIMEOUT);
1113       
1114       if (!ignore_close_error && CVAL(inbuf,smb_rcls) != 0)
1115         {
1116           DEBUG(0,("Error %s closing remote file\n",smb_errstr(inbuf)));
1117           free(inbuf);free(outbuf);
1118           return;
1119         }
1120     }
1121
1122   if (shallitime)
1123     {
1124       struct timeval tp_end;
1125       int this_time;
1126
1127       /* if shallitime is true then we didn't skip */
1128       if (tar_reset) (void) do_setrattr(finfo.name, aARCH, ATTRRESET);
1129       
1130       GetTimeOfDay(&tp_end);
1131       this_time = 
1132         (tp_end.tv_sec - tp_start.tv_sec)*1000 +
1133           (tp_end.tv_usec - tp_start.tv_usec)/1000;
1134       get_total_time_ms += this_time;
1135       get_total_size += finfo.size;
1136
1137       /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
1138       DEBUG(1,("(%g kb/s) (average %g kb/s)\n",
1139                finfo.size / MAX(0.001, (1.024*this_time)),
1140                get_total_size / MAX(0.001, (1.024*get_total_time_ms))));
1141     }
1142   
1143   free(inbuf);free(outbuf);
1144 }
1145
1146 /****************************************************************************
1147 Append single file to tar file (or not)
1148 ***************************************************************************/
1149 static void do_tar(file_info *finfo)
1150 {
1151   pstring rname;
1152
1153   if (strequal(finfo->name,".") || strequal(finfo->name,".."))
1154     return;
1155
1156   /* Is it on the exclude list ? */
1157   if (!tar_excl && clipn) {
1158     pstring exclaim;
1159
1160     strcpy(exclaim, cur_dir);
1161     *(exclaim+strlen(exclaim)-1)='\0';
1162
1163     strcat(exclaim, "\\");
1164     strcat(exclaim, finfo->name);
1165
1166     if (clipfind(cliplist, clipn, exclaim)) {
1167       DEBUG(3,("Skipping file %s\n", exclaim));
1168       return;
1169     }
1170   }
1171
1172   if (finfo->mode & aDIR)
1173     {
1174       pstring saved_curdir;
1175       pstring mtar_mask;
1176       char *inbuf,*outbuf;
1177
1178       inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1179       outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1180
1181       if (!inbuf || !outbuf)
1182         {
1183           DEBUG(0,("out of memory\n"));
1184           return;
1185         }
1186
1187       strcpy(saved_curdir,cur_dir);
1188
1189       strcat(cur_dir,finfo->name);
1190       strcat(cur_dir,"\\");
1191
1192       /* write a tar directory, don't bother with mode - just set it to
1193        * 40755 */
1194       writetarheader(tarhandle, cur_dir, 0, finfo->mtime, "040755 \0");
1195       strcpy(mtar_mask,cur_dir);
1196       strcat(mtar_mask,"*");
1197       
1198       do_dir((char *)inbuf,(char *)outbuf,mtar_mask,attribute,do_tar,recurse);
1199       strcpy(cur_dir,saved_curdir);
1200       free(inbuf);free(outbuf);
1201     }
1202   else
1203     {
1204       strcpy(rname,cur_dir);
1205       strcat(rname,finfo->name);
1206       do_atar(rname,finfo->name,finfo);
1207     }
1208 }
1209
1210 /****************************************************************************
1211 Convert from UNIX to DOS file names
1212 ***************************************************************************/
1213 static void unfixtarname(char *tptr, char *fp, int l)
1214 {
1215   /* remove '.' from start of file name, convert from unix /'s to
1216    * dos \'s in path. Kill any absolute path names.
1217    */
1218
1219   if (*fp == '.') fp++;
1220   if (*fp == '\\' || *fp == '/') fp++;
1221
1222   while (l > 0) {
1223     int skip;
1224     if(( skip = skip_multibyte_char( *fp )) != 0) {
1225       if (skip == 2) {
1226         *tptr++ = *fp++;
1227         *tptr++ = *fp++;
1228         l -= 2;
1229       } else if (skip == 1) {
1230         *tptr++ = *fp++;
1231         l--;
1232       }
1233     } else if (*fp == '/') {
1234       *tptr++ = '\\';
1235       fp++;
1236       l--;
1237     } else {
1238       *tptr++ = *fp++;
1239       l--;
1240     }
1241   }
1242 }
1243
1244 static void do_tarput()
1245 {
1246   file_info finfo;
1247   int nread=0, bufread;
1248   char *inbuf,*outbuf; 
1249   int fsize=0;
1250   int fnum;
1251   struct timeval tp_start;
1252   BOOL tskip=False;       /* We'll take each file as it comes */
1253
1254   GetTimeOfDay(&tp_start);
1255   
1256   inbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1257   outbuf = (char *)malloc(BUFFER_SIZE + SAFETY_MARGIN);
1258   
1259   if (!inbuf || !outbuf)
1260     {
1261       DEBUG(0,("out of memory\n"));
1262       return;
1263     }
1264   
1265   /*
1266    * Must read in tbufsiz dollops
1267    */
1268
1269   /* These should be the only reads in clitar.c */
1270   while ((bufread=read(tarhandle, tarbuf, tbufsiz))>0) {
1271     char *bufferp, *endofbuffer;
1272     int chunk;
1273
1274     /* Code to handle a short read.
1275      * We always need a TBLOCK full of stuff
1276      */
1277     if (bufread % TBLOCK) {
1278       int lchunk=TBLOCK-(bufread % TBLOCK);
1279       int lread;
1280
1281       /* It's a shorty - a short read that is */
1282       DEBUG(3, ("Short read, read %d so far (need %d)\n", bufread, lchunk));
1283
1284       while ((lread=read(tarhandle, tarbuf+bufread, lchunk))>0) {
1285         bufread+=lread;
1286         if (!(lchunk-=lread)) break;
1287       }
1288
1289       /* If we've reached EOF then that must be a short file */
1290       if (lread<=0) break;
1291     }
1292
1293     bufferp=tarbuf; 
1294     endofbuffer=tarbuf+bufread;
1295
1296     if (tskip) {
1297       if (fsize<bufread) {
1298         tskip=False;
1299         bufferp+=fsize;
1300         fsize=0;
1301       } else {
1302         if (fsize==bufread) tskip=False;
1303         fsize-=bufread;
1304         continue;
1305       }
1306     }
1307
1308     do {
1309       if (!fsize)
1310         {
1311           switch (readtarheader((union hblock *) bufferp, &finfo, cur_dir))
1312             {
1313             case -2:             /* something dodgy but not fatal about this */
1314               DEBUG(0, ("skipping %s...\n", finfo.name));
1315               bufferp+=TBLOCK;   /* header - like a link */
1316               continue;
1317             case -1:
1318               DEBUG(0, ("abandoning restore\n"));
1319               free(inbuf); free(outbuf);
1320               return;
1321             case 0: /* chksum is zero - we assume that one all zero
1322                      *header block will do for eof */
1323               DEBUG(0,
1324                     ("total of %d tar files restored to share\n", ntarf));
1325               free(inbuf); free(outbuf);
1326               return;
1327             default:
1328               break;
1329             }
1330
1331           tskip=clipn
1332             && (clipfind(cliplist, clipn, finfo.name) ^ tar_excl);
1333           if (tskip) {
1334             bufferp+=TBLOCK;
1335             if (finfo.mode & aDIR)
1336               continue;
1337             else if ((fsize=finfo.size) % TBLOCK) {
1338               fsize+=TBLOCK-(fsize%TBLOCK);
1339             }
1340             if (fsize<endofbuffer-bufferp) {
1341               bufferp+=fsize;
1342               fsize=0;
1343               continue;
1344             } else {
1345               fsize-=endofbuffer-bufferp;
1346               break;
1347             }
1348           }
1349
1350           if (finfo.mode & aDIR)
1351             {
1352               if (!smbchkpath(finfo.name, inbuf, outbuf)
1353                   && !smbmkdir(finfo.name, inbuf, outbuf))
1354                 {
1355                   DEBUG(0, ("abandoning restore\n"));
1356                   free(inbuf); free(outbuf);
1357                   return;
1358               }
1359               else
1360                 {
1361                   bufferp+=TBLOCK;
1362                   continue;
1363                 }
1364             }
1365           
1366           fsize=finfo.size;
1367
1368           if (ensurepath(finfo.name, inbuf, outbuf)
1369               && !smbcreat(finfo, &fnum, inbuf, outbuf))
1370             {
1371               DEBUG(0, ("abandoning restore\n"));
1372               free(inbuf);free(outbuf);
1373               return;
1374             }
1375
1376           DEBUG(0,("restore tar file %s of size %d bytes\n",
1377                    finfo.name,finfo.size));
1378
1379           nread=0;
1380           if ((bufferp+=TBLOCK) >= endofbuffer) break;    
1381         } /* if (!fsize) */
1382         
1383       /* write out the file in chunk sized chunks - don't
1384        * go past end of buffer though */
1385       chunk=(fsize-nread < endofbuffer - bufferp)
1386         ? fsize - nread : endofbuffer - bufferp;
1387       
1388       while (chunk > 0) {
1389         int minichunk=MIN(chunk, max_xmit-200);
1390         
1391         if (!smbwrite(fnum, /* file descriptor */
1392                       minichunk, /* n */
1393                       nread, /* offset low */
1394                       0, /* offset high - not implemented */
1395                       fsize-nread, /* left - only hint to server */
1396                       bufferp,
1397                       inbuf,
1398                       outbuf))
1399           {
1400             DEBUG(0, ("Error writing remote file\n"));
1401             free(inbuf); free(outbuf);
1402             return;
1403           }
1404         DEBUG(5, ("chunk writing fname=%s fnum=%d nread=%d minichunk=%d chunk=%d size=%d\n", finfo.name, fnum, nread, minichunk, chunk, fsize));
1405         
1406         bufferp+=minichunk; nread+=minichunk;
1407         chunk-=minichunk;
1408       }
1409       
1410       if (nread>=fsize)
1411         {
1412           if (!smbshut(finfo, fnum, inbuf, outbuf))
1413             {
1414               DEBUG(0, ("Error closing remote file\n"));
1415               free(inbuf);free(outbuf);
1416               return;
1417             }
1418           if (fsize % TBLOCK) bufferp+=TBLOCK - (fsize % TBLOCK);
1419           DEBUG(5, ("bufferp is now %d (psn=%d)\n",
1420                     (long) bufferp, (long)(bufferp - tarbuf)));
1421           ntarf++;
1422           fsize=0;
1423         }
1424     } while (bufferp < endofbuffer);
1425   }
1426
1427   DEBUG(0, ("premature eof on tar file ?\n"));
1428   DEBUG(0,("total of %d tar files restored to share\n", ntarf));
1429
1430   free(inbuf); free(outbuf);
1431 }
1432
1433 /*
1434  * samba interactive commands
1435  */
1436
1437 /****************************************************************************
1438 Blocksize command
1439 ***************************************************************************/
1440 void cmd_block(void)
1441 {
1442   fstring buf;
1443   int block;
1444
1445   if (!next_token(NULL,buf,NULL))
1446     {
1447       DEBUG(0, ("blocksize <n>\n"));
1448       return;
1449     }
1450
1451   block=atoi(buf);
1452   if (block < 0 || block > 65535)
1453     {
1454       DEBUG(0, ("blocksize out of range"));
1455       return;
1456     }
1457
1458   blocksize=block;
1459   DEBUG(1,("blocksize is now %d\n", blocksize));
1460 }
1461
1462 /****************************************************************************
1463 command to set incremental / reset mode
1464 ***************************************************************************/
1465 void cmd_tarmode(void)
1466 {
1467   fstring buf;
1468
1469   while (next_token(NULL,buf,NULL)) {
1470     if (strequal(buf, "full"))
1471       tar_inc=False;
1472     else if (strequal(buf, "inc"))
1473       tar_inc=True;
1474     else if (strequal(buf, "reset"))
1475       tar_reset=True;
1476     else if (strequal(buf, "noreset"))
1477       tar_reset=False;
1478     else DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
1479   }
1480
1481   DEBUG(0, ("tarmode is now %s, %s\n",
1482             tar_inc ? "incremental" : "full",
1483             tar_reset ? "reset" : "noreset"));
1484 }
1485
1486 /****************************************************************************
1487 Feeble attrib command
1488 ***************************************************************************/
1489 void cmd_setmode(void)
1490 {
1491   char *q;
1492   fstring buf;
1493   pstring fname;
1494   int attra[2];
1495   int direct=1;
1496
1497   attra[0] = attra[1] = 0;
1498
1499   if (!next_token(NULL,buf,NULL))
1500     {
1501       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1502       return;
1503     }
1504
1505   strcpy(fname, cur_dir);
1506   strcat(fname, buf);
1507
1508   while (next_token(NULL,buf,NULL)) {
1509     q=buf;
1510
1511     while(*q)
1512       switch (*q++) {
1513       case '+': direct=1;
1514         break;
1515       case '-': direct=0;
1516         break;
1517       case 'r': attra[direct]|=aRONLY;
1518         break;
1519       case 'h': attra[direct]|=aHIDDEN;
1520         break;
1521       case 's': attra[direct]|=aSYSTEM;
1522         break;
1523       case 'a': attra[direct]|=aARCH;
1524         break;
1525       default: DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1526         return;
1527       }
1528   }
1529
1530   if (attra[ATTRSET]==0 && attra[ATTRRESET]==0)
1531     {
1532       DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1533       return;
1534     }
1535
1536   DEBUG(1, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
1537   (void) do_setrattr(fname, attra[ATTRSET], ATTRSET);
1538   (void) do_setrattr(fname, attra[ATTRRESET], ATTRRESET);
1539 }
1540
1541 /****************************************************************************
1542 Principal command for creating / extracting
1543 ***************************************************************************/
1544 void cmd_tar(char *inbuf, char *outbuf)
1545 {
1546   fstring buf;
1547   char **argl;
1548   int argcl;
1549
1550   if (!next_token(NULL,buf,NULL))
1551     {
1552       DEBUG(0,("tar <c|x>[IXbga] <filename>\n"));
1553       return;
1554     }
1555
1556   argl=toktocliplist(&argcl, NULL);
1557   if (!tar_parseargs(argcl, argl, buf, 0))
1558     return;
1559
1560   process_tar(inbuf, outbuf);
1561
1562   free(argl);
1563 }
1564
1565 /****************************************************************************
1566 Command line (option) version
1567 ***************************************************************************/
1568 int process_tar(char *inbuf, char *outbuf)
1569 {
1570   initarbuf();
1571   switch(tar_type) {
1572   case 'x':
1573     do_tarput();
1574     free(tarbuf);
1575     close(tarhandle);
1576     break;
1577   case 'r':
1578   case 'c':
1579     if (clipn && tar_excl) {
1580       int i;
1581       pstring tarmac;
1582
1583       for (i=0; i<clipn; i++) {
1584         DEBUG(0,("arg %d = %s\n", i, cliplist[i]));
1585
1586         if (*(cliplist[i]+strlen(cliplist[i])-1)=='\\') {
1587           *(cliplist[i]+strlen(cliplist[i])-1)='\0';
1588         }
1589         
1590         if (strrchr(cliplist[i], '\\')) {
1591           pstring saved_dir;
1592           
1593           strcpy(saved_dir, cur_dir);
1594           
1595           if (*cliplist[i]=='\\') {
1596             strcpy(tarmac, cliplist[i]);
1597           } else {
1598             strcpy(tarmac, cur_dir);
1599             strcat(tarmac, cliplist[i]);
1600           }
1601           strcpy(cur_dir, tarmac);
1602           *(strrchr(cur_dir, '\\')+1)='\0';
1603
1604           do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse);
1605           strcpy(cur_dir,saved_dir);
1606         } else {
1607           strcpy(tarmac, cur_dir);
1608           strcat(tarmac, cliplist[i]);
1609           do_dir((char *)inbuf,(char *)outbuf,tarmac,attribute,do_tar,recurse);
1610         }
1611       }
1612     } else {
1613       pstring mask;
1614       strcpy(mask,cur_dir);
1615       strcat(mask,"\\*");
1616       do_dir((char *)inbuf,(char *)outbuf,mask,attribute,do_tar,recurse);
1617     }
1618     
1619     if (ntarf) dotareof(tarhandle);
1620     close(tarhandle);
1621     free(tarbuf);
1622     
1623     DEBUG(0, ("tar: dumped %d tar files\n", ntarf));
1624     DEBUG(0, ("Total bytes written: %d\n", ttarf));
1625     break;
1626   }
1627
1628   return(0);
1629 }
1630
1631 /****************************************************************************
1632 Find a token (filename) in a clip list
1633 ***************************************************************************/
1634 int clipfind(char **aret, int ret, char *tok)
1635 {
1636   if (aret==NULL) return 0;
1637
1638   /* ignore leading slashes or dots in token */
1639   while(strchr("/\\.", *tok)) tok++;
1640
1641   while(ret--) {
1642     char *pkey=*aret++;
1643
1644     /* ignore leading slashes or dots in list */
1645     while(strchr("/\\.", *pkey)) pkey++;
1646
1647     if (!strslashcmp(pkey, tok)) return 1;
1648   }
1649
1650   return 0;
1651 }
1652
1653 /****************************************************************************
1654 Parse tar arguments. Sets tar_type, tar_excl, etc.
1655 ***************************************************************************/
1656 int tar_parseargs(int argc, char *argv[], char *Optarg, int Optind)
1657 {
1658   char tar_clipfl='\0';
1659
1660   /* Reset back to defaults - could be from interactive version 
1661    * reset mode and archive mode left as they are though
1662    */
1663   tar_type='\0';
1664   tar_excl=True;
1665
1666   while (*Optarg) 
1667     switch(*Optarg++) {
1668     case 'c':
1669       tar_type='c';
1670       break;
1671     case 'x':
1672       if (tar_type=='c') {
1673         printf("Tar must be followed by only one of c or x.\n");
1674         return 0;
1675       }
1676       tar_type='x';
1677       break;
1678     case 'b':
1679       if (Optind>=argc || !(blocksize=atoi(argv[Optind]))) {
1680         DEBUG(0,("Option b must be followed by valid blocksize\n"));
1681         return 0;
1682       } else {
1683         Optind++;
1684       }
1685       break;
1686     case 'g':
1687       tar_inc=True;
1688       break;
1689     case 'N':
1690       if (Optind>=argc) {
1691         DEBUG(0,("Option N must be followed by valid file name\n"));
1692         return 0;
1693       } else {
1694         struct stat stbuf;
1695         extern time_t newer_than;
1696         
1697         if (sys_stat(argv[Optind], &stbuf) == 0) {
1698           newer_than = stbuf.st_mtime;
1699           DEBUG(1,("Getting files newer than %s",
1700                    asctime(LocalTime(&newer_than))));
1701           Optind++;
1702         } else {
1703           DEBUG(0,("Error setting newer-than time\n"));
1704           return 0;
1705         }
1706       }
1707       break;
1708     case 'a':
1709       tar_reset=True;
1710       break;
1711     case 'I':
1712       if (tar_clipfl) {
1713         DEBUG(0,("Only one of I,X must be specified\n"));
1714         return 0;
1715       }
1716       tar_clipfl='I';
1717       break;
1718     case 'X':
1719       if (tar_clipfl) {
1720         DEBUG(0,("Only one of I,X must be specified\n"));
1721         return 0;
1722       }
1723       tar_clipfl='X';
1724       break;
1725     default:
1726       DEBUG(0,("Unknown tar option\n"));
1727       return 0;
1728     }
1729
1730   if (!tar_type) {
1731     printf("Option T must be followed by one of c or x.\n");
1732     return 0;
1733   }
1734
1735   tar_excl=tar_clipfl!='X';
1736   if (Optind+1<argc) {
1737     cliplist=argv+Optind+1;
1738     clipn=argc-Optind-1;
1739   }
1740   if (Optind>=argc || !strcmp(argv[Optind], "-")) {
1741     /* Sets tar handle to either 0 or 1, as appropriate */
1742     tarhandle=(tar_type=='c');
1743   } else {
1744     if ((tar_type=='x' && (tarhandle = open(argv[Optind], O_RDONLY)) == -1)
1745         || (tar_type=='c' && (tarhandle=creat(argv[Optind], 0644)) < 0))
1746       {
1747         DEBUG(0,("Error opening local file %s - %s\n",
1748                  argv[Optind], strerror(errno)));
1749         return(0);
1750       }
1751   }
1752
1753   return 1;
1754 }