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