printing: explicitly clear PUBLISHED attribute
[Samba.git] / source3 / client / clitar.c
blob9a40c3e320ad6524baadd8a54a2c31fdbc7bf6b1
1 /*
2 Unix SMB/CIFS implementation.
3 Tar Extensions
4 Copyright (C) Ricky Poulten 1995-1998
5 Copyright (C) Richard Sharpe 1998
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 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 /* The following changes developed by Richard Sharpe for Canon Information
21 Systems Research Australia (CISRA)
23 1. Restore can now restore files with long file names
24 2. Save now saves directory information so that we can restore
25 directory creation times
26 3. tar now accepts both UNIX path names and DOS path names. I prefer
27 those lovely /'s to those UGLY \'s :-)
28 4. the files to exclude can be specified as a regular expression by adding
29 an r flag to the other tar flags. Eg:
31 -TcrX file.tar "*.(obj|exe)"
33 will skip all .obj and .exe files
37 #include "includes.h"
38 #include "system/filesys.h"
39 #include "clitar.h"
40 #include "client/client_proto.h"
41 #include "libsmb/libsmb.h"
43 static int clipfind(char **aret, int ret, char *tok);
45 typedef struct file_info_struct file_info2;
47 struct file_info_struct {
48 SMB_OFF_T size;
49 uint16 mode;
50 uid_t uid;
51 gid_t gid;
52 /* These times are normally kept in GMT */
53 struct timespec mtime_ts;
54 struct timespec atime_ts;
55 struct timespec ctime_ts;
56 char *name; /* This is dynamically allocated */
57 file_info2 *next, *prev; /* Used in the stack ... */
60 typedef struct {
61 file_info2 *top;
62 int items;
63 } stack;
65 #define SEPARATORS " \t\n\r"
66 extern time_t newer_than;
67 extern struct cli_state *cli;
69 /* These defines are for the do_setrattr routine, to indicate
70 * setting and reseting of file attributes in the function call */
71 #define ATTRSET 1
72 #define ATTRRESET 0
74 static uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
76 #ifndef CLIENT_TIMEOUT
77 #define CLIENT_TIMEOUT (30*1000)
78 #endif
80 static char *tarbuf, *buffer_p;
81 static int tp, ntarf, tbufsiz;
82 static double ttarf;
83 /* Incremental mode */
84 static bool tar_inc=False;
85 /* Reset archive bit */
86 static bool tar_reset=False;
87 /* Include / exclude mode (true=include, false=exclude) */
88 static bool tar_excl=True;
89 /* use regular expressions for search on file names */
90 static bool tar_re_search=False;
91 /* Do not dump anything, just calculate sizes */
92 static bool dry_run=False;
93 /* Dump files with System attribute */
94 static bool tar_system=True;
95 /* Dump files with Hidden attribute */
96 static bool tar_hidden=True;
97 /* Be noisy - make a catalogue */
98 static bool tar_noisy=True;
99 static bool tar_real_noisy=False; /* Don't want to be really noisy by default */
101 char tar_type='\0';
102 static char **cliplist=NULL;
103 static int clipn=0;
104 static bool must_free_cliplist = False;
105 extern const char *cmd_ptr;
107 extern bool lowercase;
108 extern uint16 cnum;
109 extern bool readbraw_supported;
110 extern int max_xmit;
111 extern int get_total_time_ms;
112 extern int get_total_size;
114 static int blocksize=20;
115 static int tarhandle;
117 static void writetarheader(int f, const char *aname, uint64_t size, time_t mtime,
118 const char *amode, unsigned char ftype);
119 static NTSTATUS do_atar(const char *rname_in, char *lname,
120 struct file_info *finfo1);
121 static NTSTATUS do_tar(struct cli_state *cli_state, struct file_info *finfo,
122 const char *dir);
123 static void oct_it(uint64_t value, int ndgs, char *p);
124 static void fixtarname(char *tptr, const char *fp, size_t l);
125 static int dotarbuf(int f, char *b, int n);
126 static void dozerobuf(int f, int n);
127 static void dotareof(int f);
128 static void initarbuf(void);
130 /* restore functions */
131 static long readtarheader(union hblock *hb, file_info2 *finfo, const char *prefix);
132 static long unoct(char *p, int ndgs);
133 static void do_tarput(void);
134 static void unfixtarname(char *tptr, char *fp, int l, bool first);
137 * tar specific utitlities
140 /*******************************************************************
141 Create a string of size size+1 (for the null)
142 *******************************************************************/
144 static char *string_create_s(int size)
146 char *tmp;
148 tmp = (char *)SMB_MALLOC(size+1);
150 if (tmp == NULL) {
151 DEBUG(0, ("Out of memory in string_create_s\n"));
154 return(tmp);
157 /****************************************************************************
158 Write a tar header to buffer
159 ****************************************************************************/
161 static void writetarheader(int f, const char *aname, uint64_t size, time_t mtime,
162 const char *amode, unsigned char ftype)
164 union hblock hb;
165 int i, chk, l;
166 char *jp;
168 DEBUG(5, ("WriteTarHdr, Type = %c, Size= %.0f, Name = %s\n", ftype, (double)size, aname));
170 memset(hb.dummy, 0, sizeof(hb.dummy));
172 l=strlen(aname);
173 /* We will be prepending a '.' in fixtarheader so use +2 to
174 * take care of the . and terminating zero. JRA.
176 if (l+2 >= NAMSIZ) {
177 /* write a GNU tar style long header */
178 char *b;
179 b = (char *)SMB_MALLOC(l+TBLOCK+100);
180 if (!b) {
181 DEBUG(0,("out of memory\n"));
182 exit(1);
184 writetarheader(f, "/./@LongLink", l+2, 0, " 0 \0", 'L');
185 memset(b, 0, l+TBLOCK+100);
186 fixtarname(b, aname, l+2);
187 i = strlen(b)+1;
188 DEBUG(5, ("File name in tar file: %s, size=%d, \n", b, (int)strlen(b)));
189 dotarbuf(f, b, TBLOCK*(((i-1)/TBLOCK)+1));
190 SAFE_FREE(b);
193 fixtarname(hb.dbuf.name, aname, (l+2 >= NAMSIZ) ? NAMSIZ : l + 2);
195 if (lowercase)
196 strlower_m(hb.dbuf.name);
198 /* write out a "standard" tar format header */
200 hb.dbuf.name[NAMSIZ-1]='\0';
201 safe_strcpy(hb.dbuf.mode, amode, sizeof(hb.dbuf.mode)-1);
202 oct_it((uint64_t)0, 8, hb.dbuf.uid);
203 oct_it((uint64_t)0, 8, hb.dbuf.gid);
204 oct_it((uint64_t) size, 13, hb.dbuf.size);
205 if (size > (uint64_t)077777777777LL) {
206 /* This is a non-POSIX compatible extention to store files
207 greater than 8GB. */
209 memset(hb.dbuf.size, 0, 4);
210 hb.dbuf.size[0]=128;
211 for (i = 8; i; i--) {
212 hb.dbuf.size[i+3] = size & 0xff;
213 size >>= 8;
216 oct_it((uint64_t) mtime, 13, hb.dbuf.mtime);
217 memcpy(hb.dbuf.chksum, " ", sizeof(hb.dbuf.chksum));
218 memset(hb.dbuf.linkname, 0, NAMSIZ);
219 hb.dbuf.linkflag=ftype;
221 for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;)
222 chk+=(0xFF & *jp++);
224 oct_it((uint64_t) chk, 8, hb.dbuf.chksum);
225 hb.dbuf.chksum[6] = '\0';
227 (void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
230 /****************************************************************************
231 Read a tar header into a hblock structure, and validate
232 ***************************************************************************/
234 static long readtarheader(union hblock *hb, file_info2 *finfo, const char *prefix)
236 long chk, fchk;
237 int i;
238 char *jp;
241 * read in a "standard" tar format header - we're not that interested
242 * in that many fields, though
245 /* check the checksum */
246 for (chk=0, i=sizeof(hb->dummy), jp=hb->dummy; --i>=0;)
247 chk+=(0xFF & *jp++);
249 if (chk == 0)
250 return chk;
252 /* compensate for blanks in chksum header */
253 for (i=sizeof(hb->dbuf.chksum), jp=hb->dbuf.chksum; --i>=0;)
254 chk-=(0xFF & *jp++);
256 chk += ' ' * sizeof(hb->dbuf.chksum);
258 fchk=unoct(hb->dbuf.chksum, sizeof(hb->dbuf.chksum));
260 DEBUG(5, ("checksum totals chk=%ld fchk=%ld chksum=%s\n",
261 chk, fchk, hb->dbuf.chksum));
263 if (fchk != chk) {
264 DEBUG(0, ("checksums don't match %ld %ld\n", fchk, chk));
265 dump_data(5, (uint8 *)hb - TBLOCK, TBLOCK *3);
266 return -1;
269 if ((finfo->name = string_create_s(strlen(prefix) + strlen(hb -> dbuf.name) + 3)) == NULL) {
270 DEBUG(0, ("Out of space creating file_info2 for %s\n", hb -> dbuf.name));
271 return(-1);
274 safe_strcpy(finfo->name, prefix, strlen(prefix) + strlen(hb -> dbuf.name) + 3);
276 /* use l + 1 to do the null too; do prefix - prefcnt to zap leading slash */
277 unfixtarname(finfo->name + strlen(prefix), hb->dbuf.name,
278 strlen(hb->dbuf.name) + 1, True);
280 /* can't handle some links at present */
281 if ((hb->dbuf.linkflag != '0') && (hb -> dbuf.linkflag != '5')) {
282 if (hb->dbuf.linkflag == 0) {
283 DEBUG(6, ("Warning: NULL link flag (gnu tar archive ?) %s\n",
284 finfo->name));
285 } else {
286 if (hb -> dbuf.linkflag == 'L') { /* We have a longlink */
287 /* Do nothing here at the moment. do_tarput will handle this
288 as long as the longlink gets back to it, as it has to advance
289 the buffer pointer, etc */
290 } else {
291 DEBUG(0, ("this tar file appears to contain some kind \
292 of link other than a GNUtar Longlink - ignoring\n"));
293 return -2;
298 if ((unoct(hb->dbuf.mode, sizeof(hb->dbuf.mode)) & S_IFDIR) ||
299 (*(finfo->name+strlen(finfo->name)-1) == '\\')) {
300 finfo->mode=FILE_ATTRIBUTE_DIRECTORY;
301 } else {
302 finfo->mode=0; /* we don't care about mode at the moment, we'll
303 * just make it a regular file */
307 * Bug fix by richard@sj.co.uk
309 * REC: restore times correctly (as does tar)
310 * We only get the modification time of the file; set the creation time
311 * from the mod. time, and the access time to current time
313 finfo->mtime_ts = finfo->ctime_ts =
314 convert_time_t_to_timespec((time_t)strtol(hb->dbuf.mtime, NULL, 8));
315 finfo->atime_ts = convert_time_t_to_timespec(time(NULL));
316 if ((hb->dbuf.size[0] & 0xff) == 0x80) {
317 /* This is a non-POSIX compatible extention to extract files
318 greater than 8GB. */
319 finfo->size = 0;
320 for (i = 0; i < 8; i++) {
321 finfo->size <<= 8;
322 finfo->size |= hb->dbuf.size[i+4] & 0xff;
324 } else {
325 finfo->size = unoct(hb->dbuf.size, sizeof(hb->dbuf.size));
328 return True;
331 /****************************************************************************
332 Write out the tar buffer to tape or wherever
333 ****************************************************************************/
335 static int dotarbuf(int f, char *b, int n)
337 int fail=1, writ=n;
339 if (dry_run) {
340 return writ;
342 /* This routine and the next one should be the only ones that do write()s */
343 if (tp + n >= tbufsiz) {
344 int diff;
346 diff=tbufsiz-tp;
347 memcpy(tarbuf + tp, b, diff);
348 fail=fail && (1+sys_write(f, tarbuf, tbufsiz));
349 n-=diff;
350 b+=diff;
351 tp=0;
353 while (n >= tbufsiz) {
354 fail=fail && (1 + sys_write(f, b, tbufsiz));
355 n-=tbufsiz;
356 b+=tbufsiz;
360 if (n>0) {
361 memcpy(tarbuf+tp, b, n);
362 tp+=n;
365 return(fail ? writ : 0);
368 /****************************************************************************
369 Write zeros to buffer / tape
370 ****************************************************************************/
372 static void dozerobuf(int f, int n)
374 /* short routine just to write out n zeros to buffer -
375 * used to round files to nearest block
376 * and to do tar EOFs */
378 if (dry_run)
379 return;
381 if (n+tp >= tbufsiz) {
382 memset(tarbuf+tp, 0, tbufsiz-tp);
383 if (sys_write(f, tarbuf, tbufsiz) != tbufsiz) {
384 DEBUG(0, ("dozerobuf: sys_write fail\n"));
385 return;
387 memset(tarbuf, 0, (tp+=n-tbufsiz));
388 } else {
389 memset(tarbuf+tp, 0, n);
390 tp+=n;
394 /****************************************************************************
395 Malloc tape buffer
396 ****************************************************************************/
398 static void initarbuf(void)
400 /* initialize tar buffer */
401 tbufsiz=blocksize*TBLOCK;
402 tarbuf=(char *)SMB_MALLOC(tbufsiz); /* FIXME: We might not get the buffer */
404 /* reset tar buffer pointer and tar file counter and total dumped */
405 tp=0; ntarf=0; ttarf=0;
408 /****************************************************************************
409 Write two zero blocks at end of file
410 ****************************************************************************/
412 static void dotareof(int f)
414 SMB_STRUCT_STAT stbuf;
415 /* Two zero blocks at end of file, write out full buffer */
417 if (dry_run)
418 return;
420 (void) dozerobuf(f, TBLOCK);
421 (void) dozerobuf(f, TBLOCK);
423 if (sys_fstat(f, &stbuf, false) == -1) {
424 DEBUG(0, ("Couldn't stat file handle\n"));
425 return;
428 /* Could be a pipe, in which case S_ISREG should fail,
429 * and we should write out at full size */
430 if (tp > 0) {
431 size_t towrite = S_ISREG(stbuf.st_ex_mode) ? tp : tbufsiz;
432 if (sys_write(f, tarbuf, towrite) != towrite) {
433 DEBUG(0,("dotareof: sys_write fail\n"));
438 /****************************************************************************
439 (Un)mangle DOS pathname, make nonabsolute
440 ****************************************************************************/
442 static void fixtarname(char *tptr, const char *fp, size_t l)
444 /* add a '.' to start of file name, convert from ugly dos \'s in path
445 * to lovely unix /'s :-} */
446 *tptr++='.';
447 l--;
449 StrnCpy(tptr, fp, l-1);
450 string_replace(tptr, '\\', '/');
453 /****************************************************************************
454 Convert from decimal to octal string
455 ****************************************************************************/
457 static void oct_it (uint64_t value, int ndgs, char *p)
459 /* Converts long to octal string, pads with leading zeros */
461 /* skip final null, but do final space */
462 --ndgs;
463 p[--ndgs] = ' ';
465 /* Loop does at least one digit */
466 do {
467 p[--ndgs] = '0' + (char) (value & 7);
468 value >>= 3;
469 } while (ndgs > 0 && value != 0);
471 /* Do leading zeros */
472 while (ndgs > 0)
473 p[--ndgs] = '0';
476 /****************************************************************************
477 Convert from octal string to long
478 ***************************************************************************/
480 static long unoct(char *p, int ndgs)
482 long value=0;
483 /* Converts octal string to long, ignoring any non-digit */
485 while (--ndgs) {
486 if (isdigit((int)*p))
487 value = (value << 3) | (long) (*p - '0');
489 p++;
492 return value;
495 /****************************************************************************
496 Compare two strings in a slash insensitive way, allowing s1 to match s2
497 if s1 is an "initial" string (up to directory marker). Thus, if s2 is
498 a file in any subdirectory of s1, declare a match.
499 ***************************************************************************/
501 static int strslashcmp(char *s1, char *s2)
503 char *s1_0=s1;
505 while(*s1 && *s2 && (*s1 == *s2 || tolower_m(*s1) == tolower_m(*s2) ||
506 (*s1 == '\\' && *s2=='/') || (*s1 == '/' && *s2=='\\'))) {
507 s1++; s2++;
510 /* if s1 has a trailing slash, it compared equal, so s1 is an "initial"
511 string of s2.
513 if (!*s1 && s1 != s1_0 && (*(s1-1) == '/' || *(s1-1) == '\\'))
514 return 0;
516 /* ignore trailing slash on s1 */
517 if (!*s2 && (*s1 == '/' || *s1 == '\\') && !*(s1+1))
518 return 0;
520 /* check for s1 is an "initial" string of s2 */
521 if ((*s2 == '/' || *s2 == '\\') && !*s1)
522 return 0;
524 return *s1-*s2;
527 /****************************************************************************
528 Ensure a remote path exists (make if necessary)
529 ***************************************************************************/
531 static bool ensurepath(const char *fname)
533 /* *must* be called with buffer ready malloc'ed */
534 /* ensures path exists */
536 char *partpath, *ffname;
537 const char *p=fname;
538 char *basehack;
539 char *saveptr;
541 DEBUG(5, ( "Ensurepath called with: %s\n", fname));
543 partpath = string_create_s(strlen(fname));
544 ffname = string_create_s(strlen(fname));
546 if ((partpath == NULL) || (ffname == NULL)){
547 DEBUG(0, ("Out of memory in ensurepath: %s\n", fname));
548 SAFE_FREE(partpath);
549 SAFE_FREE(ffname);
550 return(False);
553 *partpath = 0;
555 /* fname copied to ffname so can strtok_r */
557 safe_strcpy(ffname, fname, strlen(fname));
559 /* do a `basename' on ffname, so don't try and make file name directory */
560 if ((basehack=strrchr_m(ffname, '\\')) == NULL) {
561 SAFE_FREE(partpath);
562 SAFE_FREE(ffname);
563 return True;
564 } else {
565 *basehack='\0';
568 p=strtok_r(ffname, "\\", &saveptr);
570 while (p) {
571 safe_strcat(partpath, p, strlen(fname) + 1);
573 if (!NT_STATUS_IS_OK(cli_chkpath(cli, partpath))) {
574 if (!NT_STATUS_IS_OK(cli_mkdir(cli, partpath))) {
575 SAFE_FREE(partpath);
576 SAFE_FREE(ffname);
577 DEBUG(0, ("Error mkdir %s\n", cli_errstr(cli)));
578 return False;
579 } else {
580 DEBUG(3, ("mkdirhiering %s\n", partpath));
584 safe_strcat(partpath, "\\", strlen(fname) + 1);
585 p = strtok_r(NULL, "/\\", &saveptr);
588 SAFE_FREE(partpath);
589 SAFE_FREE(ffname);
590 return True;
593 static int padit(char *buf, uint64_t bufsize, uint64_t padsize)
595 int berr= 0;
596 int bytestowrite;
598 DEBUG(5, ("Padding with %0.f zeros\n", (double)padsize));
599 memset(buf, 0, (size_t)bufsize);
600 while( !berr && padsize > 0 ) {
601 bytestowrite= (int)MIN(bufsize, padsize);
602 berr = dotarbuf(tarhandle, buf, bytestowrite) != bytestowrite;
603 padsize -= bytestowrite;
606 return berr;
609 static void do_setrattr(char *name, uint16 attr, int set)
611 uint16 oldattr;
613 if (!NT_STATUS_IS_OK(cli_getatr(cli, name, &oldattr, NULL, NULL))) {
614 return;
617 if (set == ATTRSET) {
618 attr |= oldattr;
619 } else {
620 attr = oldattr & ~attr;
623 if (!NT_STATUS_IS_OK(cli_setatr(cli, name, attr, 0))) {
624 DEBUG(1,("setatr failed: %s\n", cli_errstr(cli)));
628 /****************************************************************************
629 append one remote file to the tar file
630 ***************************************************************************/
632 static NTSTATUS do_atar(const char *rname_in, char *lname,
633 struct file_info *finfo1)
635 uint16_t fnum = (uint16_t)-1;
636 uint64_t nread=0;
637 char ftype;
638 file_info2 finfo;
639 bool shallitime=True;
640 char *data = NULL;
641 int read_size = 65520;
642 int datalen=0;
643 char *rname = NULL;
644 TALLOC_CTX *ctx = talloc_stackframe();
645 NTSTATUS status = NT_STATUS_OK;
646 struct timespec tp_start;
648 clock_gettime_mono(&tp_start);
650 data = SMB_MALLOC_ARRAY(char, read_size);
651 if (!data) {
652 DEBUG(0,("do_atar: out of memory.\n"));
653 status = NT_STATUS_NO_MEMORY;
654 goto cleanup;
657 ftype = '0'; /* An ordinary file ... */
659 ZERO_STRUCT(finfo);
661 finfo.size = finfo1 -> size;
662 finfo.mode = finfo1 -> mode;
663 finfo.uid = finfo1 -> uid;
664 finfo.gid = finfo1 -> gid;
665 finfo.mtime_ts = finfo1 -> mtime_ts;
666 finfo.atime_ts = finfo1 -> atime_ts;
667 finfo.ctime_ts = finfo1 -> ctime_ts;
669 if (dry_run) {
670 DEBUG(3,("skipping file %s of size %12.0f bytes\n", finfo1->name,
671 (double)finfo.size));
672 shallitime=0;
673 ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
674 ntarf++;
675 goto cleanup;
678 rname = clean_name(ctx, rname_in);
679 if (!rname) {
680 status = NT_STATUS_NO_MEMORY;
681 goto cleanup;
684 status = cli_open(cli, rname, O_RDONLY, DENY_NONE, &fnum);
685 if (!NT_STATUS_IS_OK(status)) {
686 DEBUG(0,("%s opening remote file %s (%s)\n",
687 cli_errstr(cli),rname, client_get_cur_dir()));
688 goto cleanup;
691 finfo.name = string_create_s(strlen(rname));
692 if (finfo.name == NULL) {
693 DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n"));
694 status = NT_STATUS_NO_MEMORY;
695 goto cleanup;
698 safe_strcpy(finfo.name,rname, strlen(rname));
700 DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode));
702 if (tar_inc && !(finfo.mode & FILE_ATTRIBUTE_ARCHIVE)) {
703 DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name));
704 shallitime=0;
705 } else if (!tar_system && (finfo.mode & FILE_ATTRIBUTE_SYSTEM)) {
706 DEBUG(4, ("skipping %s - system bit is set\n", finfo.name));
707 shallitime=0;
708 } else if (!tar_hidden && (finfo.mode & FILE_ATTRIBUTE_HIDDEN)) {
709 DEBUG(4, ("skipping %s - hidden bit is set\n", finfo.name));
710 shallitime=0;
711 } else {
712 bool wrote_tar_header = False;
714 DEBUG(3,("getting file %s of size %.0f bytes as a tar file %s",
715 finfo.name, (double)finfo.size, lname));
717 do {
719 DEBUG(3,("nread=%.0f\n",(double)nread));
721 datalen = cli_read(cli, fnum, data, nread, read_size);
723 if (datalen == -1) {
724 DEBUG(0,("Error reading file %s : %s\n", rname, cli_errstr(cli)));
725 status = cli_nt_error(cli);
726 break;
729 nread += datalen;
731 /* Only if the first read succeeds, write out the tar header. */
732 if (!wrote_tar_header) {
733 /* write a tar header, don't bother with mode - just set to 100644 */
734 writetarheader(tarhandle, rname, finfo.size,
735 finfo.mtime_ts.tv_sec, "100644 \0", ftype);
736 wrote_tar_header = True;
739 /* if file size has increased since we made file size query, truncate
740 read so tar header for this file will be correct.
743 if (nread > finfo.size) {
744 datalen -= nread - finfo.size;
745 DEBUG(0,("File size change - truncating %s to %.0f bytes\n",
746 finfo.name, (double)finfo.size));
749 /* add received bits of file to buffer - dotarbuf will
750 * write out in 512 byte intervals */
752 if (dotarbuf(tarhandle,data,datalen) != datalen) {
753 DEBUG(0,("Error writing to tar file - %s\n", strerror(errno)));
754 status = map_nt_error_from_unix(errno);
755 break;
758 if ( (datalen == 0) && (finfo.size != 0) ) {
759 status = NT_STATUS_UNSUCCESSFUL;
760 DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname));
761 break;
764 datalen=0;
765 } while ( nread < finfo.size );
767 if (wrote_tar_header) {
768 /* pad tar file with zero's if we couldn't get entire file */
769 if (nread < finfo.size) {
770 DEBUG(0, ("Didn't get entire file. size=%.0f, nread=%d\n",
771 (double)finfo.size, (int)nread));
772 if (padit(data, (uint64_t)sizeof(data), finfo.size - nread)) {
773 status = map_nt_error_from_unix(errno);
774 DEBUG(0,("Error writing tar file - %s\n", strerror(errno)));
778 /* round tar file to nearest block */
779 if (finfo.size % TBLOCK)
780 dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK));
782 ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK);
783 ntarf++;
784 } else {
785 DEBUG(4, ("skipping %s - initial read failed (file was locked ?)\n", finfo.name));
786 shallitime=0;
787 status = NT_STATUS_UNSUCCESSFUL;
791 cli_close(cli, fnum);
792 fnum = -1;
794 if (shallitime) {
795 struct timespec tp_end;
796 int this_time;
798 /* if shallitime is true then we didn't skip */
799 if (tar_reset && !dry_run)
800 (void) do_setrattr(finfo.name, FILE_ATTRIBUTE_ARCHIVE, ATTRRESET);
802 clock_gettime_mono(&tp_end);
803 this_time = (tp_end.tv_sec - tp_start.tv_sec)*1000 + (tp_end.tv_nsec - tp_start.tv_nsec)/1000000;
804 get_total_time_ms += this_time;
805 get_total_size += finfo.size;
807 if (tar_noisy) {
808 DEBUG(0, ("%12.0f (%7.1f kb/s) %s\n",
809 (double)finfo.size, finfo.size / MAX(0.001, (1.024*this_time)),
810 finfo.name));
813 /* Thanks to Carel-Jan Engel (ease@mail.wirehub.nl) for this one */
814 DEBUG(3,("(%g kb/s) (average %g kb/s)\n",
815 finfo.size / MAX(0.001, (1.024*this_time)),
816 get_total_size / MAX(0.001, (1.024*get_total_time_ms))));
819 cleanup:
821 if (fnum != (uint16_t)-1) {
822 cli_close(cli, fnum);
823 fnum = -1;
825 TALLOC_FREE(ctx);
826 SAFE_FREE(data);
827 return status;
830 /****************************************************************************
831 Append single file to tar file (or not)
832 ***************************************************************************/
834 static NTSTATUS do_tar(struct cli_state *cli_state, struct file_info *finfo,
835 const char *dir)
837 TALLOC_CTX *ctx = talloc_stackframe();
838 NTSTATUS status = NT_STATUS_OK;
840 if (strequal(finfo->name,"..") || strequal(finfo->name,".")) {
841 status = NT_STATUS_OK;
842 goto cleanup;
845 /* Is it on the exclude list ? */
846 if (!tar_excl && clipn) {
847 char *exclaim;
849 DEBUG(5, ("Excl: strlen(cur_dir) = %d\n", (int)strlen(client_get_cur_dir())));
851 exclaim = talloc_asprintf(ctx,
852 "%s\\%s",
853 client_get_cur_dir(),
854 finfo->name);
855 if (!exclaim) {
856 status = NT_STATUS_NO_MEMORY;
857 goto cleanup;
860 DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));
862 if ((!tar_re_search && clipfind(cliplist, clipn, exclaim)) ||
863 (tar_re_search && mask_match_list(exclaim, cliplist, clipn, True))) {
864 DEBUG(3,("Skipping file %s\n", exclaim));
865 TALLOC_FREE(exclaim);
866 status = NT_STATUS_OK;
867 goto cleanup;
869 TALLOC_FREE(exclaim);
872 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
873 char *saved_curdir = NULL;
874 char *new_cd = NULL;
875 char *mtar_mask = NULL;
877 saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
878 if (!saved_curdir) {
879 status = NT_STATUS_NO_MEMORY;
880 goto cleanup;
883 DEBUG(5, ("strlen(cur_dir)=%d, \
884 strlen(finfo->name)=%d\nname=%s,cur_dir=%s\n",
885 (int)strlen(saved_curdir),
886 (int)strlen(finfo->name), finfo->name, saved_curdir));
888 new_cd = talloc_asprintf(ctx,
889 "%s%s\\",
890 client_get_cur_dir(),
891 finfo->name);
892 if (!new_cd) {
893 status = NT_STATUS_NO_MEMORY;
894 goto cleanup;
896 client_set_cur_dir(new_cd);
898 DEBUG(5, ("Writing a dir, Name = %s\n", client_get_cur_dir()));
900 /* write a tar directory, don't bother with mode - just
901 * set it to 40755 */
902 writetarheader(tarhandle, client_get_cur_dir(), 0,
903 finfo->mtime_ts.tv_sec, "040755 \0", '5');
904 if (tar_noisy) {
905 DEBUG(0,(" directory %s\n",
906 client_get_cur_dir()));
908 ntarf++; /* Make sure we have a file on there */
909 mtar_mask = talloc_asprintf(ctx,
910 "%s*",
911 client_get_cur_dir());
912 if (!mtar_mask) {
913 status = NT_STATUS_NO_MEMORY;
914 goto cleanup;
916 DEBUG(5, ("Doing list with mtar_mask: %s\n", mtar_mask));
917 do_list(mtar_mask, attribute, do_tar, False, True);
918 client_set_cur_dir(saved_curdir);
919 TALLOC_FREE(saved_curdir);
920 TALLOC_FREE(new_cd);
921 TALLOC_FREE(mtar_mask);
922 } else {
923 char *rname = talloc_asprintf(ctx,
924 "%s%s",
925 client_get_cur_dir(),
926 finfo->name);
927 if (!rname) {
928 status = NT_STATUS_NO_MEMORY;
929 goto cleanup;
931 status = do_atar(rname,finfo->name,finfo);
932 TALLOC_FREE(rname);
935 cleanup:
936 TALLOC_FREE(ctx);
937 return status;
940 /****************************************************************************
941 Convert from UNIX to DOS file names
942 ***************************************************************************/
944 static void unfixtarname(char *tptr, char *fp, int l, bool first)
946 /* remove '.' from start of file name, convert from unix /'s to
947 * dos \'s in path. Kill any absolute path names. But only if first!
950 DEBUG(5, ("firstb=%lX, secondb=%lX, len=%i\n", (long)tptr, (long)fp, l));
952 if (first) {
953 if (*fp == '.') {
954 fp++;
955 l--;
957 if (*fp == '\\' || *fp == '/') {
958 fp++;
959 l--;
963 safe_strcpy(tptr, fp, l);
964 string_replace(tptr, '/', '\\');
967 /****************************************************************************
968 Move to the next block in the buffer, which may mean read in another set of
969 blocks. FIXME, we should allow more than one block to be skipped.
970 ****************************************************************************/
972 static int next_block(char *ltarbuf, char **bufferp, int bufsiz)
974 int bufread, total = 0;
976 DEBUG(5, ("Advancing to next block: %0lx\n", (unsigned long)*bufferp));
977 *bufferp += TBLOCK;
978 total = TBLOCK;
980 if (*bufferp >= (ltarbuf + bufsiz)) {
982 DEBUG(5, ("Reading more data into ltarbuf ...\n"));
985 * Bugfix from Bob Boehmer <boehmer@worldnet.att.net>
986 * Fixes bug where read can return short if coming from
987 * a pipe.
990 bufread = read(tarhandle, ltarbuf, bufsiz);
991 total = bufread;
993 while (total < bufsiz) {
994 if (bufread < 0) { /* An error, return false */
995 return (total > 0 ? -2 : bufread);
997 if (bufread == 0) {
998 if (total <= 0) {
999 return -2;
1001 break;
1003 bufread = read(tarhandle, &ltarbuf[total], bufsiz - total);
1004 total += bufread;
1007 DEBUG(5, ("Total bytes read ... %i\n", total));
1009 *bufferp = ltarbuf;
1012 return(total);
1015 /* Skip a file, even if it includes a long file name? */
1016 static int skip_file(int skipsize)
1018 int dsize = skipsize;
1020 DEBUG(5, ("Skiping file. Size = %i\n", skipsize));
1022 /* FIXME, we should skip more than one block at a time */
1024 while (dsize > 0) {
1025 if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
1026 DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
1027 return(False);
1029 dsize -= TBLOCK;
1032 return(True);
1035 /*************************************************************
1036 Get a file from the tar file and store it.
1037 When this is called, tarbuf already contains the first
1038 file block. This is a bit broken & needs fixing.
1039 **************************************************************/
1041 static int get_file(file_info2 finfo)
1043 uint16_t fnum = (uint16_t) -1;
1044 int dsize = 0, bpos = 0;
1045 uint64_t rsize = 0, pos = 0;
1046 NTSTATUS status;
1048 DEBUG(5, ("get_file: file: %s, size %.0f\n", finfo.name, (double)finfo.size));
1050 if (!ensurepath(finfo.name)) {
1051 DEBUG(0, ("abandoning restore\n"));
1052 return False;
1055 status = cli_open(cli, finfo.name, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnum);
1056 if (!NT_STATUS_IS_OK(status)) {
1057 DEBUG(0, ("abandoning restore\n"));
1058 return False;
1061 /* read the blocks from the tar file and write to the remote file */
1063 rsize = finfo.size; /* This is how much to write */
1065 while (rsize > 0) {
1067 /* We can only write up to the end of the buffer */
1068 dsize = MIN(tbufsiz - (buffer_p - tarbuf) - bpos, 65520); /* Calculate the size to write */
1069 dsize = MIN(dsize, rsize); /* Should be only what is left */
1070 DEBUG(5, ("writing %i bytes, bpos = %i ...\n", dsize, bpos));
1072 status = cli_writeall(cli, fnum, 0,
1073 (uint8_t *)(buffer_p + bpos), pos,
1074 dsize, NULL);
1075 if (!NT_STATUS_IS_OK(status)) {
1076 DEBUG(0, ("Error writing remote file: %s\n",
1077 nt_errstr(status)));
1078 return 0;
1081 rsize -= dsize;
1082 pos += dsize;
1084 /* Now figure out how much to move in the buffer */
1086 /* FIXME, we should skip more than one block at a time */
1088 /* First, skip any initial part of the part written that is left over */
1089 /* from the end of the first TBLOCK */
1091 if ((bpos) && ((bpos + dsize) >= TBLOCK)) {
1092 dsize -= (TBLOCK - bpos); /* Get rid of the end of the first block */
1093 bpos = 0;
1095 if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) { /* and skip the block */
1096 DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
1097 return False;
1102 * Bugfix from Bob Boehmer <boehmer@worldnet.att.net>.
1103 * If the file being extracted is an exact multiple of
1104 * TBLOCK bytes then we don't want to extract the next
1105 * block from the tarfile here, as it will be done in
1106 * the caller of get_file().
1109 while (((rsize != 0) && (dsize >= TBLOCK)) ||
1110 ((rsize == 0) && (dsize > TBLOCK))) {
1112 if (next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
1113 DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
1114 return False;
1117 dsize -= TBLOCK;
1119 bpos = dsize;
1122 /* Now close the file ... */
1124 if (!NT_STATUS_IS_OK(cli_close(cli, fnum))) {
1125 DEBUG(0, ("Error %s closing remote file\n",
1126 cli_errstr(cli)));
1127 return(False);
1130 /* Now we update the creation date ... */
1131 DEBUG(5, ("Updating creation date on %s\n", finfo.name));
1133 if (!NT_STATUS_IS_OK(cli_setatr(cli, finfo.name, finfo.mode, finfo.mtime_ts.tv_sec))) {
1134 if (tar_real_noisy) {
1135 DEBUG(0, ("Could not set time on file: %s\n", finfo.name));
1136 /*return(False); */ /* Ignore, as Win95 does not allow changes */
1140 ntarf++;
1141 DEBUG(0, ("restore tar file %s of size %.0f bytes\n", finfo.name, (double)finfo.size));
1142 return(True);
1145 /* Create a directory. We just ensure that the path exists and return as there
1146 is no file associated with a directory
1148 static int get_dir(file_info2 finfo)
1150 DEBUG(0, ("restore directory %s\n", finfo.name));
1152 if (!ensurepath(finfo.name)) {
1153 DEBUG(0, ("Problems creating directory\n"));
1154 return(False);
1156 ntarf++;
1157 return(True);
1160 /* Get a file with a long file name ... first file has file name, next file
1161 has the data. We only want the long file name, as the loop in do_tarput
1162 will deal with the rest.
1164 static char *get_longfilename(file_info2 finfo)
1166 /* finfo.size here is the length of the filename as written by the "/./@LongLink" name
1167 * header call. */
1168 int namesize = finfo.size + strlen(client_get_cur_dir()) + 2;
1169 char *longname = (char *)SMB_MALLOC(namesize);
1170 int offset = 0, left = finfo.size;
1171 bool first = True;
1173 DEBUG(5, ("Restoring a long file name: %s\n", finfo.name));
1174 DEBUG(5, ("Len = %.0f\n", (double)finfo.size));
1176 if (longname == NULL) {
1177 DEBUG(0, ("could not allocate buffer of size %d for longname\n", namesize));
1178 return(NULL);
1181 /* First, add cur_dir to the long file name */
1183 if (strlen(client_get_cur_dir()) > 0) {
1184 strncpy(longname, client_get_cur_dir(), namesize);
1185 offset = strlen(client_get_cur_dir());
1188 /* Loop through the blocks picking up the name */
1190 while (left > 0) {
1191 if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
1192 DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
1193 SAFE_FREE(longname);
1194 return(NULL);
1197 unfixtarname(longname + offset, buffer_p, MIN(TBLOCK, finfo.size), first--);
1198 DEBUG(5, ("UnfixedName: %s, buffer: %s\n", longname, buffer_p));
1200 offset += TBLOCK;
1201 left -= TBLOCK;
1204 return(longname);
1207 static void do_tarput(void)
1209 file_info2 finfo;
1210 struct timespec tp_start;
1211 char *longfilename = NULL, linkflag;
1212 int skip = False;
1214 ZERO_STRUCT(finfo);
1216 clock_gettime_mono(&tp_start);
1217 DEBUG(5, ("RJS do_tarput called ...\n"));
1219 buffer_p = tarbuf + tbufsiz; /* init this to force first read */
1221 /* Now read through those files ... */
1222 while (True) {
1223 /* Get us to the next block, or the first block first time around */
1224 if (next_block(tarbuf, &buffer_p, tbufsiz) <= 0) {
1225 DEBUG(0, ("Empty file, short tar file, or read error: %s\n", strerror(errno)));
1226 SAFE_FREE(longfilename);
1227 return;
1230 DEBUG(5, ("Reading the next header ...\n"));
1232 switch (readtarheader((union hblock *) buffer_p,
1233 &finfo, client_get_cur_dir())) {
1234 case -2: /* Hmm, not good, but not fatal */
1235 DEBUG(0, ("Skipping %s...\n", finfo.name));
1236 if ((next_block(tarbuf, &buffer_p, tbufsiz) <= 0) && !skip_file(finfo.size)) {
1237 DEBUG(0, ("Short file, bailing out...\n"));
1238 SAFE_FREE(longfilename);
1239 return;
1241 break;
1243 case -1:
1244 DEBUG(0, ("abandoning restore, -1 from read tar header\n"));
1245 SAFE_FREE(longfilename);
1246 return;
1248 case 0: /* chksum is zero - looks like an EOF */
1249 DEBUG(0, ("tar: restored %d files and directories\n", ntarf));
1250 SAFE_FREE(longfilename);
1251 return; /* Hmmm, bad here ... */
1253 default:
1254 /* No action */
1255 break;
1258 /* Now, do we have a long file name? */
1259 if (longfilename != NULL) {
1260 SAFE_FREE(finfo.name); /* Free the space already allocated */
1261 finfo.name = longfilename;
1262 longfilename = NULL;
1265 /* Well, now we have a header, process the file ... */
1266 /* Should we skip the file? We have the long name as well here */
1267 skip = clipn && ((!tar_re_search && clipfind(cliplist, clipn, finfo.name) ^ tar_excl) ||
1268 (tar_re_search && mask_match_list(finfo.name, cliplist, clipn, True)));
1270 DEBUG(5, ("Skip = %i, cliplist=%s, file=%s\n", skip, (cliplist?cliplist[0]:NULL), finfo.name));
1271 if (skip) {
1272 skip_file(finfo.size);
1273 continue;
1276 /* We only get this far if we should process the file */
1277 linkflag = ((union hblock *)buffer_p) -> dbuf.linkflag;
1278 switch (linkflag) {
1279 case '0': /* Should use symbolic names--FIXME */
1281 * Skip to the next block first, so we can get the file, FIXME, should
1282 * be in get_file ...
1283 * The 'finfo.size != 0' fix is from Bob Boehmer <boehmer@worldnet.att.net>
1284 * Fixes bug where file size in tarfile is zero.
1286 if ((finfo.size != 0) && next_block(tarbuf, &buffer_p, tbufsiz) <=0) {
1287 DEBUG(0, ("Short file, bailing out...\n"));
1288 return;
1290 if (!get_file(finfo)) {
1291 DEBUG(0, ("Abandoning restore\n"));
1292 return;
1294 break;
1295 case '5':
1296 if (!get_dir(finfo)) {
1297 DEBUG(0, ("Abandoning restore \n"));
1298 return;
1300 break;
1301 case 'L':
1302 SAFE_FREE(longfilename);
1303 longfilename = get_longfilename(finfo);
1304 if (!longfilename) {
1305 DEBUG(0, ("abandoning restore\n"));
1306 return;
1308 DEBUG(5, ("Long file name: %s\n", longfilename));
1309 break;
1311 default:
1312 skip_file(finfo.size); /* Don't handle these yet */
1313 break;
1319 * samba interactive commands
1322 /****************************************************************************
1323 Blocksize command
1324 ***************************************************************************/
1326 int cmd_block(void)
1328 TALLOC_CTX *ctx = talloc_tos();
1329 char *buf;
1330 int block;
1332 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1333 DEBUG(0, ("blocksize <n>\n"));
1334 return 1;
1337 block=atoi(buf);
1338 if (block < 0 || block > 65535) {
1339 DEBUG(0, ("blocksize out of range"));
1340 return 1;
1343 blocksize=block;
1344 DEBUG(2,("blocksize is now %d\n", blocksize));
1345 return 0;
1348 /****************************************************************************
1349 command to set incremental / reset mode
1350 ***************************************************************************/
1352 int cmd_tarmode(void)
1354 TALLOC_CTX *ctx = talloc_tos();
1355 char *buf;
1357 while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1358 if (strequal(buf, "full"))
1359 tar_inc=False;
1360 else if (strequal(buf, "inc"))
1361 tar_inc=True;
1362 else if (strequal(buf, "reset"))
1363 tar_reset=True;
1364 else if (strequal(buf, "noreset"))
1365 tar_reset=False;
1366 else if (strequal(buf, "system"))
1367 tar_system=True;
1368 else if (strequal(buf, "nosystem"))
1369 tar_system=False;
1370 else if (strequal(buf, "hidden"))
1371 tar_hidden=True;
1372 else if (strequal(buf, "nohidden"))
1373 tar_hidden=False;
1374 else if (strequal(buf, "verbose") || strequal(buf, "noquiet"))
1375 tar_noisy=True;
1376 else if (strequal(buf, "quiet") || strequal(buf, "noverbose"))
1377 tar_noisy=False;
1378 else
1379 DEBUG(0, ("tarmode: unrecognised option %s\n", buf));
1380 TALLOC_FREE(buf);
1383 DEBUG(0, ("tarmode is now %s, %s, %s, %s, %s\n",
1384 tar_inc ? "incremental" : "full",
1385 tar_system ? "system" : "nosystem",
1386 tar_hidden ? "hidden" : "nohidden",
1387 tar_reset ? "reset" : "noreset",
1388 tar_noisy ? "verbose" : "quiet"));
1389 return 0;
1392 /****************************************************************************
1393 Feeble attrib command
1394 ***************************************************************************/
1396 int cmd_setmode(void)
1398 TALLOC_CTX *ctx = talloc_tos();
1399 char *q;
1400 char *buf;
1401 char *fname = NULL;
1402 uint16 attra[2];
1403 int direct=1;
1405 attra[0] = attra[1] = 0;
1407 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1408 DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
1409 return 1;
1412 fname = talloc_asprintf(ctx,
1413 "%s%s",
1414 client_get_cur_dir(),
1415 buf);
1416 if (!fname) {
1417 return 1;
1420 while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1421 q=buf;
1423 while(*q) {
1424 switch (*q++) {
1425 case '+':
1426 direct=1;
1427 break;
1428 case '-':
1429 direct=0;
1430 break;
1431 case 'r':
1432 attra[direct]|=FILE_ATTRIBUTE_READONLY;
1433 break;
1434 case 'h':
1435 attra[direct]|=FILE_ATTRIBUTE_HIDDEN;
1436 break;
1437 case 's':
1438 attra[direct]|=FILE_ATTRIBUTE_SYSTEM;
1439 break;
1440 case 'a':
1441 attra[direct]|=FILE_ATTRIBUTE_ARCHIVE;
1442 break;
1443 default:
1444 DEBUG(0, ("setmode <filename> <perm=[+|-]rsha>\n"));
1445 return 1;
1450 if (attra[ATTRSET]==0 && attra[ATTRRESET]==0) {
1451 DEBUG(0, ("setmode <filename> <[+|-]rsha>\n"));
1452 return 1;
1455 DEBUG(2, ("\nperm set %d %d\n", attra[ATTRSET], attra[ATTRRESET]));
1456 do_setrattr(fname, attra[ATTRSET], ATTRSET);
1457 do_setrattr(fname, attra[ATTRRESET], ATTRRESET);
1458 return 0;
1462 Convert list of tokens to array; dependent on above routine.
1463 Uses the global cmd_ptr from above - bit of a hack.
1466 static char **toktocliplist(int *ctok, const char *sep)
1468 char *s=(char *)cmd_ptr;
1469 int ictok=0;
1470 char **ret, **iret;
1472 if (!sep)
1473 sep = " \t\n\r";
1475 while(*s && strchr_m(sep,*s))
1476 s++;
1478 /* nothing left? */
1479 if (!*s)
1480 return(NULL);
1482 do {
1483 ictok++;
1484 while(*s && (!strchr_m(sep,*s)))
1485 s++;
1486 while(*s && strchr_m(sep,*s))
1487 *s++=0;
1488 } while(*s);
1490 *ctok=ictok;
1491 s=(char *)cmd_ptr;
1493 if (!(ret=iret=SMB_MALLOC_ARRAY(char *,ictok+1)))
1494 return NULL;
1496 while(ictok--) {
1497 *iret++=s;
1498 if (ictok > 0) {
1499 while(*s++)
1501 while(!*s)
1502 s++;
1506 ret[*ctok] = NULL;
1507 return ret;
1510 /****************************************************************************
1511 Principal command for creating / extracting
1512 ***************************************************************************/
1514 int cmd_tar(void)
1516 TALLOC_CTX *ctx = talloc_tos();
1517 char *buf;
1518 char **argl = NULL;
1519 int argcl = 0;
1520 int ret;
1522 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1523 DEBUG(0,("tar <c|x>[IXbgan] <filename>\n"));
1524 return 1;
1527 argl=toktocliplist(&argcl, NULL);
1528 if (!tar_parseargs(argcl, argl, buf, 0)) {
1529 SAFE_FREE(argl);
1530 return 1;
1533 ret = process_tar();
1534 SAFE_FREE(argl);
1535 return ret;
1538 /****************************************************************************
1539 Command line (option) version
1540 ***************************************************************************/
1542 int process_tar(void)
1544 TALLOC_CTX *ctx = talloc_tos();
1545 int rc = 0;
1546 initarbuf();
1547 switch(tar_type) {
1548 case 'x':
1550 #if 0
1551 do_tarput2();
1552 #else
1553 do_tarput();
1554 #endif
1555 SAFE_FREE(tarbuf);
1556 close(tarhandle);
1557 break;
1558 case 'r':
1559 case 'c':
1560 if (clipn && tar_excl) {
1561 int i;
1562 char *tarmac = NULL;
1564 for (i=0; i<clipn; i++) {
1565 DEBUG(5,("arg %d = %s\n", i, cliplist[i]));
1567 if (*(cliplist[i]+strlen(cliplist[i])-1)=='\\') {
1568 *(cliplist[i]+strlen(cliplist[i])-1)='\0';
1571 if (strrchr_m(cliplist[i], '\\')) {
1572 char *p;
1573 char saved_char;
1574 char *saved_dir = talloc_strdup(ctx,
1575 client_get_cur_dir());
1576 if (!saved_dir) {
1577 return 1;
1580 if (*cliplist[i]=='\\') {
1581 tarmac = talloc_strdup(ctx,
1582 cliplist[i]);
1583 } else {
1584 tarmac = talloc_asprintf(ctx,
1585 "%s%s",
1586 client_get_cur_dir(),
1587 cliplist[i]);
1589 if (!tarmac) {
1590 return 1;
1593 * Strip off the last \\xxx
1594 * xxx element of tarmac to set
1595 * it as current directory.
1597 p = strrchr_m(tarmac, '\\');
1598 if (!p) {
1599 return 1;
1601 saved_char = p[1];
1602 p[1] = '\0';
1604 client_set_cur_dir(tarmac);
1607 * Restore the character we
1608 * just replaced to
1609 * put the pathname
1610 * back as it was.
1612 p[1] = saved_char;
1614 DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac));
1615 do_list(tarmac,attribute,do_tar, False, True);
1617 client_set_cur_dir(saved_dir);
1619 TALLOC_FREE(saved_dir);
1620 TALLOC_FREE(tarmac);
1621 } else {
1622 tarmac = talloc_asprintf(ctx,
1623 "%s%s",
1624 client_get_cur_dir(),
1625 cliplist[i]);
1626 if (!tarmac) {
1627 return 1;
1629 DEBUG(5, ("process_tar, do_list with tarmac: %s\n", tarmac));
1630 do_list(tarmac,attribute,do_tar, False, True);
1631 TALLOC_FREE(tarmac);
1634 } else {
1635 char *mask = talloc_asprintf(ctx,
1636 "%s\\*",
1637 client_get_cur_dir());
1638 if (!mask) {
1639 return 1;
1641 DEBUG(5, ("process_tar, do_list with mask: %s\n", mask));
1642 do_list(mask,attribute,do_tar,False, True);
1643 TALLOC_FREE(mask);
1646 if (ntarf) {
1647 dotareof(tarhandle);
1649 close(tarhandle);
1650 SAFE_FREE(tarbuf);
1652 DEBUG(0, ("tar: dumped %d files and directories\n", ntarf));
1653 DEBUG(0, ("Total bytes written: %.0f\n", (double)ttarf));
1654 break;
1657 if (must_free_cliplist) {
1658 int i;
1659 for (i = 0; i < clipn; ++i) {
1660 SAFE_FREE(cliplist[i]);
1662 SAFE_FREE(cliplist);
1663 cliplist = NULL;
1664 clipn = 0;
1665 must_free_cliplist = False;
1667 return rc;
1670 /****************************************************************************
1671 Find a token (filename) in a clip list
1672 ***************************************************************************/
1674 static int clipfind(char **aret, int ret, char *tok)
1676 if (aret==NULL)
1677 return 0;
1679 /* ignore leading slashes or dots in token */
1680 while(strchr_m("/\\.", *tok))
1681 tok++;
1683 while(ret--) {
1684 char *pkey=*aret++;
1686 /* ignore leading slashes or dots in list */
1687 while(strchr_m("/\\.", *pkey))
1688 pkey++;
1690 if (!strslashcmp(pkey, tok))
1691 return 1;
1693 return 0;
1696 /****************************************************************************
1697 Read list of files to include from the file and initialize cliplist
1698 accordingly.
1699 ***************************************************************************/
1701 static int read_inclusion_file(char *filename)
1703 XFILE *inclusion = NULL;
1704 char buf[PATH_MAX + 1];
1705 char *inclusion_buffer = NULL;
1706 int inclusion_buffer_size = 0;
1707 int inclusion_buffer_sofar = 0;
1708 char *p;
1709 char *tmpstr;
1710 int i;
1711 int error = 0;
1713 clipn = 0;
1714 buf[PATH_MAX] = '\0'; /* guarantee null-termination */
1715 if ((inclusion = x_fopen(filename, O_RDONLY, 0)) == NULL) {
1716 /* XXX It would be better to include a reason for failure, but without
1717 * autoconf, it's hard to use strerror, sys_errlist, etc.
1719 DEBUG(0,("Unable to open inclusion file %s\n", filename));
1720 return 0;
1723 while ((! error) && (x_fgets(buf, sizeof(buf)-1, inclusion))) {
1724 if (inclusion_buffer == NULL) {
1725 inclusion_buffer_size = 1024;
1726 if ((inclusion_buffer = (char *)SMB_MALLOC(inclusion_buffer_size)) == NULL) {
1727 DEBUG(0,("failure allocating buffer to read inclusion file\n"));
1728 error = 1;
1729 break;
1733 if (buf[strlen(buf)-1] == '\n') {
1734 buf[strlen(buf)-1] = '\0';
1737 if ((strlen(buf) + 1 + inclusion_buffer_sofar) >= inclusion_buffer_size) {
1738 inclusion_buffer_size *= 2;
1739 inclusion_buffer = (char *)SMB_REALLOC(inclusion_buffer,inclusion_buffer_size);
1740 if (!inclusion_buffer) {
1741 DEBUG(0,("failure enlarging inclusion buffer to %d bytes\n",
1742 inclusion_buffer_size));
1743 error = 1;
1744 break;
1748 safe_strcpy(inclusion_buffer + inclusion_buffer_sofar, buf, inclusion_buffer_size - inclusion_buffer_sofar);
1749 inclusion_buffer_sofar += strlen(buf) + 1;
1750 clipn++;
1752 x_fclose(inclusion);
1754 if (! error) {
1755 /* Allocate an array of clipn + 1 char*'s for cliplist */
1756 cliplist = SMB_MALLOC_ARRAY(char *, clipn + 1);
1757 if (cliplist == NULL) {
1758 DEBUG(0,("failure allocating memory for cliplist\n"));
1759 error = 1;
1760 } else {
1761 cliplist[clipn] = NULL;
1762 p = inclusion_buffer;
1763 for (i = 0; (! error) && (i < clipn); i++) {
1764 /* set current item to NULL so array will be null-terminated even if
1765 * malloc fails below. */
1766 cliplist[i] = NULL;
1767 if ((tmpstr = (char *)SMB_MALLOC(strlen(p)+1)) == NULL) {
1768 DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", i));
1769 error = 1;
1770 } else {
1771 unfixtarname(tmpstr, p, strlen(p) + 1, True);
1772 cliplist[i] = tmpstr;
1773 if ((p = strchr_m(p, '\000')) == NULL) {
1774 DEBUG(0,("INTERNAL ERROR: inclusion_buffer is of unexpected contents.\n"));
1775 abort();
1778 ++p;
1780 must_free_cliplist = True;
1784 SAFE_FREE(inclusion_buffer);
1785 if (error) {
1786 if (cliplist) {
1787 char **pp;
1788 /* We know cliplist is always null-terminated */
1789 for (pp = cliplist; *pp; ++pp) {
1790 SAFE_FREE(*pp);
1792 SAFE_FREE(cliplist);
1793 cliplist = NULL;
1794 must_free_cliplist = False;
1796 return 0;
1799 /* cliplist and its elements are freed at the end of process_tar. */
1800 return 1;
1803 /****************************************************************************
1804 Parse tar arguments. Sets tar_type, tar_excl, etc.
1805 ***************************************************************************/
1807 int tar_parseargs(int argc, char *argv[], const char *Optarg, int Optind)
1809 int newOptind = Optind;
1810 char tar_clipfl='\0';
1812 /* Reset back to defaults - could be from interactive version
1813 * reset mode and archive mode left as they are though
1815 tar_type='\0';
1816 tar_excl=True;
1817 dry_run=False;
1819 while (*Optarg) {
1820 switch(*Optarg++) {
1821 case 'c':
1822 tar_type='c';
1823 break;
1824 case 'x':
1825 if (tar_type=='c') {
1826 printf("Tar must be followed by only one of c or x.\n");
1827 return 0;
1829 tar_type='x';
1830 break;
1831 case 'b':
1832 if (Optind>=argc || !(blocksize=atoi(argv[Optind]))) {
1833 DEBUG(0,("Option b must be followed by valid blocksize\n"));
1834 return 0;
1835 } else {
1836 Optind++;
1837 newOptind++;
1839 break;
1840 case 'g':
1841 tar_inc=True;
1842 break;
1843 case 'N':
1844 if (Optind>=argc) {
1845 DEBUG(0,("Option N must be followed by valid file name\n"));
1846 return 0;
1847 } else {
1848 SMB_STRUCT_STAT stbuf;
1850 if (sys_stat(argv[Optind], &stbuf,
1851 false) == 0) {
1852 newer_than = convert_timespec_to_time_t(
1853 stbuf.st_ex_mtime);
1854 DEBUG(1,("Getting files newer than %s",
1855 time_to_asc(newer_than)));
1856 newOptind++;
1857 Optind++;
1858 } else {
1859 DEBUG(0,("Error setting newer-than time\n"));
1860 return 0;
1863 break;
1864 case 'a':
1865 tar_reset=True;
1866 break;
1867 case 'q':
1868 tar_noisy=False;
1869 break;
1870 case 'I':
1871 if (tar_clipfl) {
1872 DEBUG(0,("Only one of I,X,F must be specified\n"));
1873 return 0;
1875 tar_clipfl='I';
1876 break;
1877 case 'X':
1878 if (tar_clipfl) {
1879 DEBUG(0,("Only one of I,X,F must be specified\n"));
1880 return 0;
1882 tar_clipfl='X';
1883 break;
1884 case 'F':
1885 if (tar_clipfl) {
1886 DEBUG(0,("Only one of I,X,F must be specified\n"));
1887 return 0;
1889 tar_clipfl='F';
1890 break;
1891 case 'r':
1892 DEBUG(0, ("tar_re_search set\n"));
1893 tar_re_search = True;
1894 break;
1895 case 'n':
1896 if (tar_type == 'c') {
1897 DEBUG(0, ("dry_run set\n"));
1898 dry_run = True;
1899 } else {
1900 DEBUG(0, ("n is only meaningful when creating a tar-file\n"));
1901 return 0;
1903 break;
1904 default:
1905 DEBUG(0,("Unknown tar option\n"));
1906 return 0;
1910 if (!tar_type) {
1911 printf("Option T must be followed by one of c or x.\n");
1912 return 0;
1915 /* tar_excl is true if cliplist lists files to be included.
1916 * Both 'I' and 'F' mean include. */
1917 tar_excl=tar_clipfl!='X';
1919 if (tar_clipfl=='F') {
1920 if (argc-Optind-1 != 1) {
1921 DEBUG(0,("Option F must be followed by exactly one filename.\n"));
1922 return 0;
1924 newOptind++;
1925 /* Optind points at the tar output file, Optind+1 at the inclusion file. */
1926 if (! read_inclusion_file(argv[Optind+1])) {
1927 return 0;
1929 } else if (Optind+1<argc && !tar_re_search) { /* For backwards compatibility */
1930 char *tmpstr;
1931 char **tmplist;
1932 int clipcount;
1934 cliplist=argv+Optind+1;
1935 clipn=argc-Optind-1;
1936 clipcount = clipn;
1938 if ((tmplist=SMB_MALLOC_ARRAY(char *,clipn)) == NULL) {
1939 DEBUG(0, ("Could not allocate space to process cliplist, count = %i\n", clipn));
1940 return 0;
1943 for (clipcount = 0; clipcount < clipn; clipcount++) {
1945 DEBUG(5, ("Processing an item, %s\n", cliplist[clipcount]));
1947 if ((tmpstr = (char *)SMB_MALLOC(strlen(cliplist[clipcount])+1)) == NULL) {
1948 DEBUG(0, ("Could not allocate space for a cliplist item, # %i\n", clipcount));
1949 SAFE_FREE(tmplist);
1950 return 0;
1953 unfixtarname(tmpstr, cliplist[clipcount], strlen(cliplist[clipcount]) + 1, True);
1954 tmplist[clipcount] = tmpstr;
1955 DEBUG(5, ("Processed an item, %s\n", tmpstr));
1957 DEBUG(5, ("Cliplist is: %s\n", cliplist[0]));
1960 cliplist = tmplist;
1961 must_free_cliplist = True;
1963 newOptind += clipn;
1966 if (Optind+1<argc && tar_re_search && tar_clipfl != 'F') {
1967 /* Doing regular expression seaches not from an inclusion file. */
1968 clipn=argc-Optind-1;
1969 cliplist=argv+Optind+1;
1970 newOptind += clipn;
1973 if (Optind>=argc || !strcmp(argv[Optind], "-")) {
1974 /* Sets tar handle to either 0 or 1, as appropriate */
1975 tarhandle=(tar_type=='c');
1977 * Make sure that dbf points to stderr if we are using stdout for
1978 * tar output
1980 if (tarhandle == 1) {
1981 setup_logging("smbclient", DEBUG_STDERR);
1983 if (!argv[Optind]) {
1984 DEBUG(0,("Must specify tar filename\n"));
1985 return 0;
1987 if (!strcmp(argv[Optind], "-")) {
1988 newOptind++;
1991 } else {
1992 if (tar_type=='c' && dry_run) {
1993 tarhandle=-1;
1994 } else if ((tar_type=='x' && (tarhandle = sys_open(argv[Optind], O_RDONLY, 0)) == -1)
1995 || (tar_type=='c' && (tarhandle=sys_creat(argv[Optind], 0644)) < 0)) {
1996 DEBUG(0,("Error opening local file %s - %s\n", argv[Optind], strerror(errno)));
1997 return(0);
1999 newOptind++;
2002 return newOptind;