PageRenderTime 36ms CodeModel.GetById 11ms app.highlight 20ms RepoModel.GetById 1ms app.codeStats 0ms

/usr.bin/tar/read.c

https://bitbucket.org/freebsd/freebsd-head/
C | 450 lines | 328 code | 42 blank | 80 comment | 102 complexity | 797fbda91c828031c16e2f50b35abe0c MD5 | raw file
  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$");
 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#ifdef HAVE_GRP_H
 43#include <grp.h>
 44#endif
 45#ifdef HAVE_LIMITS_H
 46#include <limits.h>
 47#endif
 48#ifdef HAVE_PWD_H
 49#include <pwd.h>
 50#endif
 51#ifdef HAVE_STDINT_H
 52#include <stdint.h>
 53#endif
 54#include <stdio.h>
 55#ifdef HAVE_STDLIB_H
 56#include <stdlib.h>
 57#endif
 58#ifdef HAVE_STRING_H
 59#include <string.h>
 60#endif
 61#ifdef HAVE_TIME_H
 62#include <time.h>
 63#endif
 64#ifdef HAVE_UNISTD_H
 65#include <unistd.h>
 66#endif
 67
 68#include "bsdtar.h"
 69#include "err.h"
 70
 71struct progress_data {
 72	struct bsdtar *bsdtar;
 73	struct archive *archive;
 74	struct archive_entry *entry;
 75};
 76
 77static void	list_item_verbose(struct bsdtar *, FILE *,
 78		    struct archive_entry *);
 79static void	read_archive(struct bsdtar *bsdtar, char mode);
 80
 81void
 82tar_mode_t(struct bsdtar *bsdtar)
 83{
 84	read_archive(bsdtar, 't');
 85	if (lafe_unmatched_inclusions_warn(bsdtar->matching, "Not found in archive") != 0)
 86		bsdtar->return_value = 1;
 87}
 88
 89void
 90tar_mode_x(struct bsdtar *bsdtar)
 91{
 92	read_archive(bsdtar, 'x');
 93
 94	if (lafe_unmatched_inclusions_warn(bsdtar->matching, "Not found in archive") != 0)
 95		bsdtar->return_value = 1;
 96}
 97
 98static void
 99progress_func(void *cookie)
100{
101	struct progress_data *progress_data = cookie;
102	struct bsdtar *bsdtar = progress_data->bsdtar;
103	struct archive *a = progress_data->archive;
104	struct archive_entry *entry = progress_data->entry;
105	uint64_t comp, uncomp;
106	int compression;
107
108	if (!need_report())
109		return;
110
111	if (bsdtar->verbose)
112		fprintf(stderr, "\n");
113	if (a != NULL) {
114		comp = archive_position_compressed(a);
115		uncomp = archive_position_uncompressed(a);
116		if (comp > uncomp)
117			compression = 0;
118		else
119			compression = (int)((uncomp - comp) * 100 / uncomp);
120		fprintf(stderr,
121		    "In: %s bytes, compression %d%%;",
122		    tar_i64toa(comp), compression);
123		fprintf(stderr, "  Out: %d files, %s bytes\n",
124		    archive_file_count(a), tar_i64toa(uncomp));
125	}
126	if (entry != NULL) {
127		safe_fprintf(stderr, "Current: %s",
128		    archive_entry_pathname(entry));
129		fprintf(stderr, " (%s bytes)\n",
130		    tar_i64toa(archive_entry_size(entry)));
131	}
132}
133
134/*
135 * Handle 'x' and 't' modes.
136 */
137static void
138read_archive(struct bsdtar *bsdtar, char mode)
139{
140	struct progress_data	progress_data;
141	FILE			 *out;
142	struct archive		 *a;
143	struct archive_entry	 *entry;
144	const struct stat	 *st;
145	int			  r;
146
147	while (*bsdtar->argv) {
148		lafe_include(&bsdtar->matching, *bsdtar->argv);
149		bsdtar->argv++;
150	}
151
152	if (bsdtar->names_from_file != NULL)
153		lafe_include_from_file(&bsdtar->matching,
154		    bsdtar->names_from_file, bsdtar->option_null);
155
156	a = archive_read_new();
157	if (bsdtar->compress_program != NULL)
158		archive_read_support_compression_program(a, bsdtar->compress_program);
159	else
160		archive_read_support_compression_all(a);
161	archive_read_support_format_all(a);
162	if (ARCHIVE_OK != archive_read_set_options(a, bsdtar->option_options))
163		lafe_errc(1, 0, "%s", archive_error_string(a));
164	if (archive_read_open_file(a, bsdtar->filename,
165	    bsdtar->bytes_per_block != 0 ? bsdtar->bytes_per_block :
166	    DEFAULT_BYTES_PER_BLOCK))
167		lafe_errc(1, 0, "Error opening archive: %s",
168		    archive_error_string(a));
169
170	do_chdir(bsdtar);
171
172	if (mode == 'x') {
173		/* Set an extract callback so that we can handle SIGINFO. */
174		progress_data.bsdtar = bsdtar;
175		progress_data.archive = a;
176		archive_read_extract_set_progress_callback(a, progress_func,
177		    &progress_data);
178	}
179
180	if (mode == 'x' && bsdtar->option_chroot) {
181#if HAVE_CHROOT
182		if (chroot(".") != 0)
183			lafe_errc(1, errno, "Can't chroot to \".\"");
184#else
185		lafe_errc(1, 0,
186		    "chroot isn't supported on this platform");
187#endif
188	}
189
190	for (;;) {
191		/* Support --fast-read option */
192		if (bsdtar->option_fast_read &&
193		    lafe_unmatched_inclusions(bsdtar->matching) == 0)
194			break;
195
196		r = archive_read_next_header(a, &entry);
197		progress_data.entry = entry;
198		if (r == ARCHIVE_EOF)
199			break;
200		if (r < ARCHIVE_OK)
201			lafe_warnc(0, "%s", archive_error_string(a));
202		if (r <= ARCHIVE_WARN)
203			bsdtar->return_value = 1;
204		if (r == ARCHIVE_RETRY) {
205			/* Retryable error: try again */
206			lafe_warnc(0, "Retrying...");
207			continue;
208		}
209		if (r == ARCHIVE_FATAL)
210			break;
211
212		if (bsdtar->uid >= 0) {
213			archive_entry_set_uid(entry, bsdtar->uid);
214			archive_entry_set_uname(entry, NULL);
215		}
216		if (bsdtar->gid >= 0) {
217			archive_entry_set_gid(entry, bsdtar->gid);
218			archive_entry_set_gname(entry, NULL);
219		}
220		if (bsdtar->uname)
221			archive_entry_set_uname(entry, bsdtar->uname);
222		if (bsdtar->gname)
223			archive_entry_set_gname(entry, bsdtar->gname);
224
225		/*
226		 * Exclude entries that are too old.
227		 */
228		st = archive_entry_stat(entry);
229		if (bsdtar->newer_ctime_sec > 0) {
230			if (st->st_ctime < bsdtar->newer_ctime_sec)
231				continue; /* Too old, skip it. */
232			if (st->st_ctime == bsdtar->newer_ctime_sec
233			    && ARCHIVE_STAT_CTIME_NANOS(st)
234			    <= bsdtar->newer_ctime_nsec)
235				continue; /* Too old, skip it. */
236		}
237		if (bsdtar->newer_mtime_sec > 0) {
238			if (st->st_mtime < bsdtar->newer_mtime_sec)
239				continue; /* Too old, skip it. */
240			if (st->st_mtime == bsdtar->newer_mtime_sec
241			    && ARCHIVE_STAT_MTIME_NANOS(st)
242			    <= bsdtar->newer_mtime_nsec)
243				continue; /* Too old, skip it. */
244		}
245
246		/*
247		 * Note that pattern exclusions are checked before
248		 * pathname rewrites are handled.  This gives more
249		 * control over exclusions, since rewrites always lose
250		 * information.  (For example, consider a rewrite
251		 * s/foo[0-9]/foo/.  If we check exclusions after the
252		 * rewrite, there would be no way to exclude foo1/bar
253		 * while allowing foo2/bar.)
254		 */
255		if (lafe_excluded(bsdtar->matching, archive_entry_pathname(entry)))
256			continue; /* Excluded by a pattern test. */
257
258		if (mode == 't') {
259			/* Perversely, gtar uses -O to mean "send to stderr"
260			 * when used with -t. */
261			out = bsdtar->option_stdout ? stderr : stdout;
262
263			/*
264			 * TODO: Provide some reasonable way to
265			 * preview rewrites.  gtar always displays
266			 * the unedited path in -t output, which means
267			 * you cannot easily preview rewrites.
268			 */
269			if (bsdtar->verbose < 2)
270				safe_fprintf(out, "%s",
271				    archive_entry_pathname(entry));
272			else
273				list_item_verbose(bsdtar, out, entry);
274			fflush(out);
275			r = archive_read_data_skip(a);
276			if (r == ARCHIVE_WARN) {
277				fprintf(out, "\n");
278				lafe_warnc(0, "%s",
279				    archive_error_string(a));
280			}
281			if (r == ARCHIVE_RETRY) {
282				fprintf(out, "\n");
283				lafe_warnc(0, "%s",
284				    archive_error_string(a));
285			}
286			if (r == ARCHIVE_FATAL) {
287				fprintf(out, "\n");
288				lafe_warnc(0, "%s",
289				    archive_error_string(a));
290				bsdtar->return_value = 1;
291				break;
292			}
293			fprintf(out, "\n");
294		} else {
295			/* Note: some rewrite failures prevent extraction. */
296			if (edit_pathname(bsdtar, entry))
297				continue; /* Excluded by a rewrite failure. */
298
299			if (bsdtar->option_interactive &&
300			    !yes("extract '%s'", archive_entry_pathname(entry)))
301				continue;
302
303			/*
304			 * Format here is from SUSv2, including the
305			 * deferred '\n'.
306			 */
307			if (bsdtar->verbose) {
308				safe_fprintf(stderr, "x %s",
309				    archive_entry_pathname(entry));
310				fflush(stderr);
311			}
312
313			// TODO siginfo_printinfo(bsdtar, 0);
314
315			if (bsdtar->option_stdout)
316				r = archive_read_data_into_fd(a, 1);
317			else
318				r = archive_read_extract(a, entry,
319				    bsdtar->extract_flags);
320			if (r != ARCHIVE_OK) {
321				if (!bsdtar->verbose)
322					safe_fprintf(stderr, "%s",
323					    archive_entry_pathname(entry));
324				safe_fprintf(stderr, ": %s",
325				    archive_error_string(a));
326				if (!bsdtar->verbose)
327					fprintf(stderr, "\n");
328				bsdtar->return_value = 1;
329			}
330			if (bsdtar->verbose)
331				fprintf(stderr, "\n");
332			if (r == ARCHIVE_FATAL)
333				break;
334		}
335	}
336
337
338	r = archive_read_close(a);
339	if (r != ARCHIVE_OK)
340		lafe_warnc(0, "%s", archive_error_string(a));
341	if (r <= ARCHIVE_WARN)
342		bsdtar->return_value = 1;
343
344	if (bsdtar->verbose > 2)
345		fprintf(stdout, "Archive Format: %s,  Compression: %s\n",
346		    archive_format_name(a), archive_compression_name(a));
347
348	archive_read_finish(a);
349}
350
351
352/*
353 * Display information about the current file.
354 *
355 * The format here roughly duplicates the output of 'ls -l'.
356 * This is based on SUSv2, where 'tar tv' is documented as
357 * listing additional information in an "unspecified format,"
358 * and 'pax -l' is documented as using the same format as 'ls -l'.
359 */
360static void
361list_item_verbose(struct bsdtar *bsdtar, FILE *out, struct archive_entry *entry)
362{
363	char			 tmp[100];
364	size_t			 w;
365	const char		*p;
366	const char		*fmt;
367	time_t			 tim;
368	static time_t		 now;
369
370	/*
371	 * We avoid collecting the entire list in memory at once by
372	 * listing things as we see them.  However, that also means we can't
373	 * just pre-compute the field widths.  Instead, we start with guesses
374	 * and just widen them as necessary.  These numbers are completely
375	 * arbitrary.
376	 */
377	if (!bsdtar->u_width) {
378		bsdtar->u_width = 6;
379		bsdtar->gs_width = 13;
380	}
381	if (!now)
382		time(&now);
383	fprintf(out, "%s %d ",
384	    archive_entry_strmode(entry),
385	    archive_entry_nlink(entry));
386
387	/* Use uname if it's present, else uid. */
388	p = archive_entry_uname(entry);
389	if ((p == NULL) || (*p == '\0')) {
390		sprintf(tmp, "%lu ",
391		    (unsigned long)archive_entry_uid(entry));
392		p = tmp;
393	}
394	w = strlen(p);
395	if (w > bsdtar->u_width)
396		bsdtar->u_width = w;
397	fprintf(out, "%-*s ", (int)bsdtar->u_width, p);
398
399	/* Use gname if it's present, else gid. */
400	p = archive_entry_gname(entry);
401	if (p != NULL && p[0] != '\0') {
402		fprintf(out, "%s", p);
403		w = strlen(p);
404	} else {
405		sprintf(tmp, "%lu",
406		    (unsigned long)archive_entry_gid(entry));
407		w = strlen(tmp);
408		fprintf(out, "%s", tmp);
409	}
410
411	/*
412	 * Print device number or file size, right-aligned so as to make
413	 * total width of group and devnum/filesize fields be gs_width.
414	 * If gs_width is too small, grow it.
415	 */
416	if (archive_entry_filetype(entry) == AE_IFCHR
417	    || archive_entry_filetype(entry) == AE_IFBLK) {
418		sprintf(tmp, "%lu,%lu",
419		    (unsigned long)archive_entry_rdevmajor(entry),
420		    (unsigned long)archive_entry_rdevminor(entry));
421	} else {
422		strcpy(tmp, tar_i64toa(archive_entry_size(entry)));
423	}
424	if (w + strlen(tmp) >= bsdtar->gs_width)
425		bsdtar->gs_width = w+strlen(tmp)+1;
426	fprintf(out, "%*s", (int)(bsdtar->gs_width - w), tmp);
427
428	/* Format the time using 'ls -l' conventions. */
429	tim = archive_entry_mtime(entry);
430#define HALF_YEAR (time_t)365 * 86400 / 2
431#if defined(_WIN32) && !defined(__CYGWIN__)
432#define DAY_FMT  "%d"  /* Windows' strftime function does not support %e format. */
433#else
434#define DAY_FMT  "%e"  /* Day number without leading zeros */
435#endif
436	if (tim < now - HALF_YEAR || tim > now + HALF_YEAR)
437		fmt = bsdtar->day_first ? DAY_FMT " %b  %Y" : "%b " DAY_FMT "  %Y";
438	else
439		fmt = bsdtar->day_first ? DAY_FMT " %b %H:%M" : "%b " DAY_FMT " %H:%M";
440	strftime(tmp, sizeof(tmp), fmt, localtime(&tim));
441	fprintf(out, " %s ", tmp);
442	safe_fprintf(out, "%s", archive_entry_pathname(entry));
443
444	/* Extra information for links. */
445	if (archive_entry_hardlink(entry)) /* Hard link */
446		safe_fprintf(out, " link to %s",
447		    archive_entry_hardlink(entry));
448	else if (archive_entry_symlink(entry)) /* Symbolic link */
449		safe_fprintf(out, " -> %s", archive_entry_symlink(entry));
450}