contrib/bsdtar/write.c

   1 /*-
   2  * Copyright (c) 2003-2004 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  *    in this position and unchanged.
  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.35 2004/11/05 05:39:37 kientzle Exp $");
  29
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32 #ifdef HAVE_POSIX_ACL
  33 #include <sys/acl.h>
  34 #endif
  35 #include <archive.h>
  36 #include <archive_entry.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <fnmatch.h>
  40 #include <fts.h>
  41 #include <grp.h>
  42 #include <limits.h>
  43 #include <pwd.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #ifdef linux
  49 #include <ext2fs/ext2_fs.h>
  50 #include <sys/ioctl.h>
  51 #endif
  52
  53 #include "bsdtar.h"
  54
  55 /* Fixed size of uname/gname caches. */
  56 #define name_cache_size 101
  57
  58 static const char * const NO_NAME = "(noname)";
  59
  60 /* Initial size of link cache. */
  61 #define links_cache_initial_size 1024
  62
  63 struct archive_dir_entry {
  64         struct archive_dir_entry        *next;
  65         time_t                   mtime_sec;
  66         int                      mtime_nsec;
  67         char                    *name;
  68 };
  69
  70 struct archive_dir {
  71         struct archive_dir_entry *head, *tail;
  72 };
  73
  74 struct links_cache {
  75         unsigned long             number_entries;
  76         size_t                    number_buckets;
  77         struct links_entry      **buckets;
  78 };
  79
  80 struct links_entry {
  81         struct links_entry      *next;
  82         struct links_entry      *previous;
  83         int                      links;
  84         dev_t                    dev;
  85         ino_t                    ino;
  86         char                    *name;
  87 };
  88
  89 struct name_cache {
  90         int     probes;
  91         int     hits;
  92         size_t  size;
  93         struct {
  94                 id_t id;
  95                 const char *name;
  96         } cache[name_cache_size];
  97 };
  98
  99 static void              add_dir_list(struct bsdtar *bsdtar, const char *path,
 100                              time_t mtime_sec, int mtime_nsec);
 101 static int               append_archive(struct bsdtar *, struct archive *,
 102                              const char *fname);
 103 static void              archive_names_from_file(struct bsdtar *bsdtar,
 104                              struct archive *a);
 105 static int               archive_names_from_file_helper(struct bsdtar *bsdtar,
 106                              const char *line);
 107 static void              create_cleanup(struct bsdtar *);
 108 static void              free_buckets(struct bsdtar *, struct links_cache *);
 109 static void              free_cache(struct name_cache *cache);
 110 static const char *      lookup_gname(struct bsdtar *bsdtar, gid_t gid);
 111 static int               lookup_gname_helper(struct bsdtar *bsdtar,
 112                              const char **name, id_t gid);
 113 static void              lookup_hardlink(struct bsdtar *,
 114                              struct archive_entry *entry, const struct stat *);
 115 static const char *      lookup_uname(struct bsdtar *bsdtar, uid_t uid);
 116 static int               lookup_uname_helper(struct bsdtar *bsdtar,
 117                              const char **name, id_t uid);
 118 static int               new_enough(struct bsdtar *, const char *path,
 119                              time_t mtime_sec, int mtime_nsec);
 120 static void              setup_acls(struct bsdtar *, struct archive_entry *,
 121                              const char *path);
 122 static void              test_for_append(struct bsdtar *);
 123 static void              write_archive(struct archive *, struct bsdtar *);
 124 static void              write_entry(struct bsdtar *, struct archive *,
 125                              struct stat *, const char *pathname,
 126                              unsigned pathlen, const char *accpath);
 127 static int               write_file_data(struct bsdtar *, struct archive *,
 128                              int fd);
 129 static void              write_heirarchy(struct bsdtar *, struct archive *,
 130                              const char *);
 131
 132 void
 133 tar_mode_c(struct bsdtar *bsdtar)
 134 {
 135         struct archive *a;
 136         int r;
 137
 138         if (*bsdtar->argv == NULL && bsdtar->names_from_file == NULL)
 139                 bsdtar_errc(bsdtar, 1, 0, "no files or directories specified");
 140
 141         a = archive_write_new();
 142
 143         /* Support any format that the library supports. */
 144         if (bsdtar->create_format == NULL) {
 145                 r = archive_write_set_format_pax_restricted(a);
 146                 bsdtar->create_format = "pax restricted";
 147         } else {
 148                 r = archive_write_set_format_by_name(a, bsdtar->create_format);
 149         }
 150         if (r != ARCHIVE_OK) {
 151                 fprintf(stderr, "Can't use format %s: %s\n",
 152                     bsdtar->create_format,
 153                     archive_error_string(a));
 154                 usage(bsdtar);
 155         }
 156
 157         /*
 158          * If user explicitly set the block size, then assume they
 159          * want the last block padded as well.  Otherwise, use the
 160          * default block size and accept archive_write_open_file()'s
 161          * default padding decisions.
 162          */
 163         if (bsdtar->bytes_per_block != 0) {
 164                 archive_write_set_bytes_per_block(a, bsdtar->bytes_per_block);
 165                 archive_write_set_bytes_in_last_block(a,
 166                     bsdtar->bytes_per_block);
 167         } else
 168                 archive_write_set_bytes_per_block(a, DEFAULT_BYTES_PER_BLOCK);
 169
 170         switch (bsdtar->create_compression) {
 171         case 0:
 172                 break;
 173 #ifdef HAVE_LIBBZ2
 174         case 'j': case 'y':
 175                 archive_write_set_compression_bzip2(a);
 176                 break;
 177 #endif
 178 #ifdef HAVE_LIBZ
 179         case 'z':
 180                 archive_write_set_compression_gzip(a);
 181                 break;
 182 #endif
 183         default:
 184                 bsdtar_errc(bsdtar, 1, 0,
 185                     "Unrecognized compression option -%c",
 186                     bsdtar->create_compression);
 187         }
 188
 189         r = archive_write_open_file(a, bsdtar->filename);
 190         if (r != ARCHIVE_OK)
 191                 bsdtar_errc(bsdtar, 1, 0, archive_error_string(a));
 192
 193         write_archive(a, bsdtar);
 194
 195         if (bsdtar->option_totals) {
 196                 fprintf(stderr, "Total bytes written: " BSDTAR_FILESIZE_PRINTF "\n",
 197                     (BSDTAR_FILESIZE_TYPE)archive_position_compressed(a));
 198         }
 199
 200         archive_write_finish(a);
 201 }
 202
 203 /*
 204  * Same as 'c', except we only support tar formats in uncompressed
 205  * files on disk.
 206  */
 207 void
 208 tar_mode_r(struct bsdtar *bsdtar)
 209 {
 210         off_t   end_offset;
 211         int     format;
 212         struct archive *a;
 213         struct archive_entry *entry;
 214
 215         /* Sanity-test some arguments and the file. */
 216         test_for_append(bsdtar);
 217
 218         format = ARCHIVE_FORMAT_TAR_PAX_RESTRICTED;
 219
 220         bsdtar->fd = open(bsdtar->filename, O_RDWR);
 221         if (bsdtar->fd < 0)
 222                 bsdtar_errc(bsdtar, 1, errno,
 223                     "Cannot open %s", bsdtar->filename);
 224
 225         a = archive_read_new();
 226         archive_read_support_compression_all(a);
 227         archive_read_support_format_tar(a);
 228         archive_read_support_format_gnutar(a);
 229         archive_read_open_fd(a, bsdtar->fd, 10240);
 230         while (0 == archive_read_next_header(a, &entry)) {
 231                 if (archive_compression(a) != ARCHIVE_COMPRESSION_NONE) {
 232                         archive_read_finish(a);
 233                         close(bsdtar->fd);
 234                         bsdtar_errc(bsdtar, 1, 0,
 235                             "Cannot append to compressed archive.");
 236                 }
 237                 /* Keep going until we hit end-of-archive */
 238                 format = archive_format(a);
 239         }
 240
 241         end_offset = archive_read_header_position(a);
 242         archive_read_finish(a);
 243
 244         /* Re-open archive for writing */
 245         a = archive_write_new();
 246         archive_write_set_compression_none(a);
 247         /*
 248          * Set format to same one auto-detected above, except use
 249          * ustar for appending to GNU tar, since the library doesn't
 250          * write GNU tar format.
 251          */
 252         if (format == ARCHIVE_FORMAT_TAR_GNUTAR)
 253                 format = ARCHIVE_FORMAT_TAR_USTAR;
 254         archive_write_set_format(a, format);
 255         lseek(bsdtar->fd, end_offset, SEEK_SET); /* XXX check return val XXX */
 256         archive_write_open_fd(a, bsdtar->fd); /* XXX check return val XXX */
 257
 258         write_archive(a, bsdtar); /* XXX check return val XXX */
 259
 260         if (bsdtar->option_totals) {
 261                 fprintf(stderr, "Total bytes written: " BSDTAR_FILESIZE_PRINTF "\n",
 262                     (BSDTAR_FILESIZE_TYPE)archive_position_compressed(a));
 263         }
 264
 265         archive_write_finish(a);
 266         close(bsdtar->fd);
 267         bsdtar->fd = -1;
 268 }
 269
 270 void
 271 tar_mode_u(struct bsdtar *bsdtar)
 272 {
 273         off_t                    end_offset;
 274         struct archive          *a;
 275         struct archive_entry    *entry;
 276         const char              *filename;
 277         int                      format;
 278         struct archive_dir_entry        *p;
 279         struct archive_dir       archive_dir;
 280
 281         bsdtar->archive_dir = &archive_dir;
 282         memset(&archive_dir, 0, sizeof(archive_dir));
 283
 284         filename = NULL;
 285         format = ARCHIVE_FORMAT_TAR_PAX_RESTRICTED;
 286
 287         /* Sanity-test some arguments and the file. */
 288         test_for_append(bsdtar);
 289
 290         bsdtar->fd = open(bsdtar->filename, O_RDWR);
 291         if (bsdtar->fd < 0)
 292                 bsdtar_errc(bsdtar, 1, errno,
 293                     "Cannot open %s", bsdtar->filename);
 294
 295         a = archive_read_new();
 296         archive_read_support_compression_all(a);
 297         archive_read_support_format_tar(a);
 298         archive_read_support_format_gnutar(a);
 299         archive_read_open_fd(a, bsdtar->fd,
 300             bsdtar->bytes_per_block != 0 ? bsdtar->bytes_per_block :
 301             DEFAULT_BYTES_PER_BLOCK);
 302
 303         /* Build a list of all entries and their recorded mod times. */
 304         while (0 == archive_read_next_header(a, &entry)) {
 305                 if (archive_compression(a) != ARCHIVE_COMPRESSION_NONE) {
 306                         archive_read_finish(a);
 307                         close(bsdtar->fd);
 308                         bsdtar_errc(bsdtar, 1, 0,
 309                             "Cannot append to compressed archive.");
 310                 }
 311                 add_dir_list(bsdtar, archive_entry_pathname(entry),
 312                     archive_entry_mtime(entry),
 313                     archive_entry_mtime_nsec(entry));
 314                 /* Record the last format determination we see */
 315                 format = archive_format(a);
 316                 /* Keep going until we hit end-of-archive */
 317         }
 318
 319         end_offset = archive_read_header_position(a);
 320         archive_read_finish(a);
 321
 322         /* Re-open archive for writing. */
 323         a = archive_write_new();
 324         archive_write_set_compression_none(a);
 325         /*
 326          * Set format to same one auto-detected above, except that
 327          * we don't write GNU tar format, so use ustar instead.
 328          */
 329         if (format == ARCHIVE_FORMAT_TAR_GNUTAR)
 330                 format = ARCHIVE_FORMAT_TAR_USTAR;
 331         archive_write_set_format(a, format);
 332         if (bsdtar->bytes_per_block != 0) {
 333                 archive_write_set_bytes_per_block(a, bsdtar->bytes_per_block);
 334                 archive_write_set_bytes_in_last_block(a,
 335                     bsdtar->bytes_per_block);
 336         } else
 337                 archive_write_set_bytes_per_block(a, DEFAULT_BYTES_PER_BLOCK);
 338         lseek(bsdtar->fd, end_offset, SEEK_SET);
 339         ftruncate(bsdtar->fd, end_offset);
 340         archive_write_open_fd(a, bsdtar->fd);
 341
 342         write_archive(a, bsdtar);
 343
 344         if (bsdtar->option_totals) {
 345                 fprintf(stderr, "Total bytes written: " BSDTAR_FILESIZE_PRINTF "\n",
 346                     (BSDTAR_FILESIZE_TYPE)archive_position_compressed(a));
 347         }
 348
 349         archive_write_finish(a);
 350         close(bsdtar->fd);
 351         bsdtar->fd = -1;
 352
 353         while (bsdtar->archive_dir->head != NULL) {
 354                 p = bsdtar->archive_dir->head->next;
 355                 free(bsdtar->archive_dir->head->name);
 356                 free(bsdtar->archive_dir->head);
 357                 bsdtar->archive_dir->head = p;
 358         }
 359         bsdtar->archive_dir->tail = NULL;
 360 }
 361
 362
 363 /*
 364  * Write user-specified files/dirs to opened archive.
 365  */
 366 static void
 367 write_archive(struct archive *a, struct bsdtar *bsdtar)
 368 {
 369         const char *arg;
 370
 371         if (bsdtar->names_from_file != NULL)
 372                 archive_names_from_file(bsdtar, a);
 373
 374         while (*bsdtar->argv) {
 375                 arg = *bsdtar->argv;
 376                 if (arg[0] == '-' && arg[1] == 'C') {
 377                         arg += 2;
 378                         if (*arg == '\0') {
 379                                 bsdtar->argv++;
 380                                 arg = *bsdtar->argv;
 381                                 if (arg == NULL) {
 382                                         bsdtar_warnc(bsdtar, 1, 0,
 383                                             "Missing argument for -C");
 384                                         bsdtar->return_value = 1;
 385                                         return;
 386                                 }
 387                         }
 388                         set_chdir(bsdtar, arg);
 389                 } else {
 390                         if (*arg != '/' || (arg[0] == '@' && arg[1] != '/'))
 391                                 do_chdir(bsdtar); /* Handle a deferred -C */
 392                         if (*arg == '@') {
 393                                 if (append_archive(bsdtar, a, arg + 1) != 0)
 394                                         break;
 395                         } else
 396                                 write_heirarchy(bsdtar, a, arg);
 397                 }
 398                 bsdtar->argv++;
 399         }
 400
 401         create_cleanup(bsdtar);
 402         archive_write_close(a);
 403 }
 404
 405 /*
 406  * Archive names specified in file.
 407  *
 408  * Unless --null was specified, a line containing exactly "-C" will
 409  * cause the next line to be a directory to pass to chdir().  If
 410  * --null is specified, then a line "-C" is just another filename.
 411  */
 412 void
 413 archive_names_from_file(struct bsdtar *bsdtar, struct archive *a)
 414 {
 415         bsdtar->archive = a;
 416
 417         bsdtar->next_line_is_dir = 0;
 418         process_lines(bsdtar, bsdtar->names_from_file,
 419             archive_names_from_file_helper);
 420         if (bsdtar->next_line_is_dir)
 421                 bsdtar_errc(bsdtar, 1, errno,
 422                     "Unexpected end of filename list; "
 423                     "directory expected after -C");
 424 }
 425
 426 static int
 427 archive_names_from_file_helper(struct bsdtar *bsdtar, const char *line)
 428 {
 429         if (bsdtar->next_line_is_dir) {
 430                 set_chdir(bsdtar, line);
 431                 bsdtar->next_line_is_dir = 0;
 432         } else if (!bsdtar->option_null && strcmp(line, "-C") == 0)
 433                 bsdtar->next_line_is_dir = 1;
 434         else {
 435                 if (*line != '/')
 436                         do_chdir(bsdtar); /* Handle a deferred -C */
 437                 write_heirarchy(bsdtar, bsdtar->archive, line);
 438         }
 439         return (0);
 440 }
 441
 442 /*
 443  * Copy from specified archive to current archive.
 444  * Returns non-zero on fatal error (i.e., output errors).  Errors
 445  * reading the input archive set bsdtar->return_value, but this
 446  * function will still return zero.
 447  */
 448 static int
 449 append_archive(struct bsdtar *bsdtar, struct archive *a, const char *filename)
 450 {
 451         struct archive *ina;
 452         struct archive_entry *in_entry;
 453         int bytes_read, bytes_written;
 454         char buff[8192];
 455
 456         if (strcmp(filename, "-") == 0)
 457                 filename = NULL; /* Library uses NULL for stdio. */
 458
 459         ina = archive_read_new();
 460         archive_read_support_format_all(ina);
 461         archive_read_support_compression_all(ina);
 462         if (archive_read_open_file(ina, filename, 10240)) {
 463                 bsdtar_warnc(bsdtar, 0, "%s", archive_error_string(ina));
 464                 bsdtar->return_value = 1;
 465                 return (0);
 466         }
 467         while (0 == archive_read_next_header(ina, &in_entry)) {
 468                 if (!new_enough(bsdtar, archive_entry_pathname(in_entry),
 469                         archive_entry_mtime(in_entry),
 470                         archive_entry_mtime_nsec(in_entry)))
 471                         continue;
 472                 if (excluded(bsdtar, archive_entry_pathname(in_entry)))
 473                         continue;
 474                 if (bsdtar->option_interactive &&
 475                     !yes("copy '%s'", archive_entry_pathname(in_entry)))
 476                         continue;
 477                 if (bsdtar->verbose)
 478                         safe_fprintf(stderr, "a %s",
 479                             archive_entry_pathname(in_entry));
 480                 /* XXX handle/report errors XXX */
 481                 if (archive_write_header(a, in_entry)) {
 482                         bsdtar_warnc(bsdtar, 0, "%s",
 483                             archive_error_string(ina));
 484                         bsdtar->return_value = 1;
 485                         return (-1);
 486                 }
 487                 bytes_read = archive_read_data(ina, buff, sizeof(buff));
 488                 while (bytes_read > 0) {
 489                         bytes_written =
 490                             archive_write_data(a, buff, bytes_read);
 491                         if (bytes_written < bytes_read) {
 492                                 bsdtar_warnc(bsdtar, archive_errno(a), "%s",
 493                                     archive_error_string(a));
 494                                 return (-1);
 495                         }
 496                         bytes_read =
 497                             archive_read_data(ina, buff, sizeof(buff));
 498                 }
 499                 if (bsdtar->verbose)
 500                         fprintf(stderr, "\n");
 501
 502         }
 503         if (archive_errno(ina)) {
 504                 bsdtar_warnc(bsdtar, 0, "Error reading archive %s: %s",
 505                     filename, archive_error_string(ina));
 506                 bsdtar->return_value = 1;
 507         }
 508
 509         return (0); /* TODO: Return non-zero on error */
 510 }
 511
 512 /*
 513  * Add the file or dir heirarchy named by 'path' to the archive
 514  */
 515 static void
 516 write_heirarchy(struct bsdtar *bsdtar, struct archive *a, const char *path)
 517 {
 518         FTS     *fts;
 519         FTSENT  *ftsent;
 520         int      ftsoptions;
 521         char    *fts_argv[2];
 522 #ifdef linux
 523         int      fd, r;
 524         unsigned long fflags;
 525 #endif
 526
 527         /*
 528          * Sigh: fts_open modifies it's first parameter, so we have to
 529          * copy 'path' to mutable storage.
 530          */
 531         fts_argv[0] = strdup(path);
 532         if (fts_argv[0] == NULL)
 533                 bsdtar_errc(bsdtar, 1, ENOMEM, "Can't open %s", path);
 534         fts_argv[1] = NULL;
 535         ftsoptions = FTS_PHYSICAL;
 536         switch (bsdtar->symlink_mode) {
 537         case 'H':
 538                 ftsoptions |= FTS_COMFOLLOW;
 539                 break;
 540         case 'L':
 541                 ftsoptions = FTS_COMFOLLOW | FTS_LOGICAL;
 542                 break;
 543         }
 544         if (bsdtar->option_dont_traverse_mounts)
 545                 ftsoptions |= FTS_XDEV;
 546
 547         fts = fts_open(fts_argv, ftsoptions, NULL);
 548
 549
 550         if (!fts) {
 551                 bsdtar_warnc(bsdtar, errno, "%s: Cannot open", path);
 552                 bsdtar->return_value = 1;
 553                 return;
 554         }
 555
 556         while ((ftsent = fts_read(fts))) {
 557                 switch (ftsent->fts_info) {
 558                 case FTS_NS:
 559                         bsdtar_warnc(bsdtar, ftsent->fts_errno,
 560                             "%s: Could not stat", ftsent->fts_path);
 561                         bsdtar->return_value = 1;
 562                         break;
 563                 case FTS_ERR:
 564                         bsdtar_warnc(bsdtar, ftsent->fts_errno, "%s",
 565                             ftsent->fts_path);
 566                         bsdtar->return_value = 1;
 567                         break;
 568                 case FTS_DNR:
 569                         bsdtar_warnc(bsdtar, ftsent->fts_errno,
 570                             "%s: Cannot read directory contents",
 571                             ftsent->fts_path);
 572                         bsdtar->return_value = 1;
 573                         break;
 574                 case FTS_W:  /* Skip Whiteout entries */
 575                         break;
 576                 case FTS_DC: /* Directory that causes cycle */
 577                         /* XXX Does this need special handling ? */
 578                         break;
 579                 case FTS_D:
 580                         /*
 581                          * If this dir is flagged "nodump" and we're
 582                          * honoring such flags, tell FTS to skip the
 583                          * entire tree and don't write the entry for the
 584                          * directory itself.
 585                          */
 586 #ifdef HAVE_CHFLAGS
 587                         if (bsdtar->option_honor_nodump &&
 588                             (ftsent->fts_statp->st_flags & UF_NODUMP)) {
 589                                 fts_set(fts, ftsent, FTS_SKIP);
 590                                 break;
 591                         }
 592 #endif
 593
 594 #ifdef linux
 595                         /*
 596                          * Linux has a nodump flag too but to read it
 597                          * we have to open() the dir and do an ioctl on it...
 598                          */
 599                         if (bsdtar->option_honor_nodump &&
 600                             ((fd = open(ftsent->fts_name, O_RDONLY|O_NONBLOCK)) >= 0) &&
 601                             ((r = ioctl(fd, EXT2_IOC_GETFLAGS, &fflags)),
 602                             close(fd), r) >= 0 &&
 603                             (fflags & EXT2_NODUMP_FL)) {
 604                                 fts_set(fts, ftsent, FTS_SKIP);
 605                                 break;
 606                         }
 607 #endif
 608
 609                         /*
 610                          * In -u mode, we need to check whether this
 611                          * is newer than what's already in the archive.
 612                          */
 613                         if (!new_enough(bsdtar, ftsent->fts_path,
 614                                 ftsent->fts_statp->st_mtime,
 615                                 ARCHIVE_STAT_MTIME_NANOS(ftsent->fts_statp)))
 616                                 break;
 617                         /*
 618                          * If this dir is excluded by a filename
 619                          * pattern, tell FTS to skip the entire tree
 620                          * and don't write the entry for the directory
 621                          * itself.
 622                          */
 623                         if (excluded(bsdtar, ftsent->fts_path)) {
 624                                 fts_set(fts, ftsent, FTS_SKIP);
 625                                 break;
 626                         }
 627
 628                         /*
 629                          * If the user vetoes the directory, skip
 630                          * the whole thing.
 631                          */
 632                         if (bsdtar->option_interactive &&
 633                             !yes("add '%s'", ftsent->fts_path)) {
 634                                 fts_set(fts, ftsent, FTS_SKIP);
 635                                 break;
 636                         }
 637
 638                         /*
 639                          * If we're not recursing, tell FTS to skip the
 640                          * tree but do fall through and write the entry
 641                          * for the dir itself.
 642                          */
 643                         if (bsdtar->option_no_subdirs)
 644                                 fts_set(fts, ftsent, FTS_SKIP);
 645                         write_entry(bsdtar, a, ftsent->fts_statp,
 646                             ftsent->fts_path, ftsent->fts_pathlen,
 647                             ftsent->fts_accpath);
 648                         break;
 649                 case FTS_F:
 650                 case FTS_SL:
 651                 case FTS_SLNONE:
 652                 case FTS_DEFAULT:
 653                         /*
 654                          * Skip this file if it's flagged "nodump" and we're
 655                          * honoring that flag.
 656                          */
 657 #if defined(HAVE_CHFLAGS) && defined(UF_NODUMP)
 658                         if (bsdtar->option_honor_nodump &&
 659                             (ftsent->fts_statp->st_flags & UF_NODUMP))
 660                                 break;
 661 #endif
 662
 663 #ifdef linux
 664                         /*
 665                          * Linux has a nodump flag too but to read it
 666                          * we have to open() the file and do an ioctl on it...
 667                          */
 668                         if (bsdtar->option_honor_nodump &&
 669                             S_ISREG(ftsent->fts_statp->st_mode) &&
 670                             ((fd = open(ftsent->fts_name, O_RDONLY|O_NONBLOCK)) >= 0) &&
 671                             ((r = ioctl(fd, EXT2_IOC_GETFLAGS, &fflags)),
 672                             close(fd), r) >= 0 &&
 673                             (fflags & EXT2_NODUMP_FL))
 674                                 break;
 675 #endif
 676
 677                         /*
 678                          * Skip this file if it's excluded by a
 679                          * filename pattern.
 680                          */
 681                         if (excluded(bsdtar, ftsent->fts_path))
 682                                 break;
 683
 684                         /*
 685                          * In -u mode, we need to check whether this
 686                          * is newer than what's already in the archive.
 687                          */
 688                         if (!new_enough(bsdtar, ftsent->fts_path,
 689                                 ftsent->fts_statp->st_mtime,
 690                                 ARCHIVE_STAT_MTIME_NANOS(ftsent->fts_statp)))
 691                                 break;
 692
 693                         if (bsdtar->option_interactive &&
 694                             !yes("add '%s'", ftsent->fts_path)) {
 695                                 break;
 696                         }
 697
 698                         write_entry(bsdtar, a, ftsent->fts_statp,
 699                             ftsent->fts_path, ftsent->fts_pathlen,
 700                             ftsent->fts_accpath);
 701                         break;
 702                 case FTS_DP:
 703                         break;
 704                 default:
 705                         bsdtar_warnc(bsdtar, 0,
 706                             "%s: Heirarchy traversal error %d\n",
 707                             ftsent->fts_path,
 708                             ftsent->fts_info);
 709                         break;
 710                 }
 711
 712         }
 713         if (errno)
 714                 bsdtar_warnc(bsdtar, errno, "%s", path);
 715         if (fts_close(fts))
 716                 bsdtar_warnc(bsdtar, errno, "fts_close failed");
 717         free(fts_argv[0]);
 718 }
 719
 720 /*
 721  * Add a single filesystem object to the archive.
 722  */
 723 static void
 724 write_entry(struct bsdtar *bsdtar, struct archive *a, struct stat *st,
 725     const char *pathname, unsigned pathlen, const char *accpath)
 726 {
 727         struct archive_entry    *entry;
 728         int                      e;
 729         int                      fd;
 730 #ifdef linux
 731         int                      r;
 732         unsigned long            stflags;
 733 #endif
 734         static char              linkbuffer[PATH_MAX+1];
 735
 736         (void)pathlen; /* UNUSED */
 737
 738         fd = -1;
 739         entry = archive_entry_new();
 740
 741         /* Non-regular files get archived with zero size. */
 742         if (!S_ISREG(st->st_mode))
 743                 st->st_size = 0;
 744
 745         /* Strip redundant "./" from start of filename. */
 746         if (pathname != NULL && pathname[0] == '.' && pathname[1] == '/') {
 747                 pathname += 2;
 748                 if (*pathname == '\0')  /* This is the "./" directory. */
 749                         goto cleanup;   /* Don't archive it ever. */
 750         }
 751
 752         /* Strip leading '/' unless user has asked us not to. */
 753         if (pathname && pathname[0] == '/' && !bsdtar->option_absolute_paths) {
 754                 /* Generate a warning the first time this happens. */
 755                 if (!bsdtar->warned_lead_slash) {
 756                         bsdtar_warnc(bsdtar, 0,
 757                             "Removing leading '/' from member names");
 758                         bsdtar->warned_lead_slash = 1;
 759                 }
 760                 pathname++;
 761         }
 762
 763         archive_entry_set_pathname(entry, pathname);
 764
 765         if (!S_ISDIR(st->st_mode) && (st->st_nlink > 1))
 766                 lookup_hardlink(bsdtar, entry, st);
 767
 768         /* Display entry as we process it. This format is required by SUSv2. */
 769         if (bsdtar->verbose)
 770                 safe_fprintf(stderr, "a %s", pathname);
 771
 772         /* Read symbolic link information. */
 773         if ((st->st_mode & S_IFMT) == S_IFLNK) {
 774                 int lnklen;
 775
 776                 lnklen = readlink(accpath, linkbuffer, PATH_MAX);
 777                 if (lnklen < 0) {
 778                         if (!bsdtar->verbose)
 779                                 bsdtar_warnc(bsdtar, errno,
 780                                     "%s: Couldn't read symbolic link",
 781                                     pathname);
 782                         else
 783                                 safe_fprintf(stderr,
 784                                     ": Couldn't read symbolic link: %s",
 785                                     strerror(errno));
 786                         goto cleanup;
 787                 }
 788                 linkbuffer[lnklen] = 0;
 789                 archive_entry_set_symlink(entry, linkbuffer);
 790         }
 791
 792         /* Look up username and group name. */
 793         archive_entry_set_uname(entry, lookup_uname(bsdtar, st->st_uid));
 794         archive_entry_set_gname(entry, lookup_gname(bsdtar, st->st_gid));
 795
 796 #ifdef HAVE_CHFLAGS
 797         if (st->st_flags != 0)
 798                 archive_entry_set_fflags(entry, st->st_flags, 0);
 799 #endif
 800
 801 #ifdef linux
 802         if ((S_ISREG(st->st_mode) || S_ISDIR(st->st_mode)) &&
 803             ((fd = open(accpath, O_RDONLY|O_NONBLOCK)) >= 0) &&
 804             ((r = ioctl(fd, EXT2_IOC_GETFLAGS, &stflags)), close(fd), r) >= 0 &&
 805             stflags) {
 806                 archive_entry_set_fflags(entry, stflags, 0);
 807         }
 808 #endif
 809
 810         archive_entry_copy_stat(entry, st);
 811         setup_acls(bsdtar, entry, accpath);
 812
 813         /*
 814          * If it's a regular file (and non-zero in size) make sure we
 815          * can open it before we start to write.  In particular, note
 816          * that we can always archive a zero-length file, even if we
 817          * can't read it.
 818          */
 819         if (S_ISREG(st->st_mode) && st->st_size > 0) {
 820                 fd = open(accpath, O_RDONLY);
 821                 if (fd < 0) {
 822                         if (!bsdtar->verbose)
 823                                 bsdtar_warnc(bsdtar, errno, "%s", pathname);
 824                         else
 825                                 fprintf(stderr, ": %s", strerror(errno));
 826                         goto cleanup;
 827                 }
 828         }
 829
 830         e = archive_write_header(a, entry);
 831         if (e != ARCHIVE_OK) {
 832                 if (!bsdtar->verbose)
 833                         bsdtar_warnc(bsdtar, 0, "%s: %s", pathname,
 834                             archive_error_string(a));
 835                 else
 836                         fprintf(stderr, ": %s", archive_error_string(a));
 837         }
 838
 839         if (e == ARCHIVE_FATAL)
 840                 exit(1);
 841
 842         /*
 843          * If we opened a file earlier, write it out now.  Note that
 844          * the format handler might have reset the size field to zero
 845          * to inform us that the archive body won't get stored.  In
 846          * that case, just skip the write.
 847          */
 848         if (fd >= 0 && archive_entry_size(entry) > 0)
 849                 write_file_data(bsdtar, a, fd);
 850
 851 cleanup:
 852         if (fd >= 0)
 853                 close(fd);
 854
 855         if (entry != NULL)
 856                 archive_entry_free(entry);
 857
 858         if (bsdtar->verbose)
 859                 fprintf(stderr, "\n");
 860 }
 861
 862
 863 /* Helper function to copy file to archive, with stack-allocated buffer. */
 864 static int
 865 write_file_data(struct bsdtar *bsdtar, struct archive *a, int fd)
 866 {
 867         char    buff[64*1024];
 868         ssize_t bytes_read;
 869         ssize_t bytes_written;
 870
 871         /* XXX TODO: Allocate buffer on heap and store pointer to
 872          * it in bsdtar structure; arrange cleanup as well. XXX */
 873         (void)bsdtar;
 874
 875         bytes_read = read(fd, buff, sizeof(buff));
 876         while (bytes_read > 0) {
 877                 bytes_written = archive_write_data(a, buff, bytes_read);
 878                 if (bytes_written <= 0)
 879                         return (-1); /* Write failed; this is bad */
 880                 bytes_read = read(fd, buff, sizeof(buff));
 881         }
 882         return 0;
 883 }
 884
 885
 886 static void
 887 create_cleanup(struct bsdtar *bsdtar)
 888 {
 889         /* Free inode->pathname map used for hardlink detection. */
 890         if (bsdtar->links_cache != NULL) {
 891                 free_buckets(bsdtar, bsdtar->links_cache);
 892                 free(bsdtar->links_cache);
 893                 bsdtar->links_cache = NULL;
 894         }
 895
 896         free_cache(bsdtar->uname_cache);
 897         bsdtar->uname_cache = NULL;
 898         free_cache(bsdtar->gname_cache);
 899         bsdtar->gname_cache = NULL;
 900 }
 901
 902
 903 static void
 904 free_buckets(struct bsdtar *bsdtar, struct links_cache *links_cache)
 905 {
 906         size_t i;
 907
 908         if (links_cache->buckets == NULL)
 909                 return;
 910
 911         for (i = 0; i < links_cache->number_buckets; i++) {
 912                 while (links_cache->buckets[i] != NULL) {
 913                         struct links_entry *lp = links_cache->buckets[i]->next;
 914                         if (bsdtar->option_warn_links)
 915                                 bsdtar_warnc(bsdtar, 0, "Missing links to %s",
 916                                     links_cache->buckets[i]->name);
 917                         if (links_cache->buckets[i]->name != NULL)
 918                                 free(links_cache->buckets[i]->name);
 919                         free(links_cache->buckets[i]);
 920                         links_cache->buckets[i] = lp;
 921                 }
 922         }
 923         free(links_cache->buckets);
 924         links_cache->buckets = NULL;
 925 }
 926
 927 static void
 928 lookup_hardlink(struct bsdtar *bsdtar, struct archive_entry *entry,
 929     const struct stat *st)
 930 {
 931         struct links_cache      *links_cache;
 932         struct links_entry      *le, **new_buckets;
 933         int                      hash;
 934         size_t                   i, new_size;
 935
 936         /* If necessary, initialize the links cache. */
 937         links_cache = bsdtar->links_cache;
 938         if (links_cache == NULL) {
 939                 bsdtar->links_cache = malloc(sizeof(struct links_cache));
 940                 if (bsdtar->links_cache == NULL)
 941                         bsdtar_errc(bsdtar, 1, ENOMEM,
 942                             "No memory for hardlink detection.");
 943                 links_cache = bsdtar->links_cache;
 944                 memset(links_cache, 0, sizeof(struct links_cache));
 945                 links_cache->number_buckets = links_cache_initial_size;
 946                 links_cache->buckets = malloc(links_cache->number_buckets *
 947                     sizeof(links_cache->buckets[0]));
 948                 if (links_cache->buckets == NULL) {
 949                         bsdtar_errc(bsdtar, 1, ENOMEM,
 950                             "No memory for hardlink detection.");
 951                 }
 952                 for (i = 0; i < links_cache->number_buckets; i++)
 953                         links_cache->buckets[i] = NULL;
 954         }
 955
 956         /* If the links cache overflowed and got flushed, don't bother. */
 957         if (links_cache->buckets == NULL)
 958                 return;
 959
 960         /* If the links cache is getting too full, enlarge the hash table. */
 961         if (links_cache->number_entries > links_cache->number_buckets * 2)
 962         {
 963                 int count;
 964
 965                 new_size = links_cache->number_buckets * 2;
 966                 new_buckets = malloc(new_size * sizeof(struct links_entry *));
 967
 968                 count = 0;
 969
 970                 if (new_buckets != NULL) {
 971                         memset(new_buckets, 0,
 972                             new_size * sizeof(struct links_entry *));
 973                         for (i = 0; i < links_cache->number_buckets; i++) {
 974                                 while (links_cache->buckets[i] != NULL) {
 975                                         /* Remove entry from old bucket. */
 976                                         le = links_cache->buckets[i];
 977                                         links_cache->buckets[i] = le->next;
 978
 979                                         /* Add entry to new bucket. */
 980                                         hash = (le->dev ^ le->ino) % new_size;
 981
 982                                         if (new_buckets[hash] != NULL)
 983                                                 new_buckets[hash]->previous =
 984                                                     le;
 985                                         le->next = new_buckets[hash];
 986                                         le->previous = NULL;
 987                                         new_buckets[hash] = le;
 988                                 }
 989                         }
 990                         free(links_cache->buckets);
 991                         links_cache->buckets = new_buckets;
 992                         links_cache->number_buckets = new_size;
 993                 } else {
 994                         free_buckets(bsdtar, links_cache);
 995                         bsdtar_warnc(bsdtar, ENOMEM,
 996                             "No more memory for recording hard links");
 997                         bsdtar_warnc(bsdtar, 0,
 998                             "Remaining links will be dumped as full files");
 999                 }
1000         }
1001
1002         /* Try to locate this entry in the links cache. */
1003         hash = ( st->st_dev ^ st->st_ino ) % links_cache->number_buckets;
1004         for (le = links_cache->buckets[hash]; le != NULL; le = le->next) {
1005                 if (le->dev == st->st_dev && le->ino == st->st_ino) {
1006                         archive_entry_copy_hardlink(entry, le->name);
1007
1008                         /*
1009                          * Decrement link count each time and release
1010                          * the entry if it hits zero.  This saves
1011                          * memory and is necessary for proper -l
1012                          * implementation.
1013                          */
1014                         if (--le->links <= 0) {
1015                                 if (le->previous != NULL)
1016                                         le->previous->next = le->next;
1017                                 if (le->next != NULL)
1018                                         le->next->previous = le->previous;
1019                                 if (le->name != NULL)
1020                                         free(le->name);
1021                                 if (links_cache->buckets[hash] == le)
1022                                         links_cache->buckets[hash] = le->next;
1023                                 links_cache->number_entries--;
1024                                 free(le);
1025                         }
1026
1027                         return;
1028                 }
1029         }
1030
1031         /* Add this entry to the links cache. */
1032         le = malloc(sizeof(struct links_entry));
1033         if (le != NULL)
1034                 le->name = strdup(archive_entry_pathname(entry));
1035         if ((le == NULL) || (le->name == NULL)) {
1036                 free_buckets(bsdtar, links_cache);
1037                 bsdtar_warnc(bsdtar, ENOMEM,
1038                     "No more memory for recording hard links");
1039                 bsdtar_warnc(bsdtar, 0,
1040                     "Remaining hard links will be dumped as full files");
1041                 if (le != NULL)
1042                         free(le);
1043                 return;
1044         }
1045         if (links_cache->buckets[hash] != NULL)
1046                 links_cache->buckets[hash]->previous = le;
1047         links_cache->number_entries++;
1048         le->next = links_cache->buckets[hash];
1049         le->previous = NULL;
1050         links_cache->buckets[hash] = le;
1051         le->dev = st->st_dev;
1052         le->ino = st->st_ino;
1053         le->links = st->st_nlink - 1;
1054 }
1055
1056 #ifdef HAVE_POSIX_ACL
1057 void                    setup_acl(struct bsdtar *bsdtar,
1058                              struct archive_entry *entry, const char *accpath,
1059                              int acl_type, int archive_entry_acl_type);
1060
1061 void
1062 setup_acls(struct bsdtar *bsdtar, struct archive_entry *entry,
1063     const char *accpath)
1064 {
1065         archive_entry_acl_clear(entry);
1066
1067         setup_acl(bsdtar, entry, accpath,
1068             ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
1069         /* Only directories can have default ACLs. */
1070         if (S_ISDIR(archive_entry_mode(entry)))
1071                 setup_acl(bsdtar, entry, accpath,
1072                     ACL_TYPE_DEFAULT, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT);
1073 }
1074
1075 void
1076 setup_acl(struct bsdtar *bsdtar, struct archive_entry *entry,
1077     const char *accpath, int acl_type, int archive_entry_acl_type)
1078 {
1079         acl_t            acl;
1080         acl_tag_t        acl_tag;
1081         acl_entry_t      acl_entry;
1082         acl_permset_t    acl_permset;
1083         int              s, ae_id, ae_tag, ae_perm;
1084         const char      *ae_name;
1085
1086         /* Retrieve access ACL from file. */
1087         acl = acl_get_file(accpath, acl_type);
1088         if (acl != NULL) {
1089                 s = acl_get_entry(acl, ACL_FIRST_ENTRY, &acl_entry);
1090                 while (s == 1) {
1091                         ae_id = -1;
1092                         ae_name = NULL;
1093
1094                         acl_get_tag_type(acl_entry, &acl_tag);
1095                         if (acl_tag == ACL_USER) {
1096                                 ae_id = (int)*(uid_t *)acl_get_qualifier(acl_entry);
1097                                 ae_name = lookup_uname(bsdtar, ae_id);
1098                                 ae_tag = ARCHIVE_ENTRY_ACL_USER;
1099                         } else if (acl_tag == ACL_GROUP) {
1100                                 ae_id = (int)*(gid_t *)acl_get_qualifier(acl_entry);
1101                                 ae_name = lookup_gname(bsdtar, ae_id);
1102                                 ae_tag = ARCHIVE_ENTRY_ACL_GROUP;
1103                         } else if (acl_tag == ACL_MASK) {
1104                                 ae_tag = ARCHIVE_ENTRY_ACL_MASK;
1105                         } else if (acl_tag == ACL_USER_OBJ) {
1106                                 ae_tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
1107                         } else if (acl_tag == ACL_GROUP_OBJ) {
1108                                 ae_tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
1109                         } else if (acl_tag == ACL_OTHER) {
1110                                 ae_tag = ARCHIVE_ENTRY_ACL_OTHER;
1111                         } else {
1112                                 /* Skip types that libarchive can't support. */
1113                                 continue;
1114                         }
1115
1116                         acl_get_permset(acl_entry, &acl_permset);
1117                         ae_perm = 0;
1118                         if (acl_get_perm_np(acl_permset, ACL_EXECUTE))
1119                                 ae_perm |= ARCHIVE_ENTRY_ACL_EXECUTE;
1120                         if (acl_get_perm_np(acl_permset, ACL_READ))
1121                                 ae_perm |= ARCHIVE_ENTRY_ACL_READ;
1122                         if (acl_get_perm_np(acl_permset, ACL_WRITE))
1123                                 ae_perm |= ARCHIVE_ENTRY_ACL_WRITE;
1124
1125                         archive_entry_acl_add_entry(entry,
1126                             archive_entry_acl_type, ae_perm, ae_tag,
1127                             ae_id, ae_name);
1128
1129                         s = acl_get_entry(acl, ACL_NEXT_ENTRY, &acl_entry);
1130                 }
1131                 acl_free(acl);
1132         }
1133 }
1134 #else
1135 void
1136 setup_acls(struct bsdtar *bsdtar, struct archive_entry *entry,
1137     const char *accpath)
1138 {
1139         (void)bsdtar;
1140         (void)entry;
1141         (void)accpath;
1142 }
1143 #endif
1144
1145 static void
1146 free_cache(struct name_cache *cache)
1147 {
1148         size_t i;
1149
1150         if (cache != NULL) {
1151                 for(i = 0; i < cache->size; i++) {
1152                         if (cache->cache[i].name != NULL &&
1153                             cache->cache[i].name != NO_NAME)
1154                                 free((void *)(uintptr_t)cache->cache[i].name);
1155                 }
1156                 free(cache);
1157         }
1158 }
1159
1160 /*
1161  * Lookup uid/gid from uname/gname, return NULL if no match.
1162  */
1163 static const char *
1164 lookup_name(struct bsdtar *bsdtar, struct name_cache **name_cache_variable,
1165     int (*lookup_fn)(struct bsdtar *, const char **, id_t), id_t id)
1166 {
1167         struct name_cache       *cache;
1168         const char *name;
1169         int slot;
1170
1171
1172         if (*name_cache_variable == NULL) {
1173                 *name_cache_variable = malloc(sizeof(struct name_cache));
1174                 if (*name_cache_variable == NULL)
1175                         bsdtar_errc(bsdtar, 1, ENOMEM, "No more memory");
1176                 memset(*name_cache_variable, 0, sizeof(struct name_cache));
1177                 (*name_cache_variable)->size = name_cache_size;
1178         }
1179
1180         cache = *name_cache_variable;
1181         cache->probes++;
1182
1183         slot = id % cache->size;
1184         if (cache->cache[slot].name != NULL) {
1185                 if (cache->cache[slot].id == id) {
1186                         cache->hits++;
1187                         if (cache->cache[slot].name == NO_NAME)
1188                                 return (NULL);
1189                         return (cache->cache[slot].name);
1190                 }
1191                 if (cache->cache[slot].name != NO_NAME)
1192                         free((void *)(uintptr_t)cache->cache[slot].name);
1193                 cache->cache[slot].name = NULL;
1194         }
1195
1196         if (lookup_fn(bsdtar, &name, id) == 0) {
1197                 if (name == NULL || name[0] == '\0') {
1198                         /* Cache the negative response. */
1199                         cache->cache[slot].name = NO_NAME;
1200                         cache->cache[slot].id = id;
1201                 } else {
1202                         cache->cache[slot].name = strdup(name);
1203                         if (cache->cache[slot].name != NULL) {
1204                                 cache->cache[slot].id = id;
1205                                 return (cache->cache[slot].name);
1206                         }
1207                         /*
1208                          * Conveniently, NULL marks an empty slot, so
1209                          * if the strdup() fails, we've just failed to
1210                          * cache it.  No recovery necessary.
1211                          */
1212                 }
1213         }
1214         return (NULL);
1215 }
1216
1217 static const char *
1218 lookup_uname(struct bsdtar *bsdtar, uid_t uid)
1219 {
1220         return (lookup_name(bsdtar, &bsdtar->uname_cache,
1221                     &lookup_uname_helper, (id_t)uid));
1222 }
1223
1224 static int
1225 lookup_uname_helper(struct bsdtar *bsdtar, const char **name, id_t id)
1226 {
1227         struct passwd   *pwent;
1228
1229         (void)bsdtar; /* UNUSED */
1230
1231         errno = 0;
1232         pwent = getpwuid((uid_t)id);
1233         if (pwent == NULL) {
1234                 *name = NULL;
1235                 if (errno != 0)
1236                         bsdtar_warnc(bsdtar, errno, "getpwuid(%d) failed", id);
1237                 return (errno);
1238         }
1239
1240         *name = pwent->pw_name;
1241         return (0);
1242 }
1243
1244 static const char *
1245 lookup_gname(struct bsdtar *bsdtar, gid_t gid)
1246 {
1247         return (lookup_name(bsdtar, &bsdtar->gname_cache,
1248                     &lookup_gname_helper, (id_t)gid));
1249 }
1250
1251 static int
1252 lookup_gname_helper(struct bsdtar *bsdtar, const char **name, id_t id)
1253 {
1254         struct group    *grent;
1255
1256         (void)bsdtar; /* UNUSED */
1257
1258         errno = 0;
1259         grent = getgrgid((gid_t)id);
1260         if (grent == NULL) {
1261                 *name = NULL;
1262                 if (errno != 0)
1263                         bsdtar_warnc(bsdtar, errno, "getgrgid(%d) failed", id);
1264                 return (errno);
1265         }
1266
1267         *name = grent->gr_name;
1268         return (0);
1269 }
1270
1271 /*
1272  * Test if the specified file is newer than what's already
1273  * in the archive.
1274  */
1275 int
1276 new_enough(struct bsdtar *bsdtar, const char *path,
1277     time_t mtime_sec, int mtime_nsec)
1278 {
1279         struct archive_dir_entry *p;
1280
1281         if (path[0] == '.' && path[1] == '/' && path[2] != '\0')
1282                 path += 2;
1283
1284         if (bsdtar->archive_dir == NULL ||
1285             bsdtar->archive_dir->head == NULL)
1286                 return (1);
1287
1288         for (p = bsdtar->archive_dir->head; p != NULL; p = p->next) {
1289                 if (strcmp(path, p->name)==0)
1290                         return (p->mtime_sec < mtime_sec ||
1291                                 (p->mtime_sec == mtime_sec &&
1292                                  p->mtime_nsec < mtime_nsec));
1293         }
1294         return (1);
1295 }
1296
1297 /*
1298  * Add an entry to the dir list for 'u' mode.
1299  *
1300  * XXX TODO: Make this fast.
1301  */
1302 static void
1303 add_dir_list(struct bsdtar *bsdtar, const char *path,
1304     time_t mtime_sec, int mtime_nsec)
1305 {
1306         struct archive_dir_entry        *p;
1307
1308         if (path[0] == '.' && path[1] == '/' && path[2] != '\0')
1309                 path += 2;
1310
1311         /*
1312          * Search entire list to see if this file has appeared before.
1313          * If it has, override the timestamp data.
1314          */
1315         p = bsdtar->archive_dir->head;
1316         while (p != NULL) {
1317                 if (strcmp(path, p->name)==0) {
1318                         p->mtime_sec = mtime_sec;
1319                         p->mtime_nsec = mtime_nsec;
1320                         return;
1321                 }
1322                 p = p->next;
1323         }
1324
1325         p = malloc(sizeof(*p));
1326         if (p == NULL)
1327                 bsdtar_errc(bsdtar, 1, ENOMEM, "Can't read archive directory");
1328
1329         p->name = strdup(path);
1330         if (p->name == NULL)
1331                 bsdtar_errc(bsdtar, 1, ENOMEM, "Can't read archive directory");
1332         p->mtime_sec = mtime_sec;
1333         p->mtime_nsec = mtime_nsec;
1334         p->next = NULL;
1335         if (bsdtar->archive_dir->tail == NULL) {
1336                 bsdtar->archive_dir->head = bsdtar->archive_dir->tail = p;
1337         } else {
1338                 bsdtar->archive_dir->tail->next = p;
1339                 bsdtar->archive_dir->tail = p;
1340         }
1341 }
1342
1343 void
1344 test_for_append(struct bsdtar *bsdtar)
1345 {
1346         struct stat s;
1347
1348         if (*bsdtar->argv == NULL)
1349                 bsdtar_errc(bsdtar, 1, 0, "no files or directories specified");
1350         if (bsdtar->filename == NULL)
1351                 bsdtar_errc(bsdtar, 1, 0, "Cannot append to stdout.");
1352
1353         if (bsdtar->create_compression != 0)
1354                 bsdtar_errc(bsdtar, 1, 0,
1355                     "Cannot append to %s with compression", bsdtar->filename);
1356
1357         if (stat(bsdtar->filename, &s) != 0)
1358                 bsdtar_errc(bsdtar, 1, errno,
1359                     "Cannot stat %s", bsdtar->filename);
1360
1361         if (!S_ISREG(s.st_mode))
1362                 bsdtar_errc(bsdtar, 1, 0,
1363                     "Cannot append to %s: not a regular file.",
1364                     bsdtar->filename);
1365 }