contrib/libarchive/tar/read.c

   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
  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);
  80
  81 void
  82 tar_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
  89 void
  90 tar_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
  98 static void
  99 progress_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  */
 137 static void
 138 read_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  */
 360 static void
 361 list_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 }