2 Unix SMB/CIFS implementation.
3 Tar backup command extension
4 Copyright (C) Aurélien Aptel 2013
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 * # General overview of the tar extension
23 * All tar_xxx() functions work on a `struct tar` which store most of
24 * the context of the backup process.
26 * The current tar context can be accessed via the global variable
27 * `tar_ctx`. It's publicly exported as an opaque handle via
30 * A tar context is first configured through tar_parse_args() which
31 * can be called from either the CLI (in client.c) or the interactive
32 * session (via the cmd_tar() callback).
34 * Once the configuration is done (successfully), the context is ready
35 * for processing and tar_to_process() returns true.
37 * The next step is to call tar_process() which dispatch the
38 * processing to either tar_create() or tar_extract(), depending on
43 * tar_create() creates an archive using the libarchive API then
45 * - iterates on the requested paths if the context is in inclusion
46 * mode with tar_create_from_list()
48 * - or iterates on the whole share (starting from the current dir) if
49 * in exclusion mode or if no specific path were requested
51 * The do_list() function from client.c is used to list recursively
52 * the share. In particular it takes a DOS path mask (eg. \mydir\*)
53 * and a callback function which will be called with each file name
54 * and attributes. The tar callback function is get_file_callback().
56 * The callback function checks whether the file should be skipped
57 * according the the configuration via tar_create_skip_path(). If it's
58 * not skipped it's downloaded and written to the archive in
61 * ## Archive extraction
63 * tar_extract() opens the archive and iterates on each file in
64 * it. For each file tar_extract_skip_path() checks whether it should
65 * be skipped according to the config. If it's not skipped it's
66 * uploaded on the server in tar_send_file().
70 #include "system/filesys.h"
71 #include "client/client_proto.h"
72 #include "client/clitar_proto.h"
73 #include "libsmb/libsmb.h"
75 #ifdef HAVE_LIBARCHIVE
78 #include <archive_entry.h>
80 /* prepend module name and line number to debug messages */
81 #define DBG(a, b) (DEBUG(a, ("tar:%-4d ", __LINE__)), DEBUG(a, b))
83 /* preprocessor magic to stringify __LINE__ (int) */
85 #define STR2(x) STR1(x)
88 * Number of byte in a block unit.
90 #define TAR_BLOCK_UNIT 512
93 * Default tar block size in TAR_BLOCK_UNIT.
95 #define TAR_DEFAULT_BLOCK_SIZE 20
98 * Maximum value for the blocksize field
100 #define TAR_MAX_BLOCK_SIZE 0xffff
103 * Size of the buffer used when downloading a file
105 #define TAR_CLI_READ_SIZE 0xff00
107 #define TAR_DO_LIST_ATTR (FILE_ATTRIBUTE_DIRECTORY \
108 | FILE_ATTRIBUTE_SYSTEM \
109 | FILE_ATTRIBUTE_HIDDEN)
114 TAR_CREATE
, /* c flag */
115 TAR_EXTRACT
, /* x flag */
120 TAR_INCLUDE
, /* I and F flag, default */
121 TAR_EXCLUDE
, /* X flag */
125 TALLOC_CTX
*talloc_ctx
;
127 /* in state that needs/can be processed? */
132 enum tar_operation operation
; /* create, extract */
133 enum tar_selection selection
; /* include, exclude */
134 int blocksize
; /* size in TAR_BLOCK_UNIT of a tar file block */
135 bool hidden
; /* backup hidden file? */
136 bool system
; /* backup system file? */
137 bool incremental
; /* backup _only_ archived file? */
138 bool reset
; /* unset archive bit? */
139 bool dry
; /* don't write tar file? */
140 bool regex
; /* XXX: never actually using regex... */
141 bool verbose
; /* XXX: ignored */
144 /* nb of bytes received */
147 /* path to tar archive name */
150 /* list of path to include or exclude */
155 struct archive
*archive
;
159 * Global context imported in client.c when needed.
163 struct tar tar_ctx
= {
164 .mode
.selection
= TAR_INCLUDE
,
165 .mode
.blocksize
= TAR_DEFAULT_BLOCK_SIZE
,
168 .mode
.incremental
= false,
172 .mode
.verbose
= false,
175 /* tar, local function */
176 static int tar_create(struct tar
* t
);
177 static int tar_create_from_list(struct tar
*t
);
178 static int tar_extract(struct tar
*t
);
179 static int tar_read_inclusion_file(struct tar
*t
, const char* filename
);
180 static int tar_send_file(struct tar
*t
, struct archive_entry
*entry
);
181 static int tar_set_blocksize(struct tar
*t
, int size
);
182 static int tar_set_newer_than(struct tar
*t
, const char *filename
);
183 static NTSTATUS
tar_add_selection_path(struct tar
*t
, const char *path
);
184 static void tar_dump(struct tar
*t
);
185 static NTSTATUS
tar_extract_skip_path(struct tar
*t
,
186 struct archive_entry
*entry
,
188 static TALLOC_CTX
*tar_reset_mem_context(struct tar
*t
);
189 static void tar_free_mem_context(struct tar
*t
);
190 static NTSTATUS
tar_create_skip_path(struct tar
*t
,
191 const char *fullpath
,
192 const struct file_info
*finfo
,
195 static NTSTATUS
tar_path_in_list(struct tar
*t
, const char *path
,
196 bool reverse
, bool *_is_in_list
);
198 static int tar_get_file(struct tar
*t
,
199 const char *full_dos_path
,
200 struct file_info
*finfo
);
202 static NTSTATUS
get_file_callback(struct cli_state
*cli
,
203 struct file_info
*finfo
,
207 static char *fix_unix_path(char *path
, bool removeprefix
);
208 static NTSTATUS
path_base_name(TALLOC_CTX
*ctx
, const char *path
, char **_base
);
209 static const char* skip_useless_char_in_path(const char *p
);
210 static int make_remote_path(const char *full_path
);
211 static int max_token (const char *str
);
212 static NTSTATUS
is_subpath(const char *sub
, const char *full
,
213 bool *_subpath_match
);
216 * tar_get_ctx - retrieve global tar context handle
218 struct tar
*tar_get_ctx()
224 * cmd_block - interactive command to change tar blocksize
226 * Read a size from the client command line and update the current
231 /* XXX: from client.c */
232 const extern char *cmd_ptr
;
236 TALLOC_CTX
*ctx
= talloc_new(NULL
);
241 ok
= next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
);
243 DBG(0, ("blocksize <n>\n"));
248 ok
= tar_set_blocksize(&tar_ctx
, atoi(buf
));
250 DBG(0, ("invalid blocksize\n"));
255 DBG(2, ("blocksize is now %d\n", tar_ctx
.mode
.blocksize
));
263 * cmd_tarmode - interactive command to change tar behaviour
265 * Read one or more modes from the client command line and update the
268 int cmd_tarmode(void)
270 const extern char *cmd_ptr
;
280 {"full", &tar_ctx
.mode
.incremental
, false},
281 {"inc", &tar_ctx
.mode
.incremental
, true },
282 {"reset", &tar_ctx
.mode
.reset
, true },
283 {"noreset", &tar_ctx
.mode
.reset
, false},
284 {"system", &tar_ctx
.mode
.system
, true },
285 {"nosystem", &tar_ctx
.mode
.system
, false},
286 {"hidden", &tar_ctx
.mode
.hidden
, true },
287 {"nohidden", &tar_ctx
.mode
.hidden
, false},
288 {"verbose", &tar_ctx
.mode
.verbose
, true },
289 {"noquiet", &tar_ctx
.mode
.verbose
, true },
290 {"quiet", &tar_ctx
.mode
.verbose
, false},
291 {"noverbose", &tar_ctx
.mode
.verbose
, false},
294 ctx
= talloc_new(NULL
);
299 while (next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
300 for (i
= 0; i
< ARRAY_SIZE(table
); i
++) {
301 if (strequal(table
[i
].cmd
, buf
)) {
302 *table
[i
].p
= table
[i
].value
;
307 if (i
== ARRAY_SIZE(table
))
308 DBG(0, ("tarmode: unrecognised option %s\n", buf
));
311 DBG(0, ("tarmode is now %s, %s, %s, %s, %s\n",
312 tar_ctx
.mode
.incremental
? "incremental" : "full",
313 tar_ctx
.mode
.system
? "system" : "nosystem",
314 tar_ctx
.mode
.hidden
? "hidden" : "nohidden",
315 tar_ctx
.mode
.reset
? "reset" : "noreset",
316 tar_ctx
.mode
.verbose
? "verbose" : "quiet"));
323 * cmd_tar - interactive command to start a tar backup/restoration
325 * Check presence of argument, parse them and handle the request.
329 const extern char *cmd_ptr
;
333 int maxtok
= max_token(cmd_ptr
);
338 TALLOC_CTX
*ctx
= talloc_new(NULL
);
343 ok
= next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
);
345 DBG(0, ("tar <c|x>[IXFbganN] [options] <tar file> [path list]\n"));
351 val
= talloc_array(ctx
, const char *, maxtok
);
357 while (next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
361 rc
= tar_parse_args(&tar_ctx
, flag
, val
, i
);
363 DBG(0, ("parse_args failed\n"));
368 rc
= tar_process(&tar_ctx
);
370 DBG(0, ("tar_process failed\n"));
382 * tar_parse_args - parse and set tar command line arguments
383 * @flag: string pointing to tar options
384 * @val: number of tar arguments
385 * @valsize: table of arguments after the flags (number of element in val)
387 * tar arguments work in a weird way. For each flag f that takes a
388 * value v, the user is supposed to type:
391 * -Tf1f2f3 v1 v2 v3 TARFILE PATHS...
393 * in the interactive session:
394 * tar f1f2f3 v1 v2 v3 TARFILE PATHS...
396 * @flag has only flags (eg. "f1f2f3") and @val has the arguments
397 * (values) following them (eg. ["v1", "v2", "v3", "TARFILE", "PATH1",
400 * There are only 2 flags that take an arg: b and N. The other flags
401 * just change the semantic of PATH or TARFILE.
403 * PATH can be a list of included/excluded paths, the path to a file
404 * containing a list of included/excluded paths to use (F flag). If no
405 * PATH is provided, the whole share is used (/).
407 int tar_parse_args(struct tar
* t
,
413 bool do_read_list
= false;
414 /* index of next value to use */
419 DBG(0, ("Invalid tar context\n"));
423 ctx
= tar_reset_mem_context(t
);
428 * Reset back some options - could be from interactive version
429 * all other modes are left as they are
431 t
->mode
.operation
= TAR_NO_OPERATION
;
432 t
->mode
.selection
= TAR_NO_SELECTION
;
434 t
->to_process
= false;
437 while (flag
[0] != '\0') {
441 if (t
->mode
.operation
!= TAR_NO_OPERATION
) {
442 printf("Tar must be followed by only one of c or x.\n");
445 t
->mode
.operation
= TAR_CREATE
;
448 if (t
->mode
.operation
!= TAR_NO_OPERATION
) {
449 printf("Tar must be followed by only one of c or x.\n");
452 t
->mode
.operation
= TAR_EXTRACT
;
457 if (t
->mode
.selection
!= TAR_NO_SELECTION
) {
458 DBG(0,("Only one of I,X,F must be specified\n"));
461 t
->mode
.selection
= TAR_INCLUDE
;
464 if (t
->mode
.selection
!= TAR_NO_SELECTION
) {
465 DBG(0,("Only one of I,X,F must be specified\n"));
468 t
->mode
.selection
= TAR_EXCLUDE
;
471 if (t
->mode
.selection
!= TAR_NO_SELECTION
) {
472 DBG(0,("Only one of I,X,F must be specified\n"));
475 t
->mode
.selection
= TAR_INCLUDE
;
481 if (ival
>= valsize
) {
482 DBG(0, ("Option b must be followed by a blocksize\n"));
486 if (tar_set_blocksize(t
, atoi(val
[ival
]))) {
487 DBG(0, ("Option b must be followed by a valid blocksize\n"));
494 /* incremental mode */
496 t
->mode
.incremental
= true;
501 if (ival
>= valsize
) {
502 DBG(0, ("Option N must be followed by valid file name\n"));
506 if (tar_set_newer_than(t
, val
[ival
])) {
507 DBG(0,("Error setting newer-than time\n"));
516 t
->mode
.reset
= true;
521 t
->mode
.verbose
= true;
526 t
->mode
.regex
= true;
531 if (t
->mode
.operation
!= TAR_CREATE
) {
532 DBG(0, ("n is only meaningful when creating a tar-file\n"));
537 DBG(0, ("dry_run set\n"));
541 DBG(0,("Unknown tar option\n"));
548 /* no selection given? default selection is include */
549 if (t
->mode
.selection
== TAR_NO_SELECTION
) {
550 t
->mode
.selection
= TAR_INCLUDE
;
553 if (valsize
- ival
< 1) {
554 DBG(0, ("No tar file given.\n"));
559 t
->tar_path
= talloc_strdup(ctx
, val
[ival
]);
560 if (t
->tar_path
== NULL
) {
566 * Make sure that dbf points to stderr if we are using stdout for
569 if (t
->mode
.operation
== TAR_CREATE
&& strequal(t
->tar_path
, "-")) {
570 setup_logging("smbclient", DEBUG_STDERR
);
573 /* handle PATHs... */
575 /* flag F -> read file list */
577 if (valsize
- ival
!= 1) {
578 DBG(0,("Option F must be followed by exactly one filename.\n"));
582 rc
= tar_read_inclusion_file(t
, val
[ival
]);
587 /* otherwise store all the PATHs on the command line */
590 for (i
= ival
; i
< valsize
; i
++) {
592 status
= tar_add_selection_path(t
, val
[i
]);
593 if (!NT_STATUS_IS_OK(status
)) {
599 t
->to_process
= true;
605 * tar_process - start processing archive
607 * The talloc context of the fields is freed at the end of the call.
609 int tar_process(struct tar
*t
)
614 DBG(0, ("Invalid tar context\n"));
618 switch(t
->mode
.operation
) {
626 DBG(0, ("Invalid tar state\n"));
630 t
->to_process
= false;
631 tar_free_mem_context(t
);
632 DBG(5, ("tar_process done, err = %d\n", rc
));
637 * tar_create - create archive and fetch files
639 static int tar_create(struct tar
* t
)
645 TALLOC_CTX
*ctx
= talloc_new(NULL
);
650 t
->archive
= archive_write_new();
653 const int bsize
= t
->mode
.blocksize
* TAR_BLOCK_UNIT
;
654 r
= archive_write_set_bytes_per_block(t
->archive
, bsize
);
655 if (r
!= ARCHIVE_OK
) {
656 DBG(0, ("Can't use a block size of %d bytes", bsize
));
662 * Use PAX restricted format which is not the most
663 * conservative choice but has useful extensions and is widely
666 r
= archive_write_set_format_pax_restricted(t
->archive
);
667 if (r
!= ARCHIVE_OK
) {
668 DBG(0, ("Can't use pax restricted format: %s\n",
669 archive_error_string(t
->archive
)));
674 if (strequal(t
->tar_path
, "-")) {
675 r
= archive_write_open_fd(t
->archive
, STDOUT_FILENO
);
677 r
= archive_write_open_filename(t
->archive
, t
->tar_path
);
680 if (r
!= ARCHIVE_OK
) {
681 DBG(0, ("Can't open %s: %s\n", t
->tar_path
,
682 archive_error_string(t
->archive
)));
689 * In inclusion mode, iterate on the inclusion list
691 if (t
->mode
.selection
== TAR_INCLUDE
&& t
->path_list_size
> 0) {
692 if (tar_create_from_list(t
)) {
697 mask
= talloc_asprintf(ctx
, "%s\\*", client_get_cur_dir());
702 mask
= client_clean_name(ctx
, mask
);
707 DBG(5, ("tar_process do_list with mask: %s\n", mask
));
708 status
= do_list(mask
, TAR_DO_LIST_ATTR
, get_file_callback
, false, true);
709 if (!NT_STATUS_IS_OK(status
)) {
710 DBG(0, ("do_list fail %s\n", nt_errstr(status
)));
717 DBG(0, ("Total bytes received: %" PRIu64
"\n", t
->total_size
));
720 r
= archive_write_close(t
->archive
);
721 if (r
!= ARCHIVE_OK
) {
722 DBG(0, ("Fatal: %s\n", archive_error_string(t
->archive
)));
728 #ifdef HAVE_ARCHIVE_READ_FREE
729 archive_write_free(t
->archive
);
731 archive_write_finish(t
->archive
);
738 * tar_create_from_list - fetch from path list in include mode
740 static int tar_create_from_list(struct tar
*t
)
745 const char *path
, *mask
, *start_dir
;
747 TALLOC_CTX
*ctx
= talloc_new(NULL
);
752 start_dir
= talloc_strdup(ctx
, client_get_cur_dir());
753 if (start_dir
== NULL
) {
758 for (i
= 0; i
< t
->path_list_size
; i
++) {
759 path
= t
->path_list
[i
];
761 status
= path_base_name(ctx
, path
, &base
);
762 if (!NT_STATUS_IS_OK(status
)) {
766 mask
= talloc_asprintf(ctx
, "%s\\%s",
767 client_get_cur_dir(), path
);
772 mask
= client_clean_name(ctx
, mask
);
778 DBG(5, ("incl. path='%s', base='%s', mask='%s'\n",
779 path
, base
? base
: "NULL", mask
));
782 base
= talloc_asprintf(ctx
, "%s%s\\",
783 client_get_cur_dir(), base
);
788 base
= client_clean_name(ctx
, base
);
794 DBG(5, ("cd '%s' before do_list\n", base
));
795 client_set_cur_dir(base
);
797 status
= do_list(mask
, TAR_DO_LIST_ATTR
, get_file_callback
, false, true);
799 client_set_cur_dir(start_dir
);
801 if (!NT_STATUS_IS_OK(status
)) {
802 DBG(0, ("do_list failed on %s (%s)\n", path
, nt_errstr(status
)));
814 * get_file_callback - do_list callback
816 * Callback for client.c do_list(). Called for each file found on the
817 * share matching do_list mask. Recursively call do_list() with itself
818 * as callback when the current file is a directory.
820 static NTSTATUS
get_file_callback(struct cli_state
*cli
,
821 struct file_info
*finfo
,
824 NTSTATUS status
= NT_STATUS_OK
;
826 const char *initial_dir
= client_get_cur_dir();
829 TALLOC_CTX
*ctx
= talloc_new(NULL
);
831 return NT_STATUS_NO_MEMORY
;
834 remote_name
= talloc_asprintf(ctx
, "%s%s", initial_dir
, finfo
->name
);
835 if (remote_name
== NULL
) {
836 status
= NT_STATUS_NO_MEMORY
;
839 remote_name
= client_clean_name(ctx
, remote_name
);
840 if (remote_name
== NULL
) {
841 status
= NT_STATUS_NO_MEMORY
;
845 if (strequal(finfo
->name
, "..") || strequal(finfo
->name
, ".")) {
849 status
= tar_create_skip_path(&tar_ctx
, remote_name
, finfo
, &skip
);
850 if (!NT_STATUS_IS_OK(status
)) {
855 DBG(5, ("--- %s\n", remote_name
));
856 status
= NT_STATUS_OK
;
860 if (finfo
->mode
& FILE_ATTRIBUTE_DIRECTORY
) {
865 old_dir
= talloc_strdup(ctx
, initial_dir
);
866 new_dir
= talloc_asprintf(ctx
, "%s%s\\",
867 initial_dir
, finfo
->name
);
868 if ((old_dir
== NULL
) || (new_dir
== NULL
)) {
869 status
= NT_STATUS_NO_MEMORY
;
872 mask
= talloc_asprintf(ctx
, "%s*", new_dir
);
874 status
= NT_STATUS_NO_MEMORY
;
877 mask
= client_clean_name(ctx
, mask
);
879 status
= NT_STATUS_NO_MEMORY
;
883 rc
= tar_get_file(&tar_ctx
, remote_name
, finfo
);
885 status
= NT_STATUS_UNSUCCESSFUL
;
889 client_set_cur_dir(new_dir
);
890 do_list(mask
, TAR_DO_LIST_ATTR
, get_file_callback
, false, true);
891 client_set_cur_dir(old_dir
);
893 rc
= tar_get_file(&tar_ctx
, remote_name
, finfo
);
895 status
= NT_STATUS_UNSUCCESSFUL
;
906 * tar_get_file - fetch a remote file to the local archive
907 * @full_dos_path: path to the file to fetch
908 * @finfo: attributes of the file to fetch
910 static int tar_get_file(struct tar
*t
,
911 const char *full_dos_path
,
912 struct file_info
*finfo
)
914 extern struct cli_state
*cli
;
916 struct archive_entry
*entry
;
917 char *full_unix_path
;
918 char buf
[TAR_CLI_READ_SIZE
];
921 uint16_t remote_fd
= (uint16_t)-1;
923 const bool isdir
= finfo
->mode
& FILE_ATTRIBUTE_DIRECTORY
;
924 TALLOC_CTX
*ctx
= talloc_new(NULL
);
929 DBG(5, ("+++ %s\n", full_dos_path
));
931 t
->total_size
+= finfo
->size
;
938 /* ignore return value: server might not store DOS attributes */
939 set_remote_attr(full_dos_path
, FILE_ATTRIBUTE_ARCHIVE
, ATTR_UNSET
);
942 full_unix_path
= talloc_asprintf(ctx
, ".%s", full_dos_path
);
943 if (full_unix_path
== NULL
) {
947 string_replace(full_unix_path
, '\\', '/');
948 entry
= archive_entry_new();
949 archive_entry_copy_pathname(entry
, full_unix_path
);
950 archive_entry_set_filetype(entry
, isdir
? AE_IFDIR
: AE_IFREG
);
951 archive_entry_set_atime(entry
,
952 finfo
->atime_ts
.tv_sec
,
953 finfo
->atime_ts
.tv_nsec
);
954 archive_entry_set_mtime(entry
,
955 finfo
->mtime_ts
.tv_sec
,
956 finfo
->mtime_ts
.tv_nsec
);
957 archive_entry_set_ctime(entry
,
958 finfo
->ctime_ts
.tv_sec
,
959 finfo
->ctime_ts
.tv_nsec
);
960 archive_entry_set_perm(entry
, isdir
? 0755 : 0644);
962 * check if we can safely cast unsigned file size to libarchive
963 * signed size. Very unlikely problem (>9 exabyte file)
965 if (finfo
->size
> INT64_MAX
) {
966 DBG(0, ("Remote file %s too big\n", full_dos_path
));
970 archive_entry_set_size(entry
, (int64_t)finfo
->size
);
972 r
= archive_write_header(t
->archive
, entry
);
973 if (r
!= ARCHIVE_OK
) {
974 DBG(0, ("Fatal: %s\n", archive_error_string(t
->archive
)));
980 DBG(5, ("get_file skip dir %s\n", full_dos_path
));
984 status
= cli_open(cli
, full_dos_path
, O_RDONLY
, DENY_NONE
, &remote_fd
);
985 if (!NT_STATUS_IS_OK(status
)) {
986 DBG(0,("%s opening remote file %s\n",
987 nt_errstr(status
), full_dos_path
));
992 status
= cli_read(cli
, remote_fd
, buf
, off
, sizeof(buf
), &len
);
993 if (!NT_STATUS_IS_OK(status
)) {
994 DBG(0,("Error reading file %s : %s\n",
995 full_dos_path
, nt_errstr(status
)));
1002 r
= archive_write_data(t
->archive
, buf
, len
);
1004 DBG(0, ("Fatal: %s\n", archive_error_string(t
->archive
)));
1009 } while (off
< finfo
->size
);
1012 cli_close(cli
, remote_fd
);
1015 archive_entry_free(entry
);
1023 * tar_extract - open archive and send files.
1025 static int tar_extract(struct tar
*t
)
1029 struct archive_entry
*entry
;
1030 const size_t bsize
= t
->mode
.blocksize
* TAR_BLOCK_UNIT
;
1033 t
->archive
= archive_read_new();
1034 archive_read_support_format_all(t
->archive
);
1035 #ifdef HAVE_ARCHIVE_READ_SUPPORT_FILTER_ALL
1036 archive_read_support_filter_all(t
->archive
);
1039 if (strequal(t
->tar_path
, "-")) {
1040 r
= archive_read_open_fd(t
->archive
, STDIN_FILENO
, bsize
);
1042 r
= archive_read_open_filename(t
->archive
, t
->tar_path
, bsize
);
1045 if (r
!= ARCHIVE_OK
) {
1046 DBG(0, ("Can't open %s : %s\n", t
->tar_path
,
1047 archive_error_string(t
->archive
)));
1055 r
= archive_read_next_header(t
->archive
, &entry
);
1056 if (r
== ARCHIVE_EOF
) {
1059 if (r
== ARCHIVE_WARN
) {
1060 DBG(0, ("Warning: %s\n", archive_error_string(t
->archive
)));
1062 if (r
== ARCHIVE_FATAL
) {
1063 DBG(0, ("Fatal: %s\n", archive_error_string(t
->archive
)));
1068 status
= tar_extract_skip_path(t
, entry
, &skip
);
1069 if (!NT_STATUS_IS_OK(status
)) {
1074 DBG(5, ("--- %s\n", archive_entry_pathname(entry
)));
1078 DBG(5, ("+++ %s\n", archive_entry_pathname(entry
)));
1080 rc
= tar_send_file(t
, entry
);
1088 #ifdef HAVE_ARCHIVE_READ_FREE
1089 r
= archive_read_free(t
->archive
);
1091 r
= archive_read_finish(t
->archive
);
1093 if (r
!= ARCHIVE_OK
) {
1094 DBG(0, ("Can't close %s : %s\n", t
->tar_path
,
1095 archive_error_string(t
->archive
)));
1102 * tar_send_file - send @entry to the remote server
1103 * @entry: current archive entry
1105 * Handle the creation of the parent directories and transfer the
1106 * entry to a new remote file.
1108 static int tar_send_file(struct tar
*t
, struct archive_entry
*entry
)
1110 extern struct cli_state
*cli
;
1114 uint16_t remote_fd
= (uint16_t) -1;
1116 int flags
= O_RDWR
| O_CREAT
| O_TRUNC
;
1117 mode_t mode
= archive_entry_filetype(entry
);
1119 TALLOC_CTX
*ctx
= talloc_new(NULL
);
1124 dos_path
= talloc_strdup(ctx
, archive_entry_pathname(entry
));
1125 if (dos_path
== NULL
) {
1129 fix_unix_path(dos_path
, true);
1131 full_path
= talloc_strdup(ctx
, client_get_cur_dir());
1132 if (full_path
== NULL
) {
1136 full_path
= talloc_strdup_append(full_path
, dos_path
);
1137 if (full_path
== NULL
) {
1141 full_path
= client_clean_name(ctx
, full_path
);
1142 if (full_path
== NULL
) {
1147 if (mode
!= AE_IFREG
&& mode
!= AE_IFDIR
) {
1148 DBG(0, ("Skipping non-dir & non-regular file %s\n", full_path
));
1152 rc
= make_remote_path(full_path
);
1158 if (mode
== AE_IFDIR
) {
1162 status
= cli_open(cli
, full_path
, flags
, DENY_NONE
, &remote_fd
);
1163 if (!NT_STATUS_IS_OK(status
)) {
1164 DBG(0, ("Error opening remote file %s: %s\n",
1165 full_path
, nt_errstr(status
)));
1176 r
= archive_read_data_block(t
->archive
, &buf
, &len
, &off
);
1177 if (r
== ARCHIVE_EOF
) {
1180 if (r
== ARCHIVE_WARN
) {
1181 DBG(0, ("Warning: %s\n", archive_error_string(t
->archive
)));
1183 if (r
== ARCHIVE_FATAL
) {
1184 DBG(0, ("Fatal: %s\n", archive_error_string(t
->archive
)));
1189 status
= cli_writeall(cli
, remote_fd
, 0, buf
, off
, len
, NULL
);
1190 if (!NT_STATUS_IS_OK(status
)) {
1191 DBG(0, ("Error writing remote file %s: %s\n",
1192 full_path
, nt_errstr(status
)));
1199 status
= cli_close(cli
, remote_fd
);
1200 if (!NT_STATUS_IS_OK(status
)) {
1201 DBG(0, ("Error losing remote file %s: %s\n",
1202 full_path
, nt_errstr(status
)));
1212 * tar_add_selection_path - add a path to the path list
1213 * @path: path to add
1215 static NTSTATUS
tar_add_selection_path(struct tar
*t
, const char *path
)
1218 TALLOC_CTX
*ctx
= t
->talloc_ctx
;
1219 if (!t
->path_list
) {
1220 t
->path_list
= str_list_make_empty(ctx
);
1221 if (t
->path_list
== NULL
) {
1222 return NT_STATUS_NO_MEMORY
;
1224 t
->path_list_size
= 0;
1227 /* cast to silence gcc const-qual warning */
1228 list
= str_list_add((void *)t
->path_list
, path
);
1230 return NT_STATUS_NO_MEMORY
;
1232 t
->path_list
= discard_const_p(char *, list
);
1233 t
->path_list_size
++;
1234 fix_unix_path(t
->path_list
[t
->path_list_size
- 1], true);
1236 return NT_STATUS_OK
;
1240 * tar_set_blocksize - set block size in TAR_BLOCK_UNIT
1242 static int tar_set_blocksize(struct tar
*t
, int size
)
1244 if (size
<= 0 || size
> TAR_MAX_BLOCK_SIZE
) {
1248 t
->mode
.blocksize
= size
;
1254 * tar_set_newer_than - set date threshold of saved files
1255 * @filename: local path to a file
1257 * Only files newer than the modification time of @filename will be
1260 * Note: this function set the global variable newer_than from
1261 * client.c. Thus the time is not a field of the tar structure. See
1262 * cmd_newer() to change its value from an interactive session.
1264 static int tar_set_newer_than(struct tar
*t
, const char *filename
)
1266 extern time_t newer_than
;
1267 SMB_STRUCT_STAT stbuf
;
1270 rc
= sys_stat(filename
, &stbuf
, false);
1272 DBG(0, ("Error setting newer-than time\n"));
1276 newer_than
= convert_timespec_to_time_t(stbuf
.st_ex_mtime
);
1277 DBG(1, ("Getting files newer than %s\n", time_to_asc(newer_than
)));
1282 * tar_read_inclusion_file - set path list from file
1283 * @filename: path to the list file
1285 * Read and add each line of @filename to the path list.
1287 static int tar_read_inclusion_file(struct tar
*t
, const char* filename
)
1292 TALLOC_CTX
*ctx
= talloc_new(NULL
);
1297 fd
= open(filename
, O_RDONLY
);
1299 DBG(0, ("Can't open inclusion file '%s': %s\n", filename
, strerror(errno
)));
1304 for (line
= afdgets(fd
, ctx
, 0);
1306 line
= afdgets(fd
, ctx
, 0)) {
1308 status
= tar_add_selection_path(t
, line
);
1309 if (!NT_STATUS_IS_OK(status
)) {
1324 * tar_path_in_list - check whether @path is in the path list
1325 * @path: path to find
1326 * @reverse: when true also try to find path list element in @path
1327 * @_is_in_list: set if @path is in the path list
1329 * Look at each path of the path list and set @_is_in_list if @path is a
1330 * subpath of one of them.
1332 * If you want /path to be in the path list (path/a/, path/b/) set
1333 * @reverse to true to try to match the other way around.
1335 static NTSTATUS
tar_path_in_list(struct tar
*t
, const char *path
,
1336 bool reverse
, bool *_is_in_list
)
1340 const char *pattern
;
1342 if (path
== NULL
|| path
[0] == '\0') {
1343 *_is_in_list
= false;
1344 return NT_STATUS_OK
;
1347 p
= skip_useless_char_in_path(path
);
1349 for (i
= 0; i
< t
->path_list_size
; i
++) {
1353 pattern
= skip_useless_char_in_path(t
->path_list
[i
]);
1354 status
= is_subpath(p
, pattern
, &is_in_list
);
1355 if (!NT_STATUS_IS_OK(status
)) {
1358 if (reverse
&& !is_in_list
) {
1359 status
= is_subpath(pattern
, p
, &is_in_list
);
1360 if (!NT_STATUS_IS_OK(status
)) {
1365 *_is_in_list
= true;
1366 return NT_STATUS_OK
;
1370 *_is_in_list
= false;
1371 return NT_STATUS_OK
;
1375 * tar_extract_skip_path - check if @entry should be skipped
1376 * @entry: current tar entry
1377 * @_skip: set true if path should be skipped, otherwise false
1379 * Skip predicate for tar extraction (archive to server) only.
1381 static NTSTATUS
tar_extract_skip_path(struct tar
*t
,
1382 struct archive_entry
*entry
,
1385 const char *fullpath
= archive_entry_pathname(entry
);
1388 if (t
->path_list_size
<= 0) {
1390 return NT_STATUS_OK
;
1393 if (t
->mode
.regex
) {
1394 in
= mask_match_list(fullpath
, t
->path_list
, t
->path_list_size
, true);
1396 NTSTATUS status
= tar_path_in_list(t
, fullpath
, false, &in
);
1397 if (!NT_STATUS_IS_OK(status
)) {
1402 if (t
->mode
.selection
== TAR_EXCLUDE
) {
1408 return NT_STATUS_OK
;
1412 * tar_create_skip_path - check if @fullpath shoud be skipped
1413 * @fullpath: full remote path of the current file
1414 * @finfo: remote file attributes
1415 * @_skip: returned skip not
1417 * Skip predicate for tar creation (server to archive) only.
1419 static NTSTATUS
tar_create_skip_path(struct tar
*t
,
1420 const char *fullpath
,
1421 const struct file_info
*finfo
,
1424 /* syntaxic sugar */
1425 const mode_t mode
= finfo
->mode
;
1426 const bool isdir
= mode
& FILE_ATTRIBUTE_DIRECTORY
;
1427 const bool exclude
= t
->mode
.selection
== TAR_EXCLUDE
;
1432 /* 1. if we don't want X and we have X, skip */
1433 if (!t
->mode
.system
&& (mode
& FILE_ATTRIBUTE_SYSTEM
)) {
1435 return NT_STATUS_OK
;
1438 if (!t
->mode
.hidden
&& (mode
& FILE_ATTRIBUTE_HIDDEN
)) {
1440 return NT_STATUS_OK
;
1443 /* 2. if we only want archive and it's not, skip */
1445 if (t
->mode
.incremental
&& !(mode
& FILE_ATTRIBUTE_ARCHIVE
)) {
1447 return NT_STATUS_OK
;
1451 /* 3. is it in the selection list? */
1454 * tar_create_from_list() use the include list as a starting
1455 * point, no need to check
1459 return NT_STATUS_OK
;
1462 /* we are now in exclude mode */
1464 /* no matter the selection, no list => include everything */
1465 if (t
->path_list_size
<= 0) {
1467 return NT_STATUS_OK
;
1470 if (t
->mode
.regex
) {
1471 in
= mask_match_list(fullpath
, t
->path_list
, t
->path_list_size
, true);
1473 bool reverse
= isdir
&& !exclude
;
1474 NTSTATUS status
= tar_path_in_list(t
, fullpath
, reverse
, &in
);
1475 if (!NT_STATUS_IS_OK(status
)) {
1481 return NT_STATUS_OK
;
1485 * tar_to_process - return true if @t is ready to be processed
1487 * @t is ready if it properly parsed command line arguments.
1489 bool tar_to_process(struct tar
*t
)
1492 DBG(0, ("Invalid tar context\n"));
1495 return t
->to_process
;
1499 * skip_useless_char_in_path - skip leading slashes/dots
1501 * Skip leading slashes, backslashes and dot-slashes.
1503 static const char* skip_useless_char_in_path(const char *p
)
1506 if (*p
== '/' || *p
== '\\') {
1509 else if (p
[0] == '.' && (p
[1] == '/' || p
[1] == '\\')) {
1519 * is_subpath - check if the path @sub is a subpath of @full.
1520 * @sub: path to test
1521 * @full: container path
1522 * @_subpath_match: set true if @sub is a subpath of @full, otherwise false
1524 * String comparaison is case-insensitive.
1526 static NTSTATUS
is_subpath(const char *sub
, const char *full
,
1527 bool *_subpath_match
)
1529 NTSTATUS status
= NT_STATUS_OK
;
1532 TALLOC_CTX
*tmp_ctx
= talloc_new(NULL
);
1533 if (tmp_ctx
== NULL
) {
1534 status
= NT_STATUS_NO_MEMORY
;
1538 f
= strlower_talloc(tmp_ctx
, full
);
1540 status
= NT_STATUS_NO_MEMORY
;
1543 string_replace(f
, '\\', '/');
1544 s
= strlower_talloc(tmp_ctx
, sub
);
1546 status
= NT_STATUS_NO_MEMORY
;
1549 string_replace(s
, '\\', '/');
1551 /* find the point where sub and full diverge */
1552 while ((*f
!= '\0') && (*s
!= '\0') && (*f
== *s
)) {
1558 if ((*f
== '\0') && (*s
== '\0')) {
1559 *_subpath_match
= true; /* sub and full match */
1563 if ((*f
== '\0') && (len
> 0) && (*(f
- 1) == '/')) {
1564 /* sub diverges from full at path separator */
1565 *_subpath_match
= true;
1569 if ((*s
== '\0') && (strcmp(f
, "/") == 0)) {
1570 /* full diverges from sub with trailing slash only */
1571 *_subpath_match
= true;
1575 if ((*s
== '/') && (*f
== '\0')) {
1576 /* sub diverges from full with extra path component */
1577 *_subpath_match
= true;
1580 *_subpath_match
= false;
1583 talloc_free(tmp_ctx
);
1590 * make_remote_path - recursively make remote dirs
1591 * @full_path: full hierarchy to create
1593 * Create @full_path and each parent directories as needed.
1595 static int make_remote_path(const char *full_path
)
1597 extern struct cli_state
*cli
;
1601 char *last_backslash
;
1606 TALLOC_CTX
*ctx
= talloc_new(NULL
);
1611 subpath
= talloc_strdup(ctx
, full_path
);
1612 if (subpath
== NULL
) {
1616 path
= talloc_strdup(ctx
, full_path
);
1621 len
= talloc_get_size(path
) - 1;
1623 last_backslash
= strrchr_m(path
, '\\');
1624 if (last_backslash
== NULL
) {
1628 *last_backslash
= 0;
1631 p
= strtok_r(path
, "\\", &state
);
1634 strlcat(subpath
, p
, len
);
1635 status
= cli_chkpath(cli
, subpath
);
1636 if (!NT_STATUS_IS_OK(status
)) {
1637 status
= cli_mkdir(cli
, subpath
);
1638 if (!NT_STATUS_IS_OK(status
)) {
1639 DBG(0, ("Can't mkdir %s: %s\n", subpath
, nt_errstr(status
)));
1643 DBG(3, ("mkdir %s\n", subpath
));
1646 strlcat(subpath
, "\\", len
);
1647 p
= strtok_r(NULL
, "/\\", &state
);
1657 * tar_reset_mem_context - reset talloc context associated with @t
1659 * At the start of the program the context is NULL so a new one is
1660 * allocated. On the following runs (interactive session only), simply
1661 * free the children.
1663 static TALLOC_CTX
*tar_reset_mem_context(struct tar
*t
)
1665 tar_free_mem_context(t
);
1666 t
->talloc_ctx
= talloc_new(NULL
);
1667 return t
->talloc_ctx
;
1671 * tar_free_mem_context - free talloc context associated with @t
1673 static void tar_free_mem_context(struct tar
*t
)
1675 if (t
->talloc_ctx
) {
1676 talloc_free(t
->talloc_ctx
);
1677 t
->talloc_ctx
= NULL
;
1678 t
->path_list_size
= 0;
1679 t
->path_list
= NULL
;
1684 #define XSET(v) [v] = #v
1685 #define XTABLE(v, t) DBG(2, ("DUMP:%-20.20s = %s\n", #v, t[v]))
1686 #define XBOOL(v) DBG(2, ("DUMP:%-20.20s = %d\n", #v, v ? 1 : 0))
1687 #define XSTR(v) DBG(2, ("DUMP:%-20.20s = %s\n", #v, v ? v : "NULL"))
1688 #define XINT(v) DBG(2, ("DUMP:%-20.20s = %d\n", #v, v))
1689 #define XUINT64(v) DBG(2, ("DUMP:%-20.20s = %" PRIu64 "\n", #v, v))
1692 * tar_dump - dump tar structure on stdout
1694 static void tar_dump(struct tar
*t
)
1697 const char* op
[] = {
1698 XSET(TAR_NO_OPERATION
),
1703 const char* sel
[] = {
1704 XSET(TAR_NO_SELECTION
),
1709 XBOOL(t
->to_process
);
1710 XTABLE(t
->mode
.operation
, op
);
1711 XTABLE(t
->mode
.selection
, sel
);
1712 XINT(t
->mode
.blocksize
);
1713 XBOOL(t
->mode
.hidden
);
1714 XBOOL(t
->mode
.system
);
1715 XBOOL(t
->mode
.incremental
);
1716 XBOOL(t
->mode
.reset
);
1718 XBOOL(t
->mode
.verbose
);
1719 XUINT64(t
->total_size
);
1721 XINT(t
->path_list_size
);
1723 for (i
= 0; t
->path_list
&& t
->path_list
[i
]; i
++) {
1724 DBG(2, ("DUMP: t->path_list[%2d] = %s\n", i
, t
->path_list
[i
]));
1727 DBG(2, ("DUMP:t->path_list @ %p (%d elem)\n", t
->path_list
, i
));
1736 * max_token - return upper limit for the number of token in @str
1738 * The result is not exact, the actual number of token might be less
1739 * than what is returned.
1741 static int max_token(const char *str
)
1751 while (s
[0] != '\0') {
1752 if (isspace((int)s
[0])) {
1764 * fix_unix_path - convert @path to a DOS path
1765 * @path: path to convert
1766 * @removeprefix: if true, remove leading ./ or /.
1768 static char *fix_unix_path(char *path
, bool do_remove_prefix
)
1770 char *from
= path
, *to
= path
;
1772 if (path
== NULL
|| path
[0] == '\0') {
1780 if (do_remove_prefix
) {
1782 if (path
[0] == '/' || path
[0] == '\\') {
1787 if (path
[1] != '\0' && path
[0] == '.' && (path
[1] == '/' || path
[1] == '\\')) {
1792 /* replace / with \ */
1793 while (from
[0] != '\0') {
1794 if (from
[0] == '/') {
1809 * path_base_name - return @path basename
1811 * If @path doesn't contain any directory separator return NULL.
1813 static NTSTATUS
path_base_name(TALLOC_CTX
*ctx
, const char *path
, char **_base
)
1819 for (i
= 0; path
[i
]; i
++) {
1820 if (path
[i
] == '\\' || path
[i
] == '/') {
1826 base
= talloc_strdup(ctx
, path
);
1828 return NT_STATUS_NO_MEMORY
;
1835 return NT_STATUS_OK
;
1840 #define NOT_IMPLEMENTED DEBUG(0, ("tar mode not compiled. build used --without-libarchive\n"))
1848 int cmd_tarmode(void)
1860 int tar_process(struct tar
* tar
)
1866 int tar_parse_args(struct tar
*tar
, const char *flag
, const char **val
, int valsize
)
1872 bool tar_to_process(struct tar
*tar
)
1877 struct tar
*tar_get_ctx()