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