1 /*-
2 * Copyright (c) 2003-2007 Tim Kientzle
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #include "bsdtar_platform.h"
27 __FBSDID("$FreeBSD: src/usr.bin/tar/read.c,v 1.40 2008/08/21 06:41:14 kientzle Exp $");
28
29 #ifdef HAVE_SYS_TYPES_H
30 #include <sys/types.h>
31 #endif
32 #ifdef HAVE_SYS_PARAM_H
33 #include <sys/param.h>
34 #endif
35 #ifdef HAVE_SYS_STAT_H
36 #include <sys/stat.h>
37 #endif
38
39 #ifdef HAVE_ERRNO_H
40 #include <errno.h>
41 #endif
42
43 #ifdef HAVE_FCNTL_H
44 #include <fcntl.h>
45 #endif
46
47 #ifdef HAVE_GRP_H
48 #include <grp.h>
49 #endif
50
51 #ifdef HAVE_IO_H
52 #include <io.h>
53 #endif
54
55 #ifdef HAVE_LIMITS_H
56 #include <limits.h>
57 #endif
58 #ifdef HAVE_PWD_H
59 #include <pwd.h>
60 #endif
61 #ifdef HAVE_STDINT_H
62 #include <stdint.h>
63 #endif
64 #include <stdio.h>
65 #ifdef HAVE_STDLIB_H
66 #include <stdlib.h>
67 #endif
68 #ifdef HAVE_STRING_H
69 #include <string.h>
70 #endif
71 #ifdef HAVE_TIME_H
72 #include <time.h>
73 #endif
74 #ifdef HAVE_UNISTD_H
75 #include <unistd.h>
76 #endif
77
78 #include "bsdtar.h"
79 #include "err.h"
80
81 struct progress_data {
82 struct bsdtar *bsdtar;
83 struct archive *archive;
84 struct archive_entry *entry;
85 };
86
87 static void read_archive(struct bsdtar *bsdtar, char mode, struct archive *);
88 static int unmatched_inclusions_warn(struct archive *matching, const char *);
89
90
91 void
tar_mode_t(struct bsdtar * bsdtar)92 tar_mode_t(struct bsdtar *bsdtar)
93 {
94 read_archive(bsdtar, 't', NULL);
95 if (unmatched_inclusions_warn(bsdtar->matching,
96 "Not found in archive") != 0)
97 bsdtar->return_value = 1;
98 }
99
100 void
tar_mode_x(struct bsdtar * bsdtar)101 tar_mode_x(struct bsdtar *bsdtar)
102 {
103 struct archive *writer;
104
105 writer = archive_write_disk_new();
106 if (writer == NULL)
107 lafe_errc(1, ENOMEM, "Cannot allocate disk writer object");
108 if ((bsdtar->flags & OPTFLAG_NUMERIC_OWNER) == 0)
109 archive_write_disk_set_standard_lookup(writer);
110 archive_write_disk_set_options(writer, bsdtar->extract_flags);
111
112 read_archive(bsdtar, 'x', writer);
113
114 if (unmatched_inclusions_warn(bsdtar->matching,
115 "Not found in archive") != 0)
116 bsdtar->return_value = 1;
117 archive_write_free(writer);
118 }
119
120 static void
progress_func(void * cookie)121 progress_func(void *cookie)
122 {
123 struct progress_data *progress_data = (struct progress_data *)cookie;
124 struct bsdtar *bsdtar = progress_data->bsdtar;
125 struct archive *a = progress_data->archive;
126 struct archive_entry *entry = progress_data->entry;
127 uint64_t comp, uncomp;
128 int compression;
129
130 if (!need_report())
131 return;
132
133 if (bsdtar->verbose)
134 fprintf(stderr, "\n");
135 if (a != NULL) {
136 comp = archive_filter_bytes(a, -1);
137 uncomp = archive_filter_bytes(a, 0);
138 if (comp > uncomp)
139 compression = 0;
140 else
141 compression = (int)((uncomp - comp) * 100 / uncomp);
142 fprintf(stderr,
143 "In: %s bytes, compression %d%%;",
144 tar_i64toa(comp), compression);
145 fprintf(stderr, " Out: %d files, %s bytes\n",
146 archive_file_count(a), tar_i64toa(uncomp));
147 }
148 if (entry != NULL) {
149 safe_fprintf(stderr, "Current: %s",
150 archive_entry_pathname(entry));
151 fprintf(stderr, " (%s bytes)\n",
152 tar_i64toa(archive_entry_size(entry)));
153 }
154 }
155
156 /*
157 * Handle 'x' and 't' modes.
158 */
159 static void
read_archive(struct bsdtar * bsdtar,char mode,struct archive * writer)160 read_archive(struct bsdtar *bsdtar, char mode, struct archive *writer)
161 {
162 struct progress_data progress_data;
163 FILE *out;
164 struct archive *a;
165 struct archive_entry *entry;
166 const char *reader_options;
167 int r;
168
169 while (*bsdtar->argv) {
170 if (archive_match_include_pattern(bsdtar->matching,
171 *bsdtar->argv) != ARCHIVE_OK)
172 lafe_errc(1, 0, "Error inclusion pattern: %s",
173 archive_error_string(bsdtar->matching));
174 bsdtar->argv++;
175 }
176
177 if (bsdtar->names_from_file != NULL)
178 if (archive_match_include_pattern_from_file(
179 bsdtar->matching, bsdtar->names_from_file,
180 (bsdtar->flags & OPTFLAG_NULL)) != ARCHIVE_OK)
181 lafe_errc(1, 0, "Error inclusion pattern: %s",
182 archive_error_string(bsdtar->matching));
183
184 a = archive_read_new();
185 if (cset_read_support_filter_program(bsdtar->cset, a) == 0)
186 archive_read_support_filter_all(a);
187 archive_read_support_format_all(a);
188
189 reader_options = getenv(ENV_READER_OPTIONS);
190 if (reader_options != NULL) {
191 size_t module_len = sizeof(IGNORE_WRONG_MODULE_NAME) - 1;
192 size_t opt_len = strlen(reader_options) + 1;
193 char *p;
194 /* Set default read options. */
195 if ((p = malloc(module_len + opt_len)) == NULL)
196 lafe_errc(1, errno, "Out of memory");
197 /* Prepend magic code to ignore options for
198 * a format or modules which are not added to
199 * the archive read object. */
200 memcpy(p, IGNORE_WRONG_MODULE_NAME, module_len);
201 memcpy(p + module_len, reader_options, opt_len);
202 r = archive_read_set_options(a, p);
203 free(p);
204 if (r == ARCHIVE_FATAL)
205 lafe_errc(1, 0, "%s", archive_error_string(a));
206 else
207 archive_clear_error(a);
208 }
209 if (ARCHIVE_OK != archive_read_set_options(a, bsdtar->option_options))
210 lafe_errc(1, 0, "%s", archive_error_string(a));
211 if (bsdtar->flags & OPTFLAG_IGNORE_ZEROS)
212 if (archive_read_set_options(a,
213 "read_concatenated_archives") != ARCHIVE_OK)
214 lafe_errc(1, 0, "%s", archive_error_string(a));
215 if (bsdtar->passphrase != NULL)
216 r = archive_read_add_passphrase(a, bsdtar->passphrase);
217 else
218 r = archive_read_set_passphrase_callback(a, bsdtar,
219 &passphrase_callback);
220 if (r != ARCHIVE_OK)
221 lafe_errc(1, 0, "%s", archive_error_string(a));
222 if (archive_read_open_filename(a, bsdtar->filename,
223 bsdtar->bytes_per_block))
224 lafe_errc(1, 0, "Error opening archive: %s",
225 archive_error_string(a));
226
227 do_chdir(bsdtar);
228
229 if (mode == 'x') {
230 /* Set an extract callback so that we can handle SIGINFO. */
231 progress_data.bsdtar = bsdtar;
232 progress_data.archive = a;
233 archive_read_extract_set_progress_callback(a, progress_func,
234 &progress_data);
235 }
236
237 if (mode == 'x' && (bsdtar->flags & OPTFLAG_CHROOT)) {
238 #if HAVE_CHROOT
239 if (chroot(".") != 0)
240 lafe_errc(1, errno, "Can't chroot to \".\"");
241 #else
242 lafe_errc(1, 0,
243 "chroot isn't supported on this platform");
244 #endif
245 }
246
247 #if defined(_WIN32) && !defined(__CYGWIN__)
248 if (mode == 'x' && (bsdtar->flags & OPTFLAG_STDOUT)) {
249 _setmode(1, _O_BINARY);
250 }
251 #endif
252
253 for (;;) {
254 /* Support --fast-read option */
255 const char *p;
256 if ((bsdtar->flags & OPTFLAG_FAST_READ) &&
257 archive_match_path_unmatched_inclusions(bsdtar->matching) == 0)
258 break;
259
260 r = archive_read_next_header(a, &entry);
261 progress_data.entry = entry;
262 if (r == ARCHIVE_EOF)
263 break;
264 if (r < ARCHIVE_OK)
265 lafe_warnc(0, "%s", archive_error_string(a));
266 if (r <= ARCHIVE_WARN)
267 bsdtar->return_value = 1;
268 if (r == ARCHIVE_RETRY) {
269 /* Retryable error: try again */
270 lafe_warnc(0, "Retrying...");
271 continue;
272 }
273 if (r == ARCHIVE_FATAL)
274 break;
275 p = archive_entry_pathname(entry);
276 if (p == NULL || p[0] == '\0') {
277 lafe_warnc(0, "Archive entry has empty or unreadable filename ... skipping.");
278 bsdtar->return_value = 1;
279 continue;
280 }
281
282 if (bsdtar->uid >= 0) {
283 archive_entry_set_uid(entry, bsdtar->uid);
284 archive_entry_set_uname(entry, NULL);
285 }
286 if (bsdtar->gid >= 0) {
287 archive_entry_set_gid(entry, bsdtar->gid);
288 archive_entry_set_gname(entry, NULL);
289 }
290 if (bsdtar->uname)
291 archive_entry_set_uname(entry, bsdtar->uname);
292 if (bsdtar->gname)
293 archive_entry_set_gname(entry, bsdtar->gname);
294
295 /*
296 * Note that pattern exclusions are checked before
297 * pathname rewrites are handled. This gives more
298 * control over exclusions, since rewrites always lose
299 * information. (For example, consider a rewrite
300 * s/foo[0-9]/foo/. If we check exclusions after the
301 * rewrite, there would be no way to exclude foo1/bar
302 * while allowing foo2/bar.)
303 */
304 if (archive_match_excluded(bsdtar->matching, entry))
305 continue; /* Excluded by a pattern test. */
306
307 if (mode == 't') {
308 /* Perversely, gtar uses -O to mean "send to stderr"
309 * when used with -t. */
310 out = (bsdtar->flags & OPTFLAG_STDOUT) ?
311 stderr : stdout;
312
313 /*
314 * TODO: Provide some reasonable way to
315 * preview rewrites. gtar always displays
316 * the unedited path in -t output, which means
317 * you cannot easily preview rewrites.
318 */
319 if (bsdtar->verbose < 2)
320 safe_fprintf(out, "%s",
321 archive_entry_pathname(entry));
322 else
323 list_item_verbose(bsdtar, out, entry);
324 fflush(out);
325 r = archive_read_data_skip(a);
326 if (r == ARCHIVE_WARN) {
327 fprintf(out, "\n");
328 lafe_warnc(0, "%s",
329 archive_error_string(a));
330 }
331 if (r == ARCHIVE_RETRY) {
332 fprintf(out, "\n");
333 lafe_warnc(0, "%s",
334 archive_error_string(a));
335 }
336 if (r == ARCHIVE_FATAL) {
337 fprintf(out, "\n");
338 lafe_warnc(0, "%s",
339 archive_error_string(a));
340 bsdtar->return_value = 1;
341 break;
342 }
343 fprintf(out, "\n");
344 } else {
345 /* Note: some rewrite failures prevent extraction. */
346 if (edit_pathname(bsdtar, entry))
347 continue; /* Excluded by a rewrite failure. */
348
349 if ((bsdtar->flags & OPTFLAG_INTERACTIVE) &&
350 !yes("extract '%s'", archive_entry_pathname(entry)))
351 continue;
352
353 if (bsdtar->verbose > 1) {
354 /* GNU tar uses -tv format with -xvv */
355 safe_fprintf(stderr, "x ");
356 list_item_verbose(bsdtar, stderr, entry);
357 fflush(stderr);
358 } else if (bsdtar->verbose > 0) {
359 /* Format follows SUSv2, including the
360 * deferred '\n'. */
361 safe_fprintf(stderr, "x %s",
362 archive_entry_pathname(entry));
363 fflush(stderr);
364 }
365
366 /* TODO siginfo_printinfo(bsdtar, 0); */
367
368 if (bsdtar->flags & OPTFLAG_STDOUT)
369 r = archive_read_data_into_fd(a, 1);
370 else
371 r = archive_read_extract2(a, entry, writer);
372 if (r != ARCHIVE_OK) {
373 if (!bsdtar->verbose)
374 safe_fprintf(stderr, "%s", archive_entry_pathname(entry));
375 fprintf(stderr, ": %s: ", archive_error_string(a));
376 fprintf(stderr, "%s", strerror(errno));
377 if (!bsdtar->verbose)
378 fprintf(stderr, "\n");
379 bsdtar->return_value = 1;
380 }
381 if (bsdtar->verbose)
382 fprintf(stderr, "\n");
383 if (r == ARCHIVE_FATAL)
384 break;
385 }
386 }
387
388
389 r = archive_read_close(a);
390 if (r != ARCHIVE_OK)
391 lafe_warnc(0, "%s", archive_error_string(a));
392 if (r <= ARCHIVE_WARN)
393 bsdtar->return_value = 1;
394
395 if (bsdtar->verbose > 2)
396 fprintf(stdout, "Archive Format: %s, Compression: %s\n",
397 archive_format_name(a), archive_filter_name(a, 0));
398
399 archive_read_free(a);
400 }
401
402
403 static int
unmatched_inclusions_warn(struct archive * matching,const char * msg)404 unmatched_inclusions_warn(struct archive *matching, const char *msg)
405 {
406 const char *p;
407 int r;
408
409 if (matching == NULL)
410 return (0);
411
412 while ((r = archive_match_path_unmatched_inclusions_next(
413 matching, &p)) == ARCHIVE_OK)
414 lafe_warnc(0, "%s: %s", p, msg);
415 if (r == ARCHIVE_FATAL)
416 lafe_errc(1, errno, "Out of memory");
417
418 return (archive_match_path_unmatched_inclusions(matching));
419 }
420