contrib/libarchive/tar/write.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * Copyright (c) 2012 Michihiro NAKAJIMA
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "bsdtar_platform.h"
  28 __FBSDID("$FreeBSD: src/usr.bin/tar/write.c,v 1.79 2008/11/27 05:49:52 kientzle Exp $");
  29
  30 #ifdef HAVE_SYS_TYPES_H
  31 #include <sys/types.h>
  32 #endif
  33 #ifdef HAVE_SYS_STAT_H
  34 #include <sys/stat.h>
  35 #endif
  36 #ifdef HAVE_ATTR_XATTR_H
  37 #include <attr/xattr.h>
  38 #endif
  39 #ifdef HAVE_ERRNO_H
  40 #include <errno.h>
  41 #endif
  42 #ifdef HAVE_FCNTL_H
  43 #include <fcntl.h>
  44 #endif
  45 #ifdef HAVE_GRP_H
  46 #include <grp.h>
  47 #endif
  48 #ifdef HAVE_IO_H
  49 #include <io.h>
  50 #endif
  51 #ifdef HAVE_LIBGEN_H
  52 #include <libgen.h>
  53 #endif
  54 #ifdef HAVE_LIMITS_H
  55 #include <limits.h>
  56 #endif
  57 #ifdef HAVE_PATHS_H
  58 #include <paths.h>
  59 #endif
  60 #ifdef HAVE_PWD_H
  61 #include <pwd.h>
  62 #endif
  63 #ifdef HAVE_STDINT_H
  64 #include <stdint.h>
  65 #endif
  66 #include <stdio.h>
  67 #ifdef HAVE_STDLIB_H
  68 #include <stdlib.h>
  69 #endif
  70 #ifdef HAVE_STRING_H
  71 #include <string.h>
  72 #endif
  73 #ifdef HAVE_UNISTD_H
  74 #include <unistd.h>
  75 #endif
  76
  77 #include "bsdtar.h"
  78 #include "err.h"
  79 #include "line_reader.h"
  80
  81 #ifndef O_BINARY
  82 #define O_BINARY 0
  83 #endif
  84
  85 struct archive_dir_entry {
  86         struct archive_dir_entry        *next;
  87         time_t                   mtime_sec;
  88         int                      mtime_nsec;
  89         char                    *name;
  90 };
  91
  92 struct archive_dir {
  93         struct archive_dir_entry *head, *tail;
  94 };
  95
  96 static int               append_archive(struct bsdtar *, struct archive *,
  97                              struct archive *ina);
  98 static int               append_archive_filename(struct bsdtar *,
  99                              struct archive *, const char *fname);
 100 static void              archive_names_from_file(struct bsdtar *bsdtar,
 101                              struct archive *a);
 102 static int               copy_file_data_block(struct bsdtar *,
 103                              struct archive *a, struct archive *,
 104                              struct archive_entry *);
 105 static void              excluded_callback(struct archive *, void *,
 106                              struct archive_entry *);
 107 static void              report_write(struct bsdtar *, struct archive *,
 108                              struct archive_entry *, int64_t progress);
 109 static void              test_for_append(struct bsdtar *);
 110 static int               metadata_filter(struct archive *, void *,
 111                              struct archive_entry *);
 112 static void              write_archive(struct archive *, struct bsdtar *);
 113 static void              write_entry(struct bsdtar *, struct archive *,
 114                              struct archive_entry *);
 115 static void              write_file(struct bsdtar *, struct archive *,
 116                              struct archive_entry *);
 117 static void              write_hierarchy(struct bsdtar *, struct archive *,
 118                              const char *);
 119
 120 #if defined(_WIN32) && !defined(__CYGWIN__)
 121 /* Not a full lseek() emulation, but enough for our needs here. */
 122 static int
 123 seek_file(int fd, int64_t offset, int whence)
 124 {
 125         LARGE_INTEGER distance;
 126         (void)whence; /* UNUSED */
 127         distance.QuadPart = offset;
 128         return (SetFilePointerEx((HANDLE)_get_osfhandle(fd),
 129                 distance, NULL, FILE_BEGIN) ? 1 : -1);
 130 }
 131 #define open _open
 132 #define close _close
 133 #define read _read
 134 #ifdef lseek
 135 #undef lseek
 136 #endif
 137 #define lseek seek_file
 138 #endif
 139
 140 static void
 141 set_writer_options(struct bsdtar *bsdtar, struct archive *a)
 142 {
 143         const char *writer_options;
 144         int r;
 145
 146         writer_options = getenv(ENV_WRITER_OPTIONS);
 147         if (writer_options != NULL) {
 148                 char *p;
 149                 /* Set default write options. */
 150                 p = malloc(sizeof(IGNORE_WRONG_MODULE_NAME)
 151                     + strlen(writer_options) + 1);
 152                 if (p == NULL)
 153                         lafe_errc(1, errno, "Out of memory");
 154                 /* Prepend magic code to ignore options for
 155                  * a format or filters which are not added to
 156                  * the archive write object. */
 157                 strncpy(p, IGNORE_WRONG_MODULE_NAME,
 158                     sizeof(IGNORE_WRONG_MODULE_NAME) -1);
 159                 strcpy(p + sizeof(IGNORE_WRONG_MODULE_NAME) -1, writer_options);
 160                 r = archive_write_set_options(a, p);
 161                 free(p);
 162                 if (r < ARCHIVE_WARN)
 163                         lafe_errc(1, 0, "%s", archive_error_string(a));
 164                 else
 165                         archive_clear_error(a);
 166         }
 167         if (ARCHIVE_OK != archive_write_set_options(a, bsdtar->option_options))
 168                 lafe_errc(1, 0, "%s", archive_error_string(a));
 169 }
 170
 171 static void
 172 set_reader_options(struct bsdtar *bsdtar, struct archive *a)
 173 {
 174         const char *reader_options;
 175         int r;
 176
 177         (void)bsdtar; /* UNUSED */
 178
 179         reader_options = getenv(ENV_READER_OPTIONS);
 180         if (reader_options != NULL) {
 181                 char *p;
 182                 /* Set default write options. */
 183                 p = malloc(sizeof(IGNORE_WRONG_MODULE_NAME)
 184                     + strlen(reader_options) + 1);
 185                 if (p == NULL)
 186                         lafe_errc(1, errno, "Out of memory");
 187                 /* Prepend magic code to ignore options for
 188                  * a format or filters which are not added to
 189                  * the archive write object. */
 190                 strncpy(p, IGNORE_WRONG_MODULE_NAME,
 191                     sizeof(IGNORE_WRONG_MODULE_NAME) -1);
 192                 strcpy(p + sizeof(IGNORE_WRONG_MODULE_NAME) -1, reader_options);
 193                 r = archive_read_set_options(a, p);
 194                 free(p);
 195                 if (r < ARCHIVE_WARN)
 196                         lafe_errc(1, 0, "%s", archive_error_string(a));
 197                 else
 198                         archive_clear_error(a);
 199         }
 200 }
 201
 202 void
 203 tar_mode_c(struct bsdtar *bsdtar)
 204 {
 205         struct archive *a;
 206         const void *filter_name;
 207         int r;
 208
 209         if (*bsdtar->argv == NULL && bsdtar->names_from_file == NULL)
 210                 lafe_errc(1, 0, "no files or directories specified");
 211
 212         a = archive_write_new();
 213
 214         /* Support any format that the library supports. */
 215         if (cset_get_format(bsdtar->cset) == NULL) {
 216                 r = archive_write_set_format_pax_restricted(a);
 217                 cset_set_format(bsdtar->cset, "pax restricted");
 218         } else {
 219                 r = archive_write_set_format_by_name(a,
 220                         cset_get_format(bsdtar->cset));
 221         }
 222         if (r != ARCHIVE_OK) {
 223                 fprintf(stderr, "Can't use format %s: %s\n",
 224                     cset_get_format(bsdtar->cset),
 225                     archive_error_string(a));
 226                 usage();
 227         }
 228
 229         archive_write_set_bytes_per_block(a, bsdtar->bytes_per_block);
 230         archive_write_set_bytes_in_last_block(a, bsdtar->bytes_in_last_block);
 231
 232         r = cset_write_add_filters(bsdtar->cset, a, &filter_name);
 233         if (r < ARCHIVE_WARN) {
 234                 lafe_errc(1, 0, "Unsupported compression option --%s",
 235                     (const char *)filter_name);
 236         }
 237
 238         set_writer_options(bsdtar, a);
 239         if (ARCHIVE_OK != archive_write_open_filename(a, bsdtar->filename))
 240                 lafe_errc(1, 0, "%s", archive_error_string(a));
 241         write_archive(a, bsdtar);
 242 }
 243
 244 /*
 245  * Same as 'c', except we only support tar or empty formats in
 246  * uncompressed files on disk.
 247  */
 248 void
 249 tar_mode_r(struct bsdtar *bsdtar)
 250 {
 251         int64_t end_offset;
 252         int     format;
 253         struct archive *a;
 254         struct archive_entry *entry;
 255         int     r;
 256
 257         /* Sanity-test some arguments and the file. */
 258         test_for_append(bsdtar);
 259
 260         format = ARCHIVE_FORMAT_TAR_PAX_RESTRICTED;
 261
 262 #if defined(__BORLANDC__)
 263         bsdtar->fd = open(bsdtar->filename, O_RDWR | O_CREAT | O_BINARY);
 264 #else
 265         bsdtar->fd = open(bsdtar->filename, O_RDWR | O_CREAT | O_BINARY, 0666);
 266 #endif
 267         if (bsdtar->fd < 0)
 268                 lafe_errc(1, errno,
 269                     "Cannot open %s", bsdtar->filename);
 270
 271         a = archive_read_new();
 272         archive_read_support_filter_all(a);
 273         archive_read_support_format_empty(a);
 274         archive_read_support_format_tar(a);
 275         archive_read_support_format_gnutar(a);
 276         set_reader_options(bsdtar, a);
 277         r = archive_read_open_fd(a, bsdtar->fd, 10240);
 278         if (r != ARCHIVE_OK)
 279                 lafe_errc(1, archive_errno(a),
 280                     "Can't read archive %s: %s", bsdtar->filename,
 281                     archive_error_string(a));
 282         while (0 == archive_read_next_header(a, &entry)) {
 283                 if (archive_filter_code(a, 0) != ARCHIVE_FILTER_NONE) {
 284                         archive_read_free(a);
 285                         close(bsdtar->fd);
 286                         lafe_errc(1, 0,
 287                             "Cannot append to compressed archive.");
 288                 }
 289                 /* Keep going until we hit end-of-archive */
 290                 format = archive_format(a);
 291         }
 292
 293         end_offset = archive_read_header_position(a);
 294         archive_read_free(a);
 295
 296         /* Re-open archive for writing */
 297         a = archive_write_new();
 298         /*
 299          * Set the format to be used for writing.  To allow people to
 300          * extend empty files, we need to allow them to specify the format,
 301          * which opens the possibility that they will specify a format that
 302          * doesn't match the existing format.  Hence, the following bit
 303          * of arcane ugliness.
 304          */
 305
 306         if (cset_get_format(bsdtar->cset) != NULL) {
 307                 /* If the user requested a format, use that, but ... */
 308                 archive_write_set_format_by_name(a,
 309                     cset_get_format(bsdtar->cset));
 310                 /* ... complain if it's not compatible. */
 311                 format &= ARCHIVE_FORMAT_BASE_MASK;
 312                 if (format != (int)(archive_format(a) & ARCHIVE_FORMAT_BASE_MASK)
 313                     && format != ARCHIVE_FORMAT_EMPTY) {
 314                         lafe_errc(1, 0,
 315                             "Format %s is incompatible with the archive %s.",
 316                             cset_get_format(bsdtar->cset), bsdtar->filename);
 317                 }
 318         } else {
 319                 /*
 320                  * Just preserve the current format, with a little care
 321                  * for formats that libarchive can't write.
 322                  */
 323                 if (format == ARCHIVE_FORMAT_EMPTY)
 324                         format = ARCHIVE_FORMAT_TAR_PAX_RESTRICTED;
 325                 archive_write_set_format(a, format);
 326         }
 327         if (lseek(bsdtar->fd, end_offset, SEEK_SET) < 0)
 328                 lafe_errc(1, errno, "Could not seek to archive end");
 329         set_writer_options(bsdtar, a);
 330         if (ARCHIVE_OK != archive_write_open_fd(a, bsdtar->fd))
 331                 lafe_errc(1, 0, "%s", archive_error_string(a));
 332
 333         write_archive(a, bsdtar); /* XXX check return val XXX */
 334
 335         close(bsdtar->fd);
 336         bsdtar->fd = -1;
 337 }
 338
 339 void
 340 tar_mode_u(struct bsdtar *bsdtar)
 341 {
 342         int64_t                  end_offset;
 343         struct archive          *a;
 344         struct archive_entry    *entry;
 345         int                      format;
 346         struct archive_dir_entry        *p;
 347         struct archive_dir       archive_dir;
 348
 349         bsdtar->archive_dir = &archive_dir;
 350         memset(&archive_dir, 0, sizeof(archive_dir));
 351
 352         format = ARCHIVE_FORMAT_TAR_PAX_RESTRICTED;
 353
 354         /* Sanity-test some arguments and the file. */
 355         test_for_append(bsdtar);
 356
 357         bsdtar->fd = open(bsdtar->filename, O_RDWR | O_BINARY);
 358         if (bsdtar->fd < 0)
 359                 lafe_errc(1, errno,
 360                     "Cannot open %s", bsdtar->filename);
 361
 362         a = archive_read_new();
 363         archive_read_support_filter_all(a);
 364         archive_read_support_format_tar(a);
 365         archive_read_support_format_gnutar(a);
 366         set_reader_options(bsdtar, a);
 367         if (archive_read_open_fd(a, bsdtar->fd, bsdtar->bytes_per_block)
 368             != ARCHIVE_OK) {
 369                 lafe_errc(1, 0,
 370                     "Can't open %s: %s", bsdtar->filename,
 371                     archive_error_string(a));
 372         }
 373
 374         /* Build a list of all entries and their recorded mod times. */
 375         while (0 == archive_read_next_header(a, &entry)) {
 376                 if (archive_filter_code(a, 0) != ARCHIVE_FILTER_NONE) {
 377                         archive_read_free(a);
 378                         close(bsdtar->fd);
 379                         lafe_errc(1, 0,
 380                             "Cannot append to compressed archive.");
 381                 }
 382                 if (archive_match_exclude_entry(bsdtar->matching,
 383                     ARCHIVE_MATCH_MTIME | ARCHIVE_MATCH_OLDER |
 384                     ARCHIVE_MATCH_EQUAL, entry) != ARCHIVE_OK)
 385                         lafe_errc(1, 0, "Error : %s",
 386                             archive_error_string(bsdtar->matching));
 387                 /* Record the last format determination we see */
 388                 format = archive_format(a);
 389                 /* Keep going until we hit end-of-archive */
 390         }
 391
 392         end_offset = archive_read_header_position(a);
 393         archive_read_free(a);
 394
 395         /* Re-open archive for writing. */
 396         a = archive_write_new();
 397         /*
 398          * Set format to same one auto-detected above.
 399          */
 400         archive_write_set_format(a, format);
 401         archive_write_set_bytes_per_block(a, bsdtar->bytes_per_block);
 402         archive_write_set_bytes_in_last_block(a, bsdtar->bytes_in_last_block);
 403
 404         if (lseek(bsdtar->fd, end_offset, SEEK_SET) < 0)
 405                 lafe_errc(1, errno, "Could not seek to archive end");
 406         set_writer_options(bsdtar, a);
 407         if (ARCHIVE_OK != archive_write_open_fd(a, bsdtar->fd))
 408                 lafe_errc(1, 0, "%s", archive_error_string(a));
 409
 410         write_archive(a, bsdtar);
 411
 412         close(bsdtar->fd);
 413         bsdtar->fd = -1;
 414
 415         while (bsdtar->archive_dir->head != NULL) {
 416                 p = bsdtar->archive_dir->head->next;
 417                 free(bsdtar->archive_dir->head->name);
 418                 free(bsdtar->archive_dir->head);
 419                 bsdtar->archive_dir->head = p;
 420         }
 421         bsdtar->archive_dir->tail = NULL;
 422 }
 423
 424
 425 /*
 426  * Write user-specified files/dirs to opened archive.
 427  */
 428 static void
 429 write_archive(struct archive *a, struct bsdtar *bsdtar)
 430 {
 431         const char *arg;
 432         struct archive_entry *entry, *sparse_entry;
 433
 434         /* Choose a suitable copy buffer size */
 435         bsdtar->buff_size = 64 * 1024;
 436         while (bsdtar->buff_size < (size_t)bsdtar->bytes_per_block)
 437           bsdtar->buff_size *= 2;
 438         /* Try to compensate for space we'll lose to alignment. */
 439         bsdtar->buff_size += 16 * 1024;
 440
 441         /* Allocate a buffer for file data. */
 442         if ((bsdtar->buff = malloc(bsdtar->buff_size)) == NULL)
 443                 lafe_errc(1, 0, "cannot allocate memory");
 444
 445         if ((bsdtar->resolver = archive_entry_linkresolver_new()) == NULL)
 446                 lafe_errc(1, 0, "cannot create link resolver");
 447         archive_entry_linkresolver_set_strategy(bsdtar->resolver,
 448             archive_format(a));
 449
 450         /* Create a read_disk object. */
 451         if ((bsdtar->diskreader = archive_read_disk_new()) == NULL)
 452                 lafe_errc(1, 0, "Cannot create read_disk object");
 453         /* Tell the read_disk how handle symlink. */
 454         switch (bsdtar->symlink_mode) {
 455         case 'H':
 456                 archive_read_disk_set_symlink_hybrid(bsdtar->diskreader);
 457                 break;
 458         case 'L':
 459                 archive_read_disk_set_symlink_logical(bsdtar->diskreader);
 460                 break;
 461         default:
 462                 archive_read_disk_set_symlink_physical(bsdtar->diskreader);
 463                 break;
 464         }
 465         /* Register entry filters. */
 466         archive_read_disk_set_matching(bsdtar->diskreader,
 467             bsdtar->matching, excluded_callback, bsdtar);
 468         archive_read_disk_set_metadata_filter_callback(
 469             bsdtar->diskreader, metadata_filter, bsdtar);
 470         /* Set the behavior of archive_read_disk. */
 471         archive_read_disk_set_behavior(bsdtar->diskreader,
 472             bsdtar->readdisk_flags);
 473         archive_read_disk_set_standard_lookup(bsdtar->diskreader);
 474
 475         if (bsdtar->names_from_file != NULL)
 476                 archive_names_from_file(bsdtar, a);
 477
 478         while (*bsdtar->argv) {
 479                 arg = *bsdtar->argv;
 480                 if (arg[0] == '-' && arg[1] == 'C') {
 481                         arg += 2;
 482                         if (*arg == '\0') {
 483                                 bsdtar->argv++;
 484                                 arg = *bsdtar->argv;
 485                                 if (arg == NULL) {
 486                                         lafe_warnc(0, "%s",
 487                                             "Missing argument for -C");
 488                                         bsdtar->return_value = 1;
 489                                         goto cleanup;
 490                                 }
 491                                 if (*arg == '\0') {
 492                                         lafe_warnc(0,
 493                                             "Meaningless argument for -C: ''");
 494                                         bsdtar->return_value = 1;
 495                                         goto cleanup;
 496                                 }
 497                         }
 498                         set_chdir(bsdtar, arg);
 499                 } else {
 500                         if (*arg != '/' && (arg[0] != '@' || arg[1] != '/'))
 501                                 do_chdir(bsdtar); /* Handle a deferred -C */
 502                         if (*arg == '@') {
 503                                 if (append_archive_filename(bsdtar, a,
 504                                     arg + 1) != 0)
 505                                         break;
 506                         } else
 507                                 write_hierarchy(bsdtar, a, arg);
 508                 }
 509                 bsdtar->argv++;
 510         }
 511
 512         archive_read_disk_set_matching(bsdtar->diskreader, NULL, NULL, NULL);
 513         archive_read_disk_set_metadata_filter_callback(
 514             bsdtar->diskreader, NULL, NULL);
 515         entry = NULL;
 516         archive_entry_linkify(bsdtar->resolver, &entry, &sparse_entry);
 517         while (entry != NULL) {
 518                 int r;
 519                 struct archive_entry *entry2;
 520                 struct archive *disk = bsdtar->diskreader;
 521
 522                 /*
 523                  * This tricky code here is to correctly read the cotents
 524                  * of the entry because the disk reader bsdtar->diskreader
 525                  * is pointing at does not have any information about the
 526                  * entry by this time and using archive_read_data_block()
 527                  * with the disk reader consequently must fail. And we
 528                  * have to re-open the entry to read the contents.
 529                  */
 530                 /* TODO: Work with -C option as well. */
 531                 r = archive_read_disk_open(disk,
 532                         archive_entry_sourcepath(entry));
 533                 if (r != ARCHIVE_OK) {
 534                         lafe_warnc(archive_errno(disk),
 535                             "%s", archive_error_string(disk));
 536                         bsdtar->return_value = 1;
 537                         archive_entry_free(entry);
 538                         continue;
 539                 }
 540
 541                 /*
 542                  * Invoke archive_read_next_header2() to work
 543                  * archive_read_data_block(), which is called via write_file(),
 544                  * without failure.
 545                  */
 546                 entry2 = archive_entry_new();
 547                 r = archive_read_next_header2(disk, entry2);
 548                 archive_entry_free(entry2);
 549                 if (r != ARCHIVE_OK) {
 550                         lafe_warnc(archive_errno(disk),
 551                             "%s", archive_error_string(disk));
 552                         if (r == ARCHIVE_FATAL)
 553                                 bsdtar->return_value = 1;
 554                         else
 555                                 archive_read_close(disk);
 556                         archive_entry_free(entry);
 557                         continue;
 558                 }
 559
 560                 write_file(bsdtar, a, entry);
 561                 archive_entry_free(entry);
 562                 archive_read_close(disk);
 563                 entry = NULL;
 564                 archive_entry_linkify(bsdtar->resolver, &entry, &sparse_entry);
 565         }
 566
 567         if (archive_write_close(a)) {
 568                 lafe_warnc(0, "%s", archive_error_string(a));
 569                 bsdtar->return_value = 1;
 570         }
 571
 572 cleanup:
 573         /* Free file data buffer. */
 574         free(bsdtar->buff);
 575         archive_entry_linkresolver_free(bsdtar->resolver);
 576         bsdtar->resolver = NULL;
 577         archive_read_free(bsdtar->diskreader);
 578         bsdtar->diskreader = NULL;
 579
 580         if (bsdtar->option_totals) {
 581                 fprintf(stderr, "Total bytes written: %s\n",
 582                     tar_i64toa(archive_filter_bytes(a, -1)));
 583         }
 584
 585         archive_write_free(a);
 586 }
 587
 588 /*
 589  * Archive names specified in file.
 590  *
 591  * Unless --null was specified, a line containing exactly "-C" will
 592  * cause the next line to be a directory to pass to chdir().  If
 593  * --null is specified, then a line "-C" is just another filename.
 594  */
 595 static void
 596 archive_names_from_file(struct bsdtar *bsdtar, struct archive *a)
 597 {
 598         struct lafe_line_reader *lr;
 599         const char *line;
 600
 601         bsdtar->next_line_is_dir = 0;
 602
 603         lr = lafe_line_reader(bsdtar->names_from_file, bsdtar->option_null);
 604         while ((line = lafe_line_reader_next(lr)) != NULL) {
 605                 if (bsdtar->next_line_is_dir) {
 606                         if (*line != '\0')
 607                                 set_chdir(bsdtar, line);
 608                         else {
 609                                 lafe_warnc(0,
 610                                     "Meaningless argument for -C: ''");
 611                                 bsdtar->return_value = 1;
 612                         }
 613                         bsdtar->next_line_is_dir = 0;
 614                 } else if (!bsdtar->option_null && strcmp(line, "-C") == 0)
 615                         bsdtar->next_line_is_dir = 1;
 616                 else {
 617                         if (*line != '/')
 618                                 do_chdir(bsdtar); /* Handle a deferred -C */
 619                         write_hierarchy(bsdtar, a, line);
 620                 }
 621         }
 622         lafe_line_reader_free(lr);
 623         if (bsdtar->next_line_is_dir)
 624                 lafe_errc(1, errno,
 625                     "Unexpected end of filename list; "
 626                     "directory expected after -C");
 627 }
 628
 629 /*
 630  * Copy from specified archive to current archive.  Returns non-zero
 631  * for write errors (which force us to terminate the entire archiving
 632  * operation).  If there are errors reading the input archive, we set
 633  * bsdtar->return_value but return zero, so the overall archiving
 634  * operation will complete and return non-zero.
 635  */
 636 static int
 637 append_archive_filename(struct bsdtar *bsdtar, struct archive *a,
 638     const char *raw_filename)
 639 {
 640         struct archive *ina;
 641         const char *filename = raw_filename;
 642         int rc;
 643
 644         if (strcmp(filename, "-") == 0)
 645                 filename = NULL; /* Library uses NULL for stdio. */
 646
 647         ina = archive_read_new();
 648         archive_read_support_format_all(ina);
 649         archive_read_support_filter_all(ina);
 650         set_reader_options(bsdtar, a);
 651         if (archive_read_open_filename(ina, filename,
 652                                         bsdtar->bytes_per_block)) {
 653                 lafe_warnc(0, "%s", archive_error_string(ina));
 654                 bsdtar->return_value = 1;
 655                 return (0);
 656         }
 657
 658         rc = append_archive(bsdtar, a, ina);
 659
 660         if (rc != ARCHIVE_OK) {
 661                 lafe_warnc(0, "Error reading archive %s: %s",
 662                     raw_filename, archive_error_string(ina));
 663                 bsdtar->return_value = 1;
 664         }
 665         archive_read_free(ina);
 666
 667         return (rc);
 668 }
 669
 670 static int
 671 append_archive(struct bsdtar *bsdtar, struct archive *a, struct archive *ina)
 672 {
 673         struct archive_entry *in_entry;
 674         int e;
 675
 676         while (ARCHIVE_OK == (e = archive_read_next_header(ina, &in_entry))) {
 677                 if (archive_match_excluded(bsdtar->matching, in_entry))
 678                         continue;
 679                 if (bsdtar->option_interactive &&
 680                     !yes("copy '%s'", archive_entry_pathname(in_entry)))
 681                         continue;
 682                 if (bsdtar->verbose)
 683                         safe_fprintf(stderr, "a %s",
 684                             archive_entry_pathname(in_entry));
 685                 if (need_report())
 686                         report_write(bsdtar, a, in_entry, 0);
 687
 688                 e = archive_write_header(a, in_entry);
 689                 if (e != ARCHIVE_OK) {
 690                         if (!bsdtar->verbose)
 691                                 lafe_warnc(0, "%s: %s",
 692                                     archive_entry_pathname(in_entry),
 693                                     archive_error_string(a));
 694                         else
 695                                 fprintf(stderr, ": %s", archive_error_string(a));
 696                 }
 697                 if (e == ARCHIVE_FATAL)
 698                         exit(1);
 699
 700                 if (e >= ARCHIVE_WARN) {
 701                         if (archive_entry_size(in_entry) == 0)
 702                                 archive_read_data_skip(ina);
 703                         else if (copy_file_data_block(bsdtar, a, ina, in_entry))
 704                                 exit(1);
 705                 }
 706
 707                 if (bsdtar->verbose)
 708                         fprintf(stderr, "\n");
 709         }
 710
 711         return (e == ARCHIVE_EOF ? ARCHIVE_OK : e);
 712 }
 713
 714 /* Helper function to copy file to archive. */
 715 static int
 716 copy_file_data_block(struct bsdtar *bsdtar, struct archive *a,
 717     struct archive *in_a, struct archive_entry *entry)
 718 {
 719         size_t  bytes_read;
 720         ssize_t bytes_written;
 721         int64_t offset, progress = 0;
 722         char *null_buff = NULL;
 723         const void *buff;
 724         int r;
 725
 726         while ((r = archive_read_data_block(in_a, &buff,
 727             &bytes_read, &offset)) == ARCHIVE_OK) {
 728                 if (need_report())
 729                         report_write(bsdtar, a, entry, progress);
 730
 731                 if (offset > progress) {
 732                         int64_t sparse = offset - progress;
 733                         size_t ns;
 734
 735                         if (null_buff == NULL) {
 736                                 null_buff = bsdtar->buff;
 737                                 memset(null_buff, 0, bsdtar->buff_size);
 738                         }
 739
 740                         while (sparse > 0) {
 741                                 if (sparse > (int64_t)bsdtar->buff_size)
 742                                         ns = bsdtar->buff_size;
 743                                 else
 744                                         ns = (size_t)sparse;
 745                                 bytes_written =
 746                                     archive_write_data(a, null_buff, ns);
 747                                 if (bytes_written < 0) {
 748                                         /* Write failed; this is bad */
 749                                         lafe_warnc(0, "%s",
 750                                              archive_error_string(a));
 751                                         return (-1);
 752                                 }
 753                                 if ((size_t)bytes_written < ns) {
 754                                         /* Write was truncated; warn but
 755                                          * continue. */
 756                                         lafe_warnc(0,
 757                                             "%s: Truncated write; file may "
 758                                             "have grown while being archived.",
 759                                             archive_entry_pathname(entry));
 760                                         return (0);
 761                                 }
 762                                 progress += bytes_written;
 763                                 sparse -= bytes_written;
 764                         }
 765                 }
 766
 767                 bytes_written = archive_write_data(a, buff, bytes_read);
 768                 if (bytes_written < 0) {
 769                         /* Write failed; this is bad */
 770                         lafe_warnc(0, "%s", archive_error_string(a));
 771                         return (-1);
 772                 }
 773                 if ((size_t)bytes_written < bytes_read) {
 774                         /* Write was truncated; warn but continue. */
 775                         lafe_warnc(0,
 776                             "%s: Truncated write; file may have grown "
 777                             "while being archived.",
 778                             archive_entry_pathname(entry));
 779                         return (0);
 780                 }
 781                 progress += bytes_written;
 782         }
 783         if (r < ARCHIVE_WARN) {
 784                 lafe_warnc(archive_errno(a), "%s", archive_error_string(a));
 785                 return (-1);
 786         }
 787         return (0);
 788 }
 789
 790 static void
 791 excluded_callback(struct archive *a, void *_data, struct archive_entry *entry)
 792 {
 793         struct bsdtar *bsdtar = (struct bsdtar *)_data;
 794
 795         if (bsdtar->option_no_subdirs)
 796                 return;
 797         if (!archive_read_disk_can_descend(a))
 798                 return;
 799         if (bsdtar->option_interactive &&
 800             !yes("add '%s'", archive_entry_pathname(entry)))
 801                 return;
 802         archive_read_disk_descend(a);
 803 }
 804
 805 static int
 806 metadata_filter(struct archive *a, void *_data, struct archive_entry *entry)
 807 {
 808         struct bsdtar *bsdtar = (struct bsdtar *)_data;
 809
 810         /* XXX TODO: check whether this filesystem is
 811          * synthetic and/or local.  Add a new
 812          * --local-only option to skip non-local
 813          * filesystems.  Skip synthetic filesystems
 814          * regardless.
 815          *
 816          * The results should be cached, since
 817          * tree.c doesn't usually visit a directory
 818          * and the directory contents together.  A simple
 819          * move-to-front list should perform quite well.
 820          *
 821          * Use archive_read_disk_current_filesystem_is_remote().
 822          */
 823
 824         /*
 825          * If the user vetoes this file/directory, skip it.
 826          * We want this to be fairly late; if some other
 827          * check would veto this file, we shouldn't bother
 828          * the user with it.
 829          */
 830         if (bsdtar->option_interactive &&
 831             !yes("add '%s'", archive_entry_pathname(entry)))
 832                 return (0);
 833
 834         /* Note: if user vetoes, we won't descend. */
 835         if (!bsdtar->option_no_subdirs && archive_read_disk_can_descend(a))
 836                 archive_read_disk_descend(a);
 837
 838         return (1);
 839 }
 840
 841 /*
 842  * Add the file or dir hierarchy named by 'path' to the archive
 843  */
 844 static void
 845 write_hierarchy(struct bsdtar *bsdtar, struct archive *a, const char *path)
 846 {
 847         struct archive *disk = bsdtar->diskreader;
 848         struct archive_entry *entry = NULL, *spare_entry = NULL;
 849         int r;
 850
 851         r = archive_read_disk_open(disk, path);
 852         if (r != ARCHIVE_OK) {
 853                 lafe_warnc(archive_errno(disk),
 854                     "%s", archive_error_string(disk));
 855                 bsdtar->return_value = 1;
 856                 return;
 857         }
 858         bsdtar->first_fs = -1;
 859
 860         for (;;) {
 861                 archive_entry_free(entry);
 862                 entry = archive_entry_new();
 863                 r = archive_read_next_header2(disk, entry);
 864                 if (r == ARCHIVE_EOF)
 865                         break;
 866                 else if (r != ARCHIVE_OK) {
 867                         lafe_warnc(archive_errno(disk),
 868                             "%s", archive_error_string(disk));
 869                         if (r == ARCHIVE_FATAL) {
 870                                 bsdtar->return_value = 1;
 871                                 return;
 872                         } else if (r < ARCHIVE_WARN)
 873                                 continue;
 874                 }
 875
 876                 if (bsdtar->uid >= 0) {
 877                         archive_entry_set_uid(entry, bsdtar->uid);
 878                         if (!bsdtar->uname)
 879                                 archive_entry_set_uname(entry,
 880                                     archive_read_disk_uname(bsdtar->diskreader,
 881                                         bsdtar->uid));
 882                 }
 883                 if (bsdtar->gid >= 0) {
 884                         archive_entry_set_gid(entry, bsdtar->gid);
 885                         if (!bsdtar->gname)
 886                                 archive_entry_set_gname(entry,
 887                                     archive_read_disk_gname(bsdtar->diskreader,
 888                                         bsdtar->gid));
 889                 }
 890                 if (bsdtar->uname)
 891                         archive_entry_set_uname(entry, bsdtar->uname);
 892                 if (bsdtar->gname)
 893                         archive_entry_set_gname(entry, bsdtar->gname);
 894
 895                 /*
 896                  * Rewrite the pathname to be archived.  If rewrite
 897                  * fails, skip the entry.
 898                  */
 899                 if (edit_pathname(bsdtar, entry))
 900                         continue;
 901
 902                 /* Display entry as we process it.
 903                  * This format is required by SUSv2. */
 904                 if (bsdtar->verbose)
 905                         safe_fprintf(stderr, "a %s",
 906                             archive_entry_pathname(entry));
 907
 908                 /* Non-regular files get archived with zero size. */
 909                 if (archive_entry_filetype(entry) != AE_IFREG)
 910                         archive_entry_set_size(entry, 0);
 911
 912                 archive_entry_linkify(bsdtar->resolver, &entry, &spare_entry);
 913
 914                 while (entry != NULL) {
 915                         write_file(bsdtar, a, entry);
 916                         archive_entry_free(entry);
 917                         entry = spare_entry;
 918                         spare_entry = NULL;
 919                 }
 920
 921                 if (bsdtar->verbose)
 922                         fprintf(stderr, "\n");
 923         }
 924         archive_entry_free(entry);
 925         archive_read_close(disk);
 926 }
 927
 928 /*
 929  * Write a single file (or directory or other filesystem object) to
 930  * the archive.
 931  */
 932 static void
 933 write_file(struct bsdtar *bsdtar, struct archive *a,
 934     struct archive_entry *entry)
 935 {
 936         write_entry(bsdtar, a, entry);
 937 }
 938
 939 /*
 940  * Write a single entry to the archive.
 941  */
 942 static void
 943 write_entry(struct bsdtar *bsdtar, struct archive *a,
 944     struct archive_entry *entry)
 945 {
 946         int e;
 947
 948         e = archive_write_header(a, entry);
 949         if (e != ARCHIVE_OK) {
 950                 if (!bsdtar->verbose)
 951                         lafe_warnc(0, "%s: %s",
 952                             archive_entry_pathname(entry),
 953                             archive_error_string(a));
 954                 else
 955                         fprintf(stderr, ": %s", archive_error_string(a));
 956         }
 957
 958         if (e == ARCHIVE_FATAL)
 959                 exit(1);
 960
 961         /*
 962          * If we opened a file earlier, write it out now.  Note that
 963          * the format handler might have reset the size field to zero
 964          * to inform us that the archive body won't get stored.  In
 965          * that case, just skip the write.
 966          */
 967         if (e >= ARCHIVE_WARN && archive_entry_size(entry) > 0) {
 968                 if (copy_file_data_block(bsdtar, a, bsdtar->diskreader, entry))
 969                         exit(1);
 970         }
 971 }
 972
 973 static void
 974 report_write(struct bsdtar *bsdtar, struct archive *a,
 975     struct archive_entry *entry, int64_t progress)
 976 {
 977         uint64_t comp, uncomp;
 978         int compression;
 979
 980         if (bsdtar->verbose)
 981                 fprintf(stderr, "\n");
 982         comp = archive_filter_bytes(a, -1);
 983         uncomp = archive_filter_bytes(a, 0);
 984         fprintf(stderr, "In: %d files, %s bytes;",
 985             archive_file_count(a), tar_i64toa(uncomp));
 986         if (comp > uncomp)
 987                 compression = 0;
 988         else
 989                 compression = (int)((uncomp - comp) * 100 / uncomp);
 990         fprintf(stderr,
 991             " Out: %s bytes, compression %d%%\n",
 992             tar_i64toa(comp), compression);
 993         /* Can't have two calls to tar_i64toa() pending, so split the output. */
 994         safe_fprintf(stderr, "Current: %s (%s",
 995             archive_entry_pathname(entry),
 996             tar_i64toa(progress));
 997         fprintf(stderr, "/%s bytes)\n",
 998             tar_i64toa(archive_entry_size(entry)));
 999 }
1000
1001 static void
1002 test_for_append(struct bsdtar *bsdtar)
1003 {
1004         struct stat s;
1005
1006         if (*bsdtar->argv == NULL && bsdtar->names_from_file == NULL)
1007                 lafe_errc(1, 0, "no files or directories specified");
1008         if (bsdtar->filename == NULL)
1009                 lafe_errc(1, 0, "Cannot append to stdout.");
1010
1011         if (stat(bsdtar->filename, &s) != 0)
1012                 return;
1013
1014         if (!S_ISREG(s.st_mode) && !S_ISBLK(s.st_mode))
1015                 lafe_errc(1, 0,
1016                     "Cannot append to %s: not a regular file.",
1017                     bsdtar->filename);
1018
1019 /* Is this an appropriate check here on Windows? */
1020 /*
1021         if (GetFileType(handle) != FILE_TYPE_DISK)
1022                 lafe_errc(1, 0, "Cannot append");
1023 */
1024
1025 }