contrib/libarchive/libarchive/archive_read_disk_posix.c

   1 /*-
   2  * Copyright (c) 2003-2009 Tim Kientzle
   3  * Copyright (c) 2010,2011 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  *    in this position and unchanged.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 /* This is the tree-walking code for POSIX systems. */
  29 #if !defined(_WIN32) || defined(__CYGWIN__)
  30
  31 #include "archive_platform.h"
  32 __FBSDID("$FreeBSD$");
  33
  34 #ifdef HAVE_SYS_PARAM_H
  35 #include <sys/param.h>
  36 #endif
  37 #ifdef HAVE_SYS_MOUNT_H
  38 #include <sys/mount.h>
  39 #endif
  40 #ifdef HAVE_SYS_STAT_H
  41 #include <sys/stat.h>
  42 #endif
  43 #ifdef HAVE_SYS_STATFS_H
  44 #include <sys/statfs.h>
  45 #endif
  46 #ifdef HAVE_SYS_STATVFS_H
  47 #include <sys/statvfs.h>
  48 #endif
  49 #ifdef HAVE_SYS_TIME_H
  50 #include <sys/time.h>
  51 #endif
  52 #ifdef HAVE_LINUX_MAGIC_H
  53 #include <linux/magic.h>
  54 #endif
  55 #ifdef HAVE_DIRECT_H
  56 #include <direct.h>
  57 #endif
  58 #ifdef HAVE_DIRENT_H
  59 #include <dirent.h>
  60 #endif
  61 #ifdef HAVE_ERRNO_H
  62 #include <errno.h>
  63 #endif
  64 #ifdef HAVE_FCNTL_H
  65 #include <fcntl.h>
  66 #endif
  67 #ifdef HAVE_LIMITS_H
  68 #include <limits.h>
  69 #endif
  70 #ifdef HAVE_STDLIB_H
  71 #include <stdlib.h>
  72 #endif
  73 #ifdef HAVE_STRING_H
  74 #include <string.h>
  75 #endif
  76 #ifdef HAVE_UNISTD_H
  77 #include <unistd.h>
  78 #endif
  79
  80 #include "archive.h"
  81 #include "archive_string.h"
  82 #include "archive_entry.h"
  83 #include "archive_private.h"
  84 #include "archive_read_disk_private.h"
  85
  86 #ifndef HAVE_FCHDIR
  87 #error fchdir function required.
  88 #endif
  89 #ifndef O_BINARY
  90 #define O_BINARY        0
  91 #endif
  92
  93 /*-
  94  * This is a new directory-walking system that addresses a number
  95  * of problems I've had with fts(3).  In particular, it has no
  96  * pathname-length limits (other than the size of 'int'), handles
  97  * deep logical traversals, uses considerably less memory, and has
  98  * an opaque interface (easier to modify in the future).
  99  *
 100  * Internally, it keeps a single list of "tree_entry" items that
 101  * represent filesystem objects that require further attention.
 102  * Non-directories are not kept in memory: they are pulled from
 103  * readdir(), returned to the client, then freed as soon as possible.
 104  * Any directory entry to be traversed gets pushed onto the stack.
 105  *
 106  * There is surprisingly little information that needs to be kept for
 107  * each item on the stack.  Just the name, depth (represented here as the
 108  * string length of the parent directory's pathname), and some markers
 109  * indicating how to get back to the parent (via chdir("..") for a
 110  * regular dir or via fchdir(2) for a symlink).
 111  */
 112 /*
 113  * TODO:
 114  *    1) Loop checking.
 115  *    3) Arbitrary logical traversals by closing/reopening intermediate fds.
 116  */
 117
 118 struct restore_time {
 119         const char              *name;
 120         time_t                   mtime;
 121         long                     mtime_nsec;
 122         time_t                   atime;
 123         long                     atime_nsec;
 124         mode_t                   filetype;
 125         int                      noatime;
 126 };
 127
 128 struct tree_entry {
 129         int                      depth;
 130         struct tree_entry       *next;
 131         struct tree_entry       *parent;
 132         struct archive_string    name;
 133         size_t                   dirname_length;
 134         int64_t                  dev;
 135         int64_t                  ino;
 136         int                      flags;
 137         int                      filesystem_id;
 138         /* How to return back to the parent of a symlink. */
 139         int                      symlink_parent_fd;
 140         /* How to restore time of a directory. */
 141         struct restore_time      restore_time;
 142 };
 143
 144 struct filesystem {
 145         int64_t         dev;
 146         int             synthetic;
 147         int             remote;
 148         int             noatime;
 149 #if defined(HAVE_READDIR_R)
 150         size_t          name_max;
 151 #endif
 152         long            incr_xfer_size;
 153         long            max_xfer_size;
 154         long            min_xfer_size;
 155         long            xfer_align;
 156
 157         /*
 158          * Buffer used for reading file contents.
 159          */
 160         /* Exactly allocated memory pointer. */
 161         unsigned char   *allocation_ptr;
 162         /* Pointer adjusted to the filesystem alignment . */
 163         unsigned char   *buff;
 164         size_t           buff_size;
 165 };
 166
 167 /* Definitions for tree_entry.flags bitmap. */
 168 #define isDir           1  /* This entry is a regular directory. */
 169 #define isDirLink       2  /* This entry is a symbolic link to a directory. */
 170 #define needsFirstVisit 4  /* This is an initial entry. */
 171 #define needsDescent    8  /* This entry needs to be previsited. */
 172 #define needsOpen       16 /* This is a directory that needs to be opened. */
 173 #define needsAscent     32 /* This entry needs to be postvisited. */
 174
 175 /*
 176  * Local data for this package.
 177  */
 178 struct tree {
 179         struct tree_entry       *stack;
 180         struct tree_entry       *current;
 181         DIR                     *d;
 182 #define INVALID_DIR_HANDLE NULL
 183         struct dirent           *de;
 184 #if defined(HAVE_READDIR_R)
 185         struct dirent           *dirent;
 186         size_t                   dirent_allocated;
 187 #endif
 188         int                      flags;
 189         int                      visit_type;
 190         /* Error code from last failed operation. */
 191         int                      tree_errno;
 192
 193         /* Dynamically-sized buffer for holding path */
 194         struct archive_string    path;
 195
 196         /* Last path element */
 197         const char              *basename;
 198         /* Leading dir length */
 199         size_t                   dirname_length;
 200
 201         int                      depth;
 202         int                      openCount;
 203         int                      maxOpenCount;
 204         int                      initial_dir_fd;
 205         int                      working_dir_fd;
 206
 207         struct stat              lst;
 208         struct stat              st;
 209         int                      descend;
 210         int                      nlink;
 211         /* How to restore time of a file. */
 212         struct restore_time      restore_time;
 213
 214         struct entry_sparse {
 215                 int64_t          length;
 216                 int64_t          offset;
 217         }                       *sparse_list, *current_sparse;
 218         int                      sparse_count;
 219         int                      sparse_list_size;
 220
 221         char                     initial_symlink_mode;
 222         char                     symlink_mode;
 223         struct filesystem       *current_filesystem;
 224         struct filesystem       *filesystem_table;
 225         int                      current_filesystem_id;
 226         int                      max_filesystem_id;
 227         int                      allocated_filesytem;
 228
 229         int                      entry_fd;
 230         int                      entry_eof;
 231         int64_t                  entry_remaining_bytes;
 232         int64_t                  entry_total;
 233         unsigned char           *entry_buff;
 234         size_t                   entry_buff_size;
 235 };
 236
 237 /* Definitions for tree.flags bitmap. */
 238 #define hasStat         16 /* The st entry is valid. */
 239 #define hasLstat        32 /* The lst entry is valid. */
 240 #define onWorkingDir    64 /* We are on the working dir where we are
 241                             * reading directory entry at this time. */
 242 #define needsRestoreTimes 128
 243
 244 static int
 245 tree_dir_next_posix(struct tree *t);
 246
 247 #ifdef HAVE_DIRENT_D_NAMLEN
 248 /* BSD extension; avoids need for a strlen() call. */
 249 #define D_NAMELEN(dp)   (dp)->d_namlen
 250 #else
 251 #define D_NAMELEN(dp)   (strlen((dp)->d_name))
 252 #endif
 253
 254 /* Initiate/terminate a tree traversal. */
 255 static struct tree *tree_open(const char *, int, int);
 256 static struct tree *tree_reopen(struct tree *, const char *, int);
 257 static void tree_close(struct tree *);
 258 static void tree_free(struct tree *);
 259 static void tree_push(struct tree *, const char *, int, int64_t, int64_t,
 260                 struct restore_time *);
 261 static int tree_enter_initial_dir(struct tree *);
 262 static int tree_enter_working_dir(struct tree *);
 263 static int tree_current_dir_fd(struct tree *);
 264
 265 /*
 266  * tree_next() returns Zero if there is no next entry, non-zero if
 267  * there is.  Note that directories are visited three times.
 268  * Directories are always visited first as part of enumerating their
 269  * parent; that is a "regular" visit.  If tree_descend() is invoked at
 270  * that time, the directory is added to a work list and will
 271  * subsequently be visited two more times: once just after descending
 272  * into the directory ("postdescent") and again just after ascending
 273  * back to the parent ("postascent").
 274  *
 275  * TREE_ERROR_DIR is returned if the descent failed (because the
 276  * directory couldn't be opened, for instance).  This is returned
 277  * instead of TREE_POSTDESCENT/TREE_POSTASCENT.  TREE_ERROR_DIR is not a
 278  * fatal error, but it does imply that the relevant subtree won't be
 279  * visited.  TREE_ERROR_FATAL is returned for an error that left the
 280  * traversal completely hosed.  Right now, this is only returned for
 281  * chdir() failures during ascent.
 282  */
 283 #define TREE_REGULAR            1
 284 #define TREE_POSTDESCENT        2
 285 #define TREE_POSTASCENT         3
 286 #define TREE_ERROR_DIR          -1
 287 #define TREE_ERROR_FATAL        -2
 288
 289 static int tree_next(struct tree *);
 290
 291 /*
 292  * Return information about the current entry.
 293  */
 294
 295 /*
 296  * The current full pathname, length of the full pathname, and a name
 297  * that can be used to access the file.  Because tree does use chdir
 298  * extensively, the access path is almost never the same as the full
 299  * current path.
 300  *
 301  * TODO: On platforms that support it, use openat()-style operations
 302  * to eliminate the chdir() operations entirely while still supporting
 303  * arbitrarily deep traversals.  This makes access_path troublesome to
 304  * support, of course, which means we'll need a rich enough interface
 305  * that clients can function without it.  (In particular, we'll need
 306  * tree_current_open() that returns an open file descriptor.)
 307  *
 308  */
 309 static const char *tree_current_path(struct tree *);
 310 static const char *tree_current_access_path(struct tree *);
 311
 312 /*
 313  * Request the lstat() or stat() data for the current path.  Since the
 314  * tree package needs to do some of this anyway, and caches the
 315  * results, you should take advantage of it here if you need it rather
 316  * than make a redundant stat() or lstat() call of your own.
 317  */
 318 static const struct stat *tree_current_stat(struct tree *);
 319 static const struct stat *tree_current_lstat(struct tree *);
 320 static int      tree_current_is_symblic_link_target(struct tree *);
 321
 322 /* The following functions use tricks to avoid a certain number of
 323  * stat()/lstat() calls. */
 324 /* "is_physical_dir" is equivalent to S_ISDIR(tree_current_lstat()->st_mode) */
 325 static int tree_current_is_physical_dir(struct tree *);
 326 /* "is_dir" is equivalent to S_ISDIR(tree_current_stat()->st_mode) */
 327 static int tree_current_is_dir(struct tree *);
 328 static int update_current_filesystem(struct archive_read_disk *a,
 329                     int64_t dev);
 330 static int setup_current_filesystem(struct archive_read_disk *);
 331 static int tree_target_is_same_as_parent(struct tree *, const struct stat *);
 332
 333 static int      _archive_read_disk_open(struct archive *, const char *);
 334 static int      _archive_read_free(struct archive *);
 335 static int      _archive_read_close(struct archive *);
 336 static int      _archive_read_data_block(struct archive *,
 337                     const void **, size_t *, int64_t *);
 338 static int      _archive_read_next_header2(struct archive *,
 339                     struct archive_entry *);
 340 static const char *trivial_lookup_gname(void *, int64_t gid);
 341 static const char *trivial_lookup_uname(void *, int64_t uid);
 342 static int      setup_sparse(struct archive_read_disk *, struct archive_entry *);
 343 static int      close_and_restore_time(int fd, struct tree *,
 344                     struct restore_time *);
 345
 346
 347 static struct archive_vtable *
 348 archive_read_disk_vtable(void)
 349 {
 350         static struct archive_vtable av;
 351         static int inited = 0;
 352
 353         if (!inited) {
 354                 av.archive_free = _archive_read_free;
 355                 av.archive_close = _archive_read_close;
 356                 av.archive_read_data_block = _archive_read_data_block;
 357                 av.archive_read_next_header2 = _archive_read_next_header2;
 358                 inited = 1;
 359         }
 360         return (&av);
 361 }
 362
 363 const char *
 364 archive_read_disk_gname(struct archive *_a, int64_t gid)
 365 {
 366         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 367         if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 368                 ARCHIVE_STATE_ANY, "archive_read_disk_gname"))
 369                 return (NULL);
 370         if (a->lookup_gname == NULL)
 371                 return (NULL);
 372         return ((*a->lookup_gname)(a->lookup_gname_data, gid));
 373 }
 374
 375 const char *
 376 archive_read_disk_uname(struct archive *_a, int64_t uid)
 377 {
 378         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 379         if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 380                 ARCHIVE_STATE_ANY, "archive_read_disk_uname"))
 381                 return (NULL);
 382         if (a->lookup_uname == NULL)
 383                 return (NULL);
 384         return ((*a->lookup_uname)(a->lookup_uname_data, uid));
 385 }
 386
 387 int
 388 archive_read_disk_set_gname_lookup(struct archive *_a,
 389     void *private_data,
 390     const char * (*lookup_gname)(void *private, int64_t gid),
 391     void (*cleanup_gname)(void *private))
 392 {
 393         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 394         archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
 395             ARCHIVE_STATE_ANY, "archive_read_disk_set_gname_lookup");
 396
 397         if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)
 398                 (a->cleanup_gname)(a->lookup_gname_data);
 399
 400         a->lookup_gname = lookup_gname;
 401         a->cleanup_gname = cleanup_gname;
 402         a->lookup_gname_data = private_data;
 403         return (ARCHIVE_OK);
 404 }
 405
 406 int
 407 archive_read_disk_set_uname_lookup(struct archive *_a,
 408     void *private_data,
 409     const char * (*lookup_uname)(void *private, int64_t uid),
 410     void (*cleanup_uname)(void *private))
 411 {
 412         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 413         archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
 414             ARCHIVE_STATE_ANY, "archive_read_disk_set_uname_lookup");
 415
 416         if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL)
 417                 (a->cleanup_uname)(a->lookup_uname_data);
 418
 419         a->lookup_uname = lookup_uname;
 420         a->cleanup_uname = cleanup_uname;
 421         a->lookup_uname_data = private_data;
 422         return (ARCHIVE_OK);
 423 }
 424
 425 /*
 426  * Create a new archive_read_disk object and initialize it with global state.
 427  */
 428 struct archive *
 429 archive_read_disk_new(void)
 430 {
 431         struct archive_read_disk *a;
 432
 433         a = (struct archive_read_disk *)malloc(sizeof(*a));
 434         if (a == NULL)
 435                 return (NULL);
 436         memset(a, 0, sizeof(*a));
 437         a->archive.magic = ARCHIVE_READ_DISK_MAGIC;
 438         a->archive.state = ARCHIVE_STATE_NEW;
 439         a->archive.vtable = archive_read_disk_vtable();
 440         a->lookup_uname = trivial_lookup_uname;
 441         a->lookup_gname = trivial_lookup_gname;
 442         a->entry_wd_fd = -1;
 443         return (&a->archive);
 444 }
 445
 446 static int
 447 _archive_read_free(struct archive *_a)
 448 {
 449         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 450         int r;
 451
 452         if (_a == NULL)
 453                 return (ARCHIVE_OK);
 454         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 455             ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_free");
 456
 457         if (a->archive.state != ARCHIVE_STATE_CLOSED)
 458                 r = _archive_read_close(&a->archive);
 459         else
 460                 r = ARCHIVE_OK;
 461
 462         tree_free(a->tree);
 463         if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)
 464                 (a->cleanup_gname)(a->lookup_gname_data);
 465         if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL)
 466                 (a->cleanup_uname)(a->lookup_uname_data);
 467         archive_string_free(&a->archive.error_string);
 468         a->archive.magic = 0;
 469         __archive_clean(&a->archive);
 470         free(a);
 471         return (r);
 472 }
 473
 474 static int
 475 _archive_read_close(struct archive *_a)
 476 {
 477         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 478
 479         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 480             ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_close");
 481
 482         if (a->archive.state != ARCHIVE_STATE_FATAL)
 483                 a->archive.state = ARCHIVE_STATE_CLOSED;
 484
 485         tree_close(a->tree);
 486
 487         return (ARCHIVE_OK);
 488 }
 489
 490 static void
 491 setup_symlink_mode(struct archive_read_disk *a, char symlink_mode,
 492     int follow_symlinks)
 493 {
 494         a->symlink_mode = symlink_mode;
 495         a->follow_symlinks = follow_symlinks;
 496         if (a->tree != NULL) {
 497                 a->tree->initial_symlink_mode = a->symlink_mode;
 498                 a->tree->symlink_mode = a->symlink_mode;
 499         }
 500 }
 501
 502 int
 503 archive_read_disk_set_symlink_logical(struct archive *_a)
 504 {
 505         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 506         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 507             ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_logical");
 508         setup_symlink_mode(a, 'L', 1);
 509         return (ARCHIVE_OK);
 510 }
 511
 512 int
 513 archive_read_disk_set_symlink_physical(struct archive *_a)
 514 {
 515         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 516         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 517             ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_physical");
 518         setup_symlink_mode(a, 'P', 0);
 519         return (ARCHIVE_OK);
 520 }
 521
 522 int
 523 archive_read_disk_set_symlink_hybrid(struct archive *_a)
 524 {
 525         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 526         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 527             ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_hybrid");
 528         setup_symlink_mode(a, 'H', 1);/* Follow symlinks initially. */
 529         return (ARCHIVE_OK);
 530 }
 531
 532 int
 533 archive_read_disk_set_atime_restored(struct archive *_a)
 534 {
 535 #ifndef HAVE_UTIMES
 536         static int warning_done = 0;
 537 #endif
 538         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 539         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 540             ARCHIVE_STATE_ANY, "archive_read_disk_restore_atime");
 541 #ifdef HAVE_UTIMES
 542         a->restore_time = 1;
 543         if (a->tree != NULL)
 544                 a->tree->flags |= needsRestoreTimes;
 545         return (ARCHIVE_OK);
 546 #else
 547         if (warning_done)
 548                 /* Warning was already emitted; suppress further warnings. */
 549                 return (ARCHIVE_OK);
 550
 551         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 552             "Cannot restore access time on this system");
 553         warning_done = 1;
 554         return (ARCHIVE_WARN);
 555 #endif
 556 }
 557
 558 /*
 559  * Trivial implementations of gname/uname lookup functions.
 560  * These are normally overridden by the client, but these stub
 561  * versions ensure that we always have something that works.
 562  */
 563 static const char *
 564 trivial_lookup_gname(void *private_data, int64_t gid)
 565 {
 566         (void)private_data; /* UNUSED */
 567         (void)gid; /* UNUSED */
 568         return (NULL);
 569 }
 570
 571 static const char *
 572 trivial_lookup_uname(void *private_data, int64_t uid)
 573 {
 574         (void)private_data; /* UNUSED */
 575         (void)uid; /* UNUSED */
 576         return (NULL);
 577 }
 578
 579 /*
 580  * Allocate memory for the reading buffer adjusted to the filesystem
 581  * alignment.
 582  */
 583 static int
 584 setup_suitable_read_buffer(struct archive_read_disk *a)
 585 {
 586         struct tree *t = a->tree;
 587         struct filesystem *cf = t->current_filesystem;
 588         size_t asize;
 589         size_t s;
 590
 591         if (cf->allocation_ptr == NULL) {
 592                 /* If we couldn't get a filesystem alignment,
 593                  * we use 4096 as default value but we won't use
 594                  * O_DIRECT to open() and openat() operations. */
 595                 long xfer_align = (cf->xfer_align == -1)?4096:cf->xfer_align;
 596
 597                 if (cf->max_xfer_size != -1)
 598                         asize = cf->max_xfer_size + xfer_align;
 599                 else {
 600                         long incr = cf->incr_xfer_size;
 601                         /* Some platform does not set a proper value to
 602                          * incr_xfer_size.*/
 603                         if (incr < 0)
 604                                 incr = cf->min_xfer_size;
 605                         if (cf->min_xfer_size < 0) {
 606                                 incr = xfer_align;
 607                                 asize = xfer_align;
 608                         } else
 609                                 asize = cf->min_xfer_size;
 610
 611                         /* Increase a buffer size up to 64K bytes in
 612                          * a proper incremant size. */
 613                         while (asize < 1024*64)
 614                                 asize += incr;
 615                         /* Take a margin to adjust to the filesystem
 616                          * alignment. */
 617                         asize += xfer_align;
 618                 }
 619                 cf->allocation_ptr = malloc(asize);
 620                 if (cf->allocation_ptr == NULL) {
 621                         archive_set_error(&a->archive, ENOMEM,
 622                             "Couldn't allocate memory");
 623                         a->archive.state = ARCHIVE_STATE_FATAL;
 624                         return (ARCHIVE_FATAL);
 625                 }
 626
 627                 /*
 628                  * Calculate proper address for the filesystem.
 629                  */
 630                 s = (uintptr_t)cf->allocation_ptr;
 631                 s %= xfer_align;
 632                 if (s > 0)
 633                         s = xfer_align - s;
 634
 635                 /*
 636                  * Set a read buffer pointer in the proper alignment of
 637                  * the current filesystem.
 638                  */
 639                 cf->buff = cf->allocation_ptr + s;
 640                 cf->buff_size = asize - xfer_align;
 641         }
 642         return (ARCHIVE_OK);
 643 }
 644
 645 static int
 646 _archive_read_data_block(struct archive *_a, const void **buff,
 647     size_t *size, int64_t *offset)
 648 {
 649         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 650         struct tree *t = a->tree;
 651         int r;
 652         ssize_t bytes;
 653         size_t buffbytes;
 654
 655         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,
 656             "archive_read_data_block");
 657
 658         if (t->entry_eof || t->entry_remaining_bytes <= 0) {
 659                 r = ARCHIVE_EOF;
 660                 goto abort_read_data;
 661         }
 662
 663         /*
 664          * Open the current file.
 665          */
 666         if (t->entry_fd < 0) {
 667                 int flags = O_RDONLY | O_BINARY;
 668
 669                 /*
 670                  * Eliminate or reduce cache effects if we can.
 671                  *
 672                  * Carefully consider this to be enabled.
 673                  */
 674 #if defined(O_DIRECT) && 0/* Disabled for now */
 675                 if (t->current_filesystem->xfer_align != -1 &&
 676                     t->nlink == 1)
 677                         flags |= O_DIRECT;
 678 #endif
 679 #if defined(O_NOATIME)
 680                 /*
 681                  * Linux has O_NOATIME flag; use it if we need.
 682                  */
 683                 if ((t->flags & needsRestoreTimes) != 0 &&
 684                     t->restore_time.noatime == 0)
 685                         flags |= O_NOATIME;
 686                 do {
 687 #endif
 688 #ifdef HAVE_OPENAT
 689                         t->entry_fd = openat(tree_current_dir_fd(t),
 690                             tree_current_access_path(t), flags);
 691 #else
 692                         tree_enter_working_dir(t);
 693                         t->entry_fd = open(tree_current_access_path(t), flags);
 694 #endif
 695 #if defined(O_NOATIME)
 696                         /*
 697                          * When we did open the file with O_NOATIME flag,
 698                          * if successful, set 1 to t->restore_time.noatime
 699                          * not to restore an atime of the file later.
 700                          * if failed by EPERM, retry it without O_NOATIME flag.
 701                          */
 702                         if (flags & O_NOATIME) {
 703                                 if (t->entry_fd >= 0)
 704                                         t->restore_time.noatime = 1;
 705                                 else if (errno == EPERM) {
 706                                         flags &= ~O_NOATIME;
 707                                         continue;
 708                                 }
 709                         }
 710                 } while (0);
 711 #endif
 712                 if (t->entry_fd < 0) {
 713                         archive_set_error(&a->archive, errno,
 714                             "Couldn't open %s", tree_current_path(t));
 715                         r = ARCHIVE_FAILED;
 716                         tree_enter_initial_dir(t);
 717                         goto abort_read_data;
 718                 }
 719                 tree_enter_initial_dir(t);
 720         }
 721
 722         /*
 723          * Allocate read buffer if not allocated.
 724          */
 725         if (t->current_filesystem->allocation_ptr == NULL) {
 726                 r = setup_suitable_read_buffer(a);
 727                 if (r != ARCHIVE_OK) {
 728                         a->archive.state = ARCHIVE_STATE_FATAL;
 729                         goto abort_read_data;
 730                 }
 731         }
 732         t->entry_buff = t->current_filesystem->buff;
 733         t->entry_buff_size = t->current_filesystem->buff_size;
 734
 735         buffbytes = t->entry_buff_size;
 736         if (buffbytes > t->current_sparse->length)
 737                 buffbytes = t->current_sparse->length;
 738
 739         /*
 740          * Skip hole.
 741          * TODO: Should we consider t->current_filesystem->xfer_align?
 742          */
 743         if (t->current_sparse->offset > t->entry_total) {
 744                 if (lseek(t->entry_fd,
 745                     (off_t)t->current_sparse->offset, SEEK_SET) < 0) {
 746                         archive_set_error(&a->archive, errno, "Seek error");
 747                         r = ARCHIVE_FATAL;
 748                         a->archive.state = ARCHIVE_STATE_FATAL;
 749                         goto abort_read_data;
 750                 }
 751                 bytes = t->current_sparse->offset - t->entry_total;
 752                 t->entry_remaining_bytes -= bytes;
 753                 t->entry_total += bytes;
 754         }
 755
 756         /*
 757          * Read file contents.
 758          */
 759         if (buffbytes > 0) {
 760                 bytes = read(t->entry_fd, t->entry_buff, buffbytes);
 761                 if (bytes < 0) {
 762                         archive_set_error(&a->archive, errno, "Read error");
 763                         r = ARCHIVE_FATAL;
 764                         a->archive.state = ARCHIVE_STATE_FATAL;
 765                         goto abort_read_data;
 766                 }
 767         } else
 768                 bytes = 0;
 769         if (bytes == 0) {
 770                 /* Get EOF */
 771                 t->entry_eof = 1;
 772                 r = ARCHIVE_EOF;
 773                 goto abort_read_data;
 774         }
 775         *buff = t->entry_buff;
 776         *size = bytes;
 777         *offset = t->entry_total;
 778         t->entry_total += bytes;
 779         t->entry_remaining_bytes -= bytes;
 780         if (t->entry_remaining_bytes == 0) {
 781                 /* Close the current file descriptor */
 782                 close_and_restore_time(t->entry_fd, t, &t->restore_time);
 783                 t->entry_fd = -1;
 784                 t->entry_eof = 1;
 785         }
 786         t->current_sparse->offset += bytes;
 787         t->current_sparse->length -= bytes;
 788         if (t->current_sparse->length == 0 && !t->entry_eof)
 789                 t->current_sparse++;
 790         return (ARCHIVE_OK);
 791
 792 abort_read_data:
 793         *buff = NULL;
 794         *size = 0;
 795         *offset = t->entry_total;
 796         if (t->entry_fd >= 0) {
 797                 /* Close the current file descriptor */
 798                 close_and_restore_time(t->entry_fd, t, &t->restore_time);
 799                 t->entry_fd = -1;
 800         }
 801         return (r);
 802 }
 803
 804 static int
 805 _archive_read_next_header2(struct archive *_a, struct archive_entry *entry)
 806 {
 807         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 808         struct tree *t;
 809         const struct stat *st; /* info to use for this entry */
 810         const struct stat *lst;/* lstat() information */
 811         int descend, fd = -1, r;
 812
 813         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 814             ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
 815             "archive_read_next_header2");
 816
 817         t = a->tree;
 818         if (t->entry_fd >= 0) {
 819                 close_and_restore_time(t->entry_fd, t, &t->restore_time);
 820                 t->entry_fd = -1;
 821         }
 822 #if !(defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_FDOPENDIR))
 823         /* Restore working directory. */
 824         tree_enter_working_dir(t);
 825 #endif
 826         st = NULL;
 827         lst = NULL;
 828         do {
 829                 switch (tree_next(t)) {
 830                 case TREE_ERROR_FATAL:
 831                         archive_set_error(&a->archive, t->tree_errno,
 832                             "%s: Unable to continue traversing directory tree",
 833                             tree_current_path(t));
 834                         a->archive.state = ARCHIVE_STATE_FATAL;
 835                         tree_enter_initial_dir(t);
 836                         return (ARCHIVE_FATAL);
 837                 case TREE_ERROR_DIR:
 838                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 839                             "%s: Couldn't visit directory",
 840                             tree_current_path(t));
 841                         tree_enter_initial_dir(t);
 842                         return (ARCHIVE_FAILED);
 843                 case 0:
 844                         tree_enter_initial_dir(t);
 845                         return (ARCHIVE_EOF);
 846                 case TREE_POSTDESCENT:
 847                 case TREE_POSTASCENT:
 848                         break;
 849                 case TREE_REGULAR:
 850                         lst = tree_current_lstat(t);
 851                         if (lst == NULL) {
 852                                 archive_set_error(&a->archive, errno,
 853                                     "%s: Cannot stat",
 854                                     tree_current_path(t));
 855                                 tree_enter_initial_dir(t);
 856                                 return (ARCHIVE_FAILED);
 857                         }
 858                         break;
 859                 }
 860         } while (lst == NULL);
 861
 862         /*
 863          * Distinguish 'L'/'P'/'H' symlink following.
 864          */
 865         switch(t->symlink_mode) {
 866         case 'H':
 867                 /* 'H': After the first item, rest like 'P'. */
 868                 t->symlink_mode = 'P';
 869                 /* 'H': First item (from command line) like 'L'. */
 870                 /* FALLTHROUGH */
 871         case 'L':
 872                 /* 'L': Do descend through a symlink to dir. */
 873                 descend = tree_current_is_dir(t);
 874                 /* 'L': Follow symlinks to files. */
 875                 a->symlink_mode = 'L';
 876                 a->follow_symlinks = 1;
 877                 /* 'L': Archive symlinks as targets, if we can. */
 878                 st = tree_current_stat(t);
 879                 if (st != NULL && !tree_target_is_same_as_parent(t, st))
 880                         break;
 881                 /* If stat fails, we have a broken symlink;
 882                  * in that case, don't follow the link. */
 883                 /* FALLTHROUGH */
 884         default:
 885                 /* 'P': Don't descend through a symlink to dir. */
 886                 descend = tree_current_is_physical_dir(t);
 887                 /* 'P': Don't follow symlinks to files. */
 888                 a->symlink_mode = 'P';
 889                 a->follow_symlinks = 0;
 890                 /* 'P': Archive symlinks as symlinks. */
 891                 st = lst;
 892                 break;
 893         }
 894
 895         if (update_current_filesystem(a, st->st_dev) != ARCHIVE_OK) {
 896                 a->archive.state = ARCHIVE_STATE_FATAL;
 897                 tree_enter_initial_dir(t);
 898                 return (ARCHIVE_FATAL);
 899         }
 900         t->descend = descend;
 901
 902         archive_entry_set_pathname(entry, tree_current_path(t));
 903         archive_entry_copy_sourcepath(entry, tree_current_access_path(t));
 904         archive_entry_copy_stat(entry, st);
 905
 906         /* Save the times to be restored. */
 907         t->restore_time.mtime = archive_entry_mtime(entry);
 908         t->restore_time.mtime_nsec = archive_entry_mtime_nsec(entry);
 909         t->restore_time.atime = archive_entry_atime(entry);
 910         t->restore_time.atime_nsec = archive_entry_atime_nsec(entry);
 911         t->restore_time.filetype = archive_entry_filetype(entry);
 912         t->restore_time.noatime = t->current_filesystem->noatime;
 913
 914 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_FDOPENDIR)
 915         /*
 916          * Open the current file to freely gather its metadata anywhere in
 917          * working directory.
 918          * Note: A symbolic link file cannot be opened with O_NOFOLLOW.
 919          */
 920         if (a->follow_symlinks || archive_entry_filetype(entry) != AE_IFLNK)
 921                 fd = openat(tree_current_dir_fd(t), tree_current_access_path(t),
 922                     O_RDONLY | O_NONBLOCK);
 923         /* Restore working directory if openat() operation failed or
 924          * the file is a symbolic link. */
 925         if (fd < 0)
 926                 tree_enter_working_dir(t);
 927
 928         /* The current direcotry fd is needed at
 929          * archive_read_disk_entry_from_file() function to read link data
 930          * with readlinkat(). */
 931         a->entry_wd_fd = tree_current_dir_fd(t);
 932 #endif
 933
 934         /*
 935          * Populate the archive_entry with metadata from the disk.
 936          */
 937         r = archive_read_disk_entry_from_file(&(a->archive), entry, fd, st);
 938
 939         /* Close the file descriptor used for reding the current file
 940          * metadata at archive_read_disk_entry_from_file(). */
 941         if (fd >= 0)
 942                 close(fd);
 943
 944         /* Return to the initial directory. */
 945         tree_enter_initial_dir(t);
 946         archive_entry_copy_sourcepath(entry, tree_current_path(t));
 947
 948         /*
 949          * EOF and FATAL are persistent at this layer.  By
 950          * modifying the state, we guarantee that future calls to
 951          * read a header or read data will fail.
 952          */
 953         switch (r) {
 954         case ARCHIVE_EOF:
 955                 a->archive.state = ARCHIVE_STATE_EOF;
 956                 break;
 957         case ARCHIVE_OK:
 958         case ARCHIVE_WARN:
 959                 t->entry_total = 0;
 960                 if (archive_entry_filetype(entry) == AE_IFREG) {
 961                         t->nlink = archive_entry_nlink(entry);
 962                         t->entry_remaining_bytes = archive_entry_size(entry);
 963                         t->entry_eof = (t->entry_remaining_bytes == 0)? 1: 0;
 964                         if (!t->entry_eof &&
 965                             setup_sparse(a, entry) != ARCHIVE_OK)
 966                                 return (ARCHIVE_FATAL);
 967                 } else {
 968                         t->entry_remaining_bytes = 0;
 969                         t->entry_eof = 1;
 970                 }
 971                 a->archive.state = ARCHIVE_STATE_DATA;
 972                 break;
 973         case ARCHIVE_RETRY:
 974                 break;
 975         case ARCHIVE_FATAL:
 976                 a->archive.state = ARCHIVE_STATE_FATAL;
 977                 break;
 978         }
 979
 980         return (r);
 981 }
 982
 983 static int
 984 setup_sparse(struct archive_read_disk *a, struct archive_entry *entry)
 985 {
 986         struct tree *t = a->tree;
 987         int64_t length, offset;
 988         int i;
 989
 990         t->sparse_count = archive_entry_sparse_reset(entry);
 991         if (t->sparse_count+1 > t->sparse_list_size) {
 992                 free(t->sparse_list);
 993                 t->sparse_list_size = t->sparse_count + 1;
 994                 t->sparse_list = malloc(sizeof(t->sparse_list[0]) *
 995                     t->sparse_list_size);
 996                 if (t->sparse_list == NULL) {
 997                         t->sparse_list_size = 0;
 998                         archive_set_error(&a->archive, ENOMEM,
 999                             "Can't allocate data");
1000                         a->archive.state = ARCHIVE_STATE_FATAL;
1001                         return (ARCHIVE_FATAL);
1002                 }
1003         }
1004         for (i = 0; i < t->sparse_count; i++) {
1005                 archive_entry_sparse_next(entry, &offset, &length);
1006                 t->sparse_list[i].offset = offset;
1007                 t->sparse_list[i].length = length;
1008         }
1009         if (i == 0) {
1010                 t->sparse_list[i].offset = 0;
1011                 t->sparse_list[i].length = archive_entry_size(entry);
1012         } else {
1013                 t->sparse_list[i].offset = archive_entry_size(entry);
1014                 t->sparse_list[i].length = 0;
1015         }
1016         t->current_sparse = t->sparse_list;
1017
1018         return (ARCHIVE_OK);
1019 }
1020
1021 /*
1022  * Called by the client to mark the directory just returned from
1023  * tree_next() as needing to be visited.
1024  */
1025 int
1026 archive_read_disk_descend(struct archive *_a)
1027 {
1028         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1029         struct tree *t = a->tree;
1030
1031         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,
1032             "archive_read_disk_descend");
1033
1034         if (t->visit_type != TREE_REGULAR || !t->descend) {
1035                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1036                     "Ignored the request descending the current object");
1037                 return (ARCHIVE_WARN);
1038         }
1039
1040         if (tree_current_is_physical_dir(t)) {
1041                 tree_push(t, t->basename, t->current_filesystem_id,
1042                     t->lst.st_dev, t->lst.st_ino, &t->restore_time);
1043                 t->stack->flags |= isDir;
1044         } else if (tree_current_is_dir(t)) {
1045                 tree_push(t, t->basename, t->current_filesystem_id,
1046                     t->st.st_dev, t->st.st_ino, &t->restore_time);
1047                 t->stack->flags |= isDirLink;
1048         }
1049         t->descend = 0;
1050         return (ARCHIVE_OK);
1051 }
1052
1053 int
1054 archive_read_disk_open(struct archive *_a, const char *pathname)
1055 {
1056         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1057
1058         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
1059             ARCHIVE_STATE_NEW | ARCHIVE_STATE_CLOSED,
1060             "archive_read_disk_open");
1061         archive_clear_error(&a->archive);
1062
1063         return (_archive_read_disk_open(_a, pathname));
1064 }
1065
1066 int
1067 archive_read_disk_open_w(struct archive *_a, const wchar_t *pathname)
1068 {
1069         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1070         struct archive_string path;
1071         int ret;
1072
1073         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
1074             ARCHIVE_STATE_NEW | ARCHIVE_STATE_CLOSED,
1075             "archive_read_disk_open_w");
1076         archive_clear_error(&a->archive);
1077
1078         /* Make a char string from a wchar_t string. */
1079         archive_string_init(&path);
1080         if (archive_string_append_from_wcs(&path, pathname,
1081             wcslen(pathname)) != 0) {
1082                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1083                     "Can't convert a path to a char string");
1084                 a->archive.state = ARCHIVE_STATE_FATAL;
1085                 ret = ARCHIVE_FATAL;
1086         } else
1087                 ret = _archive_read_disk_open(_a, path.s);
1088
1089         archive_string_free(&path);
1090         return (ret);
1091 }
1092
1093 static int
1094 _archive_read_disk_open(struct archive *_a, const char *pathname)
1095 {
1096         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1097
1098         if (a->tree != NULL)
1099                 a->tree = tree_reopen(a->tree, pathname, a->restore_time);
1100         else
1101                 a->tree = tree_open(pathname, a->symlink_mode,
1102                     a->restore_time);
1103         if (a->tree == NULL) {
1104                 archive_set_error(&a->archive, ENOMEM,
1105                     "Can't allocate tar data");
1106                 a->archive.state = ARCHIVE_STATE_FATAL;
1107                 return (ARCHIVE_FATAL);
1108         }
1109         a->archive.state = ARCHIVE_STATE_HEADER;
1110
1111         return (ARCHIVE_OK);
1112 }
1113
1114 /*
1115  * Return a current filesystem ID which is index of the filesystem entry
1116  * you've visited through archive_read_disk.
1117  */
1118 int
1119 archive_read_disk_current_filesystem(struct archive *_a)
1120 {
1121         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1122
1123         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,
1124             "archive_read_disk_current_filesystem");
1125
1126         return (a->tree->current_filesystem_id);
1127 }
1128
1129 static int
1130 update_current_filesystem(struct archive_read_disk *a, int64_t dev)
1131 {
1132         struct tree *t = a->tree;
1133         int i, fid;
1134
1135         if (t->current_filesystem != NULL &&
1136             t->current_filesystem->dev == dev)
1137                 return (ARCHIVE_OK);
1138
1139         for (i = 0; i < t->max_filesystem_id; i++) {
1140                 if (t->filesystem_table[i].dev == dev) {
1141                         /* There is the filesytem ID we've already generated. */
1142                         t->current_filesystem_id = i;
1143                         t->current_filesystem = &(t->filesystem_table[i]);
1144                         return (ARCHIVE_OK);
1145                 }
1146         }
1147
1148         /*
1149          * This is the new filesytem which we have to generate a new ID for.
1150          */
1151         fid = t->max_filesystem_id++;
1152         if (t->max_filesystem_id > t->allocated_filesytem) {
1153                 size_t s;
1154
1155                 s = t->max_filesystem_id * 2;
1156                 t->filesystem_table = realloc(t->filesystem_table,
1157                     s * sizeof(*t->filesystem_table));
1158                 if (t->filesystem_table == NULL) {
1159                         archive_set_error(&a->archive, ENOMEM,
1160                             "Can't allocate tar data");
1161                         return (ARCHIVE_FATAL);
1162                 }
1163                 t->allocated_filesytem = s;
1164         }
1165         t->current_filesystem_id = fid;
1166         t->current_filesystem = &(t->filesystem_table[fid]);
1167         t->current_filesystem->dev = dev;
1168         t->current_filesystem->allocation_ptr = NULL;
1169         t->current_filesystem->buff = NULL;
1170
1171         /* Setup the current filesystem properties which depend on
1172          * platform specific. */
1173         return (setup_current_filesystem(a));
1174 }
1175
1176 /*
1177  * Returns 1 if current filesystem is generated filesystem, 0 if it is not
1178  * or -1 if it is unknown.
1179  */
1180 int
1181 archive_read_disk_current_filesystem_is_synthetic(struct archive *_a)
1182 {
1183         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1184
1185         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,
1186             "archive_read_disk_current_filesystem");
1187
1188         return (a->tree->current_filesystem->synthetic);
1189 }
1190
1191 /*
1192  * Returns 1 if current filesystem is remote filesystem, 0 if it is not
1193  * or -1 if it is unknown.
1194  */
1195 int
1196 archive_read_disk_current_filesystem_is_remote(struct archive *_a)
1197 {
1198         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1199
1200         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,
1201             "archive_read_disk_current_filesystem");
1202
1203         return (a->tree->current_filesystem->remote);
1204 }
1205
1206 #if defined(_PC_REC_INCR_XFER_SIZE) && defined(_PC_REC_MAX_XFER_SIZE) &&\
1207         defined(_PC_REC_MIN_XFER_SIZE) && defined(_PC_REC_XFER_ALIGN)
1208 static int
1209 get_xfer_size(struct tree *t, int fd, const char *path)
1210 {
1211         t->current_filesystem->xfer_align = -1;
1212         errno = 0;
1213         if (fd >= 0) {
1214                 t->current_filesystem->incr_xfer_size =
1215                     fpathconf(fd, _PC_REC_INCR_XFER_SIZE);
1216                 t->current_filesystem->max_xfer_size =
1217                     fpathconf(fd, _PC_REC_MAX_XFER_SIZE);
1218                 t->current_filesystem->min_xfer_size =
1219                     fpathconf(fd, _PC_REC_MIN_XFER_SIZE);
1220                 t->current_filesystem->xfer_align =
1221                     fpathconf(fd, _PC_REC_XFER_ALIGN);
1222         } else if (path != NULL) {
1223                 t->current_filesystem->incr_xfer_size =
1224                     pathconf(path, _PC_REC_INCR_XFER_SIZE);
1225                 t->current_filesystem->max_xfer_size =
1226                     pathconf(path, _PC_REC_MAX_XFER_SIZE);
1227                 t->current_filesystem->min_xfer_size =
1228                     pathconf(path, _PC_REC_MIN_XFER_SIZE);
1229                 t->current_filesystem->xfer_align =
1230                     pathconf(path, _PC_REC_XFER_ALIGN);
1231         }
1232         /* At least we need an alignment size. */
1233         if (t->current_filesystem->xfer_align == -1)
1234                 return ((errno == EINVAL)?1:-1);
1235         else
1236                 return (0);
1237 }
1238 #else
1239 static int
1240 get_xfer_size(struct tree *t, int fd, const char *path)
1241 {
1242         (void)t; /* UNUSED */
1243         (void)fd; /* UNUSED */
1244         (void)path; /* UNUSED */
1245         return (1);/* Not supported */
1246 }
1247 #endif
1248
1249 #if defined(HAVE_STATFS) && defined(HAVE_FSTATFS) && defined(MNT_LOCAL) \
1250         && !defined(ST_LOCAL)
1251
1252 /*
1253  * Gather current filesystem properties on FreeBSD, OpenBSD and Mac OS X.
1254  */
1255 static int
1256 setup_current_filesystem(struct archive_read_disk *a)
1257 {
1258         struct tree *t = a->tree;
1259         struct statfs sfs;
1260 #if defined(HAVE_GETVFSBYNAME) && defined(VFCF_SYNTHETIC)
1261         struct vfsconf vfc;
1262 #endif
1263         int r, xr = 0;
1264 #if !defined(HAVE_STRUCT_STATFS_F_NAMEMAX)
1265         long nm;
1266 #endif
1267
1268         t->current_filesystem->synthetic = -1;
1269         t->current_filesystem->remote = -1;
1270         if (tree_current_is_symblic_link_target(t)) {
1271 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_FDOPENDIR)
1272                 /*
1273                  * Get file system statistics on any directory
1274                  * where current is.
1275                  */
1276                 int fd = openat(tree_current_dir_fd(t),
1277                     tree_current_access_path(t), O_RDONLY);
1278                 if (fd < 0) {
1279                         archive_set_error(&a->archive, errno,
1280                             "openat failed");
1281                         return (ARCHIVE_FAILED);
1282                 }
1283                 r = fstatfs(fd, &sfs);
1284                 if (r == 0)
1285                         xr = get_xfer_size(t, fd, NULL);
1286                 close(fd);
1287 #else
1288                 r = statfs(tree_current_access_path(t), &sfs);
1289                 if (r == 0)
1290                         xr = get_xfer_size(t, -1, tree_current_access_path(t));
1291 #endif
1292         } else {
1293                 r = fstatfs(tree_current_dir_fd(t), &sfs);
1294                 if (r == 0)
1295                         xr = get_xfer_size(t, tree_current_dir_fd(t), NULL);
1296         }
1297         if (r == -1 || xr == -1) {
1298                 archive_set_error(&a->archive, errno, "statfs failed");
1299                 return (ARCHIVE_FAILED);
1300         } else if (xr == 1) {
1301                 /* pathconf(_PC_REX_*) operations are not supported. */
1302                 t->current_filesystem->xfer_align = sfs.f_bsize;
1303                 t->current_filesystem->max_xfer_size = -1;
1304                 t->current_filesystem->min_xfer_size = sfs.f_iosize;
1305                 t->current_filesystem->incr_xfer_size = sfs.f_iosize;
1306         }
1307         if (sfs.f_flags & MNT_LOCAL)
1308                 t->current_filesystem->remote = 0;
1309         else
1310                 t->current_filesystem->remote = 1;
1311
1312 #if defined(HAVE_GETVFSBYNAME) && defined(VFCF_SYNTHETIC)
1313         r = getvfsbyname(sfs.f_fstypename, &vfc);
1314         if (r == -1) {
1315                 archive_set_error(&a->archive, errno, "getvfsbyname failed");
1316                 return (ARCHIVE_FAILED);
1317         }
1318         if (vfc.vfc_flags & VFCF_SYNTHETIC)
1319                 t->current_filesystem->synthetic = 1;
1320         else
1321                 t->current_filesystem->synthetic = 0;
1322 #endif
1323
1324 #if defined(MNT_NOATIME)
1325         if (sfs.f_flags & MNT_NOATIME)
1326                 t->current_filesystem->noatime = 1;
1327         else
1328 #endif
1329                 t->current_filesystem->noatime = 0;
1330
1331 #if defined(HAVE_READDIR_R)
1332         /* Set maximum filename length. */
1333 #if defined(HAVE_STRUCT_STATFS_F_NAMEMAX)
1334         t->current_filesystem->name_max = sfs.f_namemax;
1335 #else
1336         /* Mac OS X does not have f_namemax in struct statfs. */
1337         if (tree_current_is_symblic_link_target(t))
1338                 nm = pathconf(tree_current_access_path(t), _PC_NAME_MAX);
1339         else
1340                 nm = fpathconf(tree_current_dir_fd(t), _PC_NAME_MAX);
1341         if (nm == -1)
1342                 t->current_filesystem->name_max = NAME_MAX;
1343         else
1344                 t->current_filesystem->name_max = nm;
1345 #endif
1346 #endif /* HAVE_READDIR_R */
1347         return (ARCHIVE_OK);
1348 }
1349
1350 #elif (defined(HAVE_STATVFS) || defined(HAVE_FSTATVFS)) && defined(ST_LOCAL)
1351
1352 /*
1353  * Gather current filesystem properties on NetBSD
1354  */
1355 static int
1356 setup_current_filesystem(struct archive_read_disk *a)
1357 {
1358         struct tree *t = a->tree;
1359         struct statvfs sfs;
1360         int r, xr = 0;
1361
1362         t->current_filesystem->synthetic = -1;
1363         if (tree_current_is_symblic_link_target(t)) {
1364                 r = statvfs(tree_current_access_path(t), &sfs);
1365                 if (r == 0)
1366                         xr = get_xfer_size(t, -1, tree_current_access_path(t));
1367         } else {
1368 #ifdef HAVE_FSTATVFS
1369                 r = fstatvfs(tree_current_dir_fd(t), &sfs);
1370                 if (r == 0)
1371                         xr = get_xfer_size(t, tree_current_dir_fd(t), NULL);
1372 #else
1373                 r = statvfs(".", &sfs);
1374                 if (r == 0)
1375                         xr = get_xfer_size(t, -1, ".");
1376 #endif
1377         }
1378         if (r == -1 || xr == -1) {
1379                 t->current_filesystem->remote = -1;
1380                 archive_set_error(&a->archive, errno, "statvfs failed");
1381                 return (ARCHIVE_FAILED);
1382         } else if (xr == 1) {
1383                 /* Usuall come here unless NetBSD supports _PC_REC_XFER_ALIGN
1384                  * for pathconf() function. */
1385                 t->current_filesystem->xfer_align = sfs.f_frsize;
1386                 t->current_filesystem->max_xfer_size = -1;
1387                 t->current_filesystem->min_xfer_size = sfs.f_iosize;
1388                 t->current_filesystem->incr_xfer_size = sfs.f_iosize;
1389         }
1390         if (sfs.f_flag & ST_LOCAL)
1391                 t->current_filesystem->remote = 0;
1392         else
1393                 t->current_filesystem->remote = 1;
1394
1395         if (sfs.f_flag & ST_NOATIME)
1396                 t->current_filesystem->noatime = 1;
1397         else
1398                 t->current_filesystem->noatime = 0;
1399
1400         /* Set maximum filename length. */
1401         t->current_filesystem->name_max = sfs.f_namemax;
1402         return (ARCHIVE_OK);
1403 }
1404
1405 #elif defined(HAVE_SYS_STATFS_H) && defined(HAVE_LINUX_MAGIC_H) &&\
1406         defined(HAVE_STATFS) && defined(HAVE_FSTATFS)
1407 /*
1408  * Note: statfs is deprecated since LSB 3.2
1409  */
1410
1411 #ifndef CIFS_SUPER_MAGIC
1412 #define CIFS_SUPER_MAGIC 0xFF534D42
1413 #endif
1414 #ifndef DEVFS_SUPER_MAGIC
1415 #define DEVFS_SUPER_MAGIC 0x1373
1416 #endif
1417
1418 /*
1419  * Gather current filesystem properties on Linux
1420  */
1421 static int
1422 setup_current_filesystem(struct archive_read_disk *a)
1423 {
1424         struct tree *t = a->tree;
1425         struct statfs sfs;
1426         struct statvfs svfs;
1427         int r, vr = 0, xr = 0;
1428
1429         if (tree_current_is_symblic_link_target(t)) {
1430 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_FDOPENDIR)
1431                 /*
1432                  * Get file system statistics on any directory
1433                  * where current is.
1434                  */
1435                 int fd = openat(tree_current_dir_fd(t),
1436                     tree_current_access_path(t), O_RDONLY);
1437                 if (fd < 0) {
1438                         archive_set_error(&a->archive, errno,
1439                             "openat failed");
1440                         return (ARCHIVE_FAILED);
1441                 }
1442                 vr = fstatvfs(fd, &svfs);/* for f_flag, mount flags */
1443                 r = fstatfs(fd, &sfs);
1444                 if (r == 0)
1445                         xr = get_xfer_size(t, fd, NULL);
1446                 close(fd);
1447 #else
1448                 vr = statvfs(tree_current_access_path(t), &svfs);
1449                 r = statfs(tree_current_access_path(t), &sfs);
1450                 if (r == 0)
1451                         xr = get_xfer_size(t, -1, tree_current_access_path(t));
1452 #endif
1453         } else {
1454 #ifdef HAVE_FSTATFS
1455                 vr = fstatvfs(tree_current_dir_fd(t), &svfs);
1456                 r = fstatfs(tree_current_dir_fd(t), &sfs);
1457                 if (r == 0)
1458                         xr = get_xfer_size(t, tree_current_dir_fd(t), NULL);
1459 #elif defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_FDOPENDIR)
1460 #error "Unexpected case. Please tell us about this error."
1461 #else
1462                 vr = statvfs(".", &svfs);
1463                 r = statfs(".", &sfs);
1464                 if (r == 0)
1465                         xr = get_xfer_size(t, -1, ".");
1466 #endif
1467         }
1468         if (r == -1 || xr == -1 || vr == -1) {
1469                 t->current_filesystem->synthetic = -1;
1470                 t->current_filesystem->remote = -1;
1471                 archive_set_error(&a->archive, errno, "statfs failed");
1472                 return (ARCHIVE_FAILED);
1473         } else if (xr == 1) {
1474                 /* pathconf(_PC_REX_*) operations are not supported. */
1475                 t->current_filesystem->xfer_align = svfs.f_frsize;
1476                 t->current_filesystem->max_xfer_size = -1;
1477                 t->current_filesystem->min_xfer_size = svfs.f_bsize;
1478                 t->current_filesystem->incr_xfer_size = svfs.f_bsize;
1479         }
1480         switch (sfs.f_type) {
1481         case AFS_SUPER_MAGIC:
1482         case CIFS_SUPER_MAGIC:
1483         case CODA_SUPER_MAGIC:
1484         case NCP_SUPER_MAGIC:/* NetWare */
1485         case NFS_SUPER_MAGIC:
1486         case SMB_SUPER_MAGIC:
1487                 t->current_filesystem->remote = 1;
1488                 t->current_filesystem->synthetic = 0;
1489                 break;
1490         case DEVFS_SUPER_MAGIC:
1491         case PROC_SUPER_MAGIC:
1492         case USBDEVICE_SUPER_MAGIC:
1493                 t->current_filesystem->remote = 0;
1494                 t->current_filesystem->synthetic = 1;
1495                 break;
1496         default:
1497                 t->current_filesystem->remote = 0;
1498                 t->current_filesystem->synthetic = 0;
1499                 break;
1500         }
1501
1502 #if defined(ST_NOATIME)
1503         if (svfs.f_flag & ST_NOATIME)
1504                 t->current_filesystem->noatime = 1;
1505         else
1506 #endif
1507                 t->current_filesystem->noatime = 0;
1508
1509 #if defined(HAVE_READDIR_R)
1510         /* Set maximum filename length. */
1511         t->current_filesystem->name_max = sfs.f_namelen;
1512 #endif
1513         return (ARCHIVE_OK);
1514 }
1515
1516 #elif defined(HAVE_SYS_STATVFS_H) &&\
1517         (defined(HAVE_STATVFS) || defined(HAVE_FSTATVFS))
1518
1519 /*
1520  * Gather current filesystem properties on other posix platform.
1521  */
1522 static int
1523 setup_current_filesystem(struct archive_read_disk *a)
1524 {
1525         struct tree *t = a->tree;
1526         struct statvfs sfs;
1527         int r, xr = 0;
1528
1529         t->current_filesystem->synthetic = -1;/* Not supported */
1530         t->current_filesystem->remote = -1;/* Not supported */
1531         if (tree_current_is_symblic_link_target(t)) {
1532 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_FDOPENDIR)
1533                 /*
1534                  * Get file system statistics on any directory
1535                  * where current is.
1536                  */
1537                 int fd = openat(tree_current_dir_fd(t),
1538                     tree_current_access_path(t), O_RDONLY);
1539                 if (fd < 0) {
1540                         archive_set_error(&a->archive, errno,
1541                             "openat failed");
1542                         return (ARCHIVE_FAILED);
1543                 }
1544                 r = fstatvfs(fd, &sfs);
1545                 if (r == 0)
1546                         xr = get_xfer_size(t, fd, NULL);
1547                 close(fd);
1548 #else
1549                 r = statvfs(tree_current_access_path(t), &sfs);
1550                 if (r == 0)
1551                         xr = get_xfer_size(t, -1, tree_current_access_path(t));
1552 #endif
1553         } else {
1554 #ifdef HAVE_FSTATVFS
1555                 r = fstatvfs(tree_current_dir_fd(t), &sfs);
1556                 if (r == 0)
1557                         xr = get_xfer_size(t, tree_current_dir_fd(t), NULL);
1558 #elif defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_FDOPENDIR)
1559 #error "Unexpected case. Please tell us about this error."
1560 #else
1561                 r = statvfs(".", &sfs);
1562                 if (r == 0)
1563                         xr = get_xfer_size(t, -1, ".");
1564 #endif
1565         }
1566         if (r == -1 || xr == -1) {
1567                 t->current_filesystem->synthetic = -1;
1568                 t->current_filesystem->remote = -1;
1569                 archive_set_error(&a->archive, errno, "statvfs failed");
1570                 return (ARCHIVE_FAILED);
1571         } else if (xr == 1) {
1572                 /* pathconf(_PC_REX_*) operations are not supported. */
1573                 t->current_filesystem->xfer_align = sfs.f_frsize;
1574                 t->current_filesystem->max_xfer_size = -1;
1575                 t->current_filesystem->min_xfer_size = sfs.f_bsize;
1576                 t->current_filesystem->incr_xfer_size = sfs.f_bsize;
1577         }
1578
1579 #if defined(ST_NOATIME)
1580         if (sfs.f_flag & ST_NOATIME)
1581                 t->current_filesystem->noatime = 1;
1582         else
1583 #endif
1584                 t->current_filesystem->noatime = 0;
1585
1586 #if defined(HAVE_READDIR_R)
1587         /* Set maximum filename length. */
1588         t->current_filesystem->name_max = sfs.f_namemax;
1589 #endif
1590         return (ARCHIVE_OK);
1591 }
1592
1593 #else
1594
1595 /*
1596  * Generic: Gather current filesystem properties.
1597  * TODO: Is this generic function really needed?
1598  */
1599 static int
1600 setup_current_filesystem(struct archive_read_disk *a)
1601 {
1602         struct tree *t = a->tree;
1603 #if defined(_PC_NAME_MAX) && defined(HAVE_READDIR_R)
1604         long nm;
1605 #endif
1606         t->current_filesystem->synthetic = -1;/* Not supported */
1607         t->current_filesystem->remote = -1;/* Not supported */
1608         t->current_filesystem->noatime = 0;
1609         (void)get_xfer_size(t, -1, ".");/* Dummy call to avoid build error. */
1610         t->current_filesystem->xfer_align = -1;/* Unknown */
1611         t->current_filesystem->max_xfer_size = -1;
1612         t->current_filesystem->min_xfer_size = -1;
1613         t->current_filesystem->incr_xfer_size = -1;
1614
1615 #if defined(HAVE_READDIR_R)
1616         /* Set maximum filename length. */
1617 #  if defined(_PC_NAME_MAX)
1618         if (tree_current_is_symblic_link_target(t))
1619                 nm = pathconf(tree_current_access_path(t), _PC_NAME_MAX);
1620         else
1621                 nm = fpathconf(tree_current_dir_fd(t), _PC_NAME_MAX);
1622         if (nm == -1)
1623 #  endif /* _PC_NAME_MAX */
1624                 /*
1625                  * Some sysmtes (HP-UX or others?) incorrectly defined
1626                  * NAME_MAX macro to be a smaller value.
1627                  */
1628 #  if defined(NAME_MAX) && NAME_MAX >= 255
1629                 t->current_filesystem->name_max = NAME_MAX;
1630 #  else
1631                 /* No way to get a trusted value of maximum filename
1632                  * length. */
1633                 t->current_filesystem->name_max = PATH_MAX;
1634 #  endif /* NAME_MAX */
1635 #  if defined(_PC_NAME_MAX)
1636         else
1637                 t->current_filesystem->name_max = nm;
1638 #  endif /* _PC_NAME_MAX */
1639 #endif /* HAVE_READDIR_R */
1640         return (ARCHIVE_OK);
1641 }
1642
1643 #endif
1644
1645 static int
1646 close_and_restore_time(int fd, struct tree *t, struct restore_time *rt)
1647 {
1648 #ifndef HAVE_UTIMES
1649         (void)a; /* UNUSED */
1650         return (close(fd));
1651 #else
1652 #if defined(HAVE_FUTIMENS) && !defined(__CYGWIN__)
1653         struct timespec timespecs[2];
1654 #endif
1655         struct timeval times[2];
1656
1657         if ((t->flags & needsRestoreTimes) == 0 || rt->noatime) {
1658                 if (fd >= 0)
1659                         return (close(fd));
1660                 else
1661                         return (0);
1662         }
1663
1664 #if defined(HAVE_FUTIMENS) && !defined(__CYGWIN__)
1665         timespecs[1].tv_sec = rt->mtime;
1666         timespecs[1].tv_nsec = rt->mtime_nsec;
1667
1668         timespecs[0].tv_sec = rt->atime;
1669         timespecs[0].tv_nsec = rt->atime_nsec;
1670         /* futimens() is defined in POSIX.1-2008. */
1671         if (futimens(fd, timespecs) == 0)
1672                 return (close(fd));
1673 #endif
1674
1675         times[1].tv_sec = rt->mtime;
1676         times[1].tv_usec = rt->mtime_nsec / 1000;
1677
1678         times[0].tv_sec = rt->atime;
1679         times[0].tv_usec = rt->atime_nsec / 1000;
1680
1681 #if !defined(HAVE_FUTIMENS) && defined(HAVE_FUTIMES) && !defined(__CYGWIN__)
1682         if (futimes(fd, times) == 0)
1683                 return (close(fd));
1684 #endif
1685         close(fd);
1686 #if defined(HAVE_FUTIMESAT)
1687         if (futimesat(tree_current_dir_fd(t), rt->name, times) == 0)
1688                 return (0);
1689 #endif
1690 #ifdef HAVE_LUTIMES
1691         if (lutimes(rt->name, times) != 0)
1692 #else
1693         if (AE_IFLNK != rt->filetype && utimes(rt->name, times) != 0)
1694 #endif
1695                 return (-1);
1696 #endif
1697         return (0);
1698 }
1699
1700 /*
1701  * Add a directory path to the current stack.
1702  */
1703 static void
1704 tree_push(struct tree *t, const char *path, int filesystem_id,
1705     int64_t dev, int64_t ino, struct restore_time *rt)
1706 {
1707         struct tree_entry *te;
1708
1709         te = malloc(sizeof(*te));
1710         memset(te, 0, sizeof(*te));
1711         te->next = t->stack;
1712         te->parent = t->current;
1713         if (te->parent)
1714                 te->depth = te->parent->depth + 1;
1715         t->stack = te;
1716         archive_string_init(&te->name);
1717         te->symlink_parent_fd = -1;
1718         archive_strcpy(&te->name, path);
1719         te->flags = needsDescent | needsOpen | needsAscent;
1720         te->filesystem_id = filesystem_id;
1721         te->dev = dev;
1722         te->ino = ino;
1723         te->dirname_length = t->dirname_length;
1724         te->restore_time.name = te->name.s;
1725         if (rt != NULL) {
1726                 te->restore_time.mtime = rt->mtime;
1727                 te->restore_time.mtime_nsec = rt->mtime_nsec;
1728                 te->restore_time.atime = rt->atime;
1729                 te->restore_time.atime_nsec = rt->atime_nsec;
1730                 te->restore_time.filetype = rt->filetype;
1731                 te->restore_time.noatime = rt->noatime;
1732         }
1733 }
1734
1735 /*
1736  * Append a name to the current dir path.
1737  */
1738 static void
1739 tree_append(struct tree *t, const char *name, size_t name_length)
1740 {
1741         size_t size_needed;
1742
1743         t->path.s[t->dirname_length] = '\0';
1744         t->path.length = t->dirname_length;
1745         /* Strip trailing '/' from name, unless entire name is "/". */
1746         while (name_length > 1 && name[name_length - 1] == '/')
1747                 name_length--;
1748
1749         /* Resize pathname buffer as needed. */
1750         size_needed = name_length + t->dirname_length + 2;
1751         archive_string_ensure(&t->path, size_needed);
1752         /* Add a separating '/' if it's needed. */
1753         if (t->dirname_length > 0 && t->path.s[archive_strlen(&t->path)-1] != '/')
1754                 archive_strappend_char(&t->path, '/');
1755         t->basename = t->path.s + archive_strlen(&t->path);
1756         archive_strncat(&t->path, name, name_length);
1757         t->restore_time.name = t->basename;
1758 }
1759
1760 /*
1761  * Open a directory tree for traversal.
1762  */
1763 static struct tree *
1764 tree_open(const char *path, int symlink_mode, int restore_time)
1765 {
1766         struct tree *t;
1767
1768         if ((t = malloc(sizeof(*t))) == NULL)
1769                 return (NULL);
1770         memset(t, 0, sizeof(*t));
1771         archive_string_init(&t->path);
1772         archive_string_ensure(&t->path, 31);
1773         t->initial_symlink_mode = symlink_mode;
1774         return (tree_reopen(t, path, restore_time));
1775 }
1776
1777 static struct tree *
1778 tree_reopen(struct tree *t, const char *path, int restore_time)
1779 {
1780         t->flags = (restore_time)?needsRestoreTimes:0;
1781         t->visit_type = 0;
1782         t->tree_errno = 0;
1783         t->dirname_length = 0;
1784         t->depth = 0;
1785         t->descend = 0;
1786         t->current = NULL;
1787         t->d = INVALID_DIR_HANDLE;
1788         t->symlink_mode = t->initial_symlink_mode;
1789         archive_string_empty(&t->path);
1790         t->entry_fd = -1;
1791         t->entry_eof = 0;
1792         t->entry_remaining_bytes = 0;
1793
1794         /* First item is set up a lot like a symlink traversal. */
1795         tree_push(t, path, 0, 0, 0, NULL);
1796         t->stack->flags = needsFirstVisit;
1797         t->maxOpenCount = t->openCount = 1;
1798         t->initial_dir_fd = open(".", O_RDONLY);
1799         t->working_dir_fd = dup(t->initial_dir_fd);
1800         return (t);
1801 }
1802
1803 static int
1804 tree_descent(struct tree *t)
1805 {
1806         int r = 0;
1807
1808 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_FDOPENDIR)
1809         int new_fd;
1810         t->dirname_length = archive_strlen(&t->path);
1811         new_fd = openat(t->working_dir_fd, t->stack->name.s, O_RDONLY);
1812         if (new_fd < 0) {
1813                 t->tree_errno = errno;
1814                 r = TREE_ERROR_DIR;
1815         } else {
1816                 t->depth++;
1817                 /* If it is a link, set up fd for the ascent. */
1818                 if (t->stack->flags & isDirLink) {
1819                         t->stack->symlink_parent_fd = t->working_dir_fd;
1820                         t->openCount++;
1821                         if (t->openCount > t->maxOpenCount)
1822                                 t->maxOpenCount = t->openCount;
1823                 } else
1824                         close(t->working_dir_fd);
1825                 t->working_dir_fd = new_fd;
1826         }
1827 #else
1828         /* If it is a link, set up fd for the ascent. */
1829         if (t->stack->flags & isDirLink)
1830                 t->stack->symlink_parent_fd = t->working_dir_fd;
1831         else {
1832                 close(t->working_dir_fd);
1833                 t->openCount--;
1834         }
1835         t->working_dir_fd = -1;
1836         t->dirname_length = archive_strlen(&t->path);
1837         if (chdir(t->stack->name.s) != 0)
1838         {
1839                 t->tree_errno = errno;
1840                 r = TREE_ERROR_DIR;
1841         } else {
1842                 t->depth++;
1843                 t->working_dir_fd = open(".", O_RDONLY);
1844                 t->openCount++;
1845                 if (t->openCount > t->maxOpenCount)
1846                         t->maxOpenCount = t->openCount;
1847         }
1848 #endif
1849         return (r);
1850 }
1851
1852 /*
1853  * We've finished a directory; ascend back to the parent.
1854  */
1855 static int
1856 tree_ascend(struct tree *t)
1857 {
1858         struct tree_entry *te;
1859         int r = 0, prev_dir_fd;
1860
1861         te = t->stack;
1862         prev_dir_fd = t->working_dir_fd;
1863 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_FDOPENDIR)
1864         if (te->flags & isDirLink)
1865                 t->working_dir_fd = te->symlink_parent_fd;
1866         else {
1867                 int new_fd = openat(t->working_dir_fd, "..", O_RDONLY);
1868                 if (new_fd < 0) {
1869                         t->tree_errno = errno;
1870                         r = TREE_ERROR_FATAL;
1871                 } else
1872                         t->working_dir_fd = new_fd;
1873         }
1874 #else
1875         if (te->flags & isDirLink) {
1876                 if (fchdir(te->symlink_parent_fd) != 0) {
1877                         t->tree_errno = errno;
1878                         r = TREE_ERROR_FATAL;
1879                 } else
1880                         t->working_dir_fd = te->symlink_parent_fd;
1881         } else {
1882                 if (chdir("..") != 0) {
1883                         t->tree_errno = errno;
1884                         r = TREE_ERROR_FATAL;
1885                 } else
1886                         t->working_dir_fd = open(".", O_RDONLY);
1887         }
1888 #endif
1889         if (r == 0) {
1890                 /* Current directory has been changed, we should
1891                  * close an fd of previous working directory. */
1892                 close_and_restore_time(prev_dir_fd, t, &te->restore_time);
1893                 if (te->flags & isDirLink) {
1894                         t->openCount--;
1895                         te->symlink_parent_fd = -1;
1896                 }
1897                 t->depth--;
1898         }
1899         return (r);
1900 }
1901
1902 /*
1903  * Return to the initial directory where tree_open() was performed.
1904  */
1905 static int
1906 tree_enter_initial_dir(struct tree *t)
1907 {
1908         int r = 0;
1909
1910         if (t->flags & onWorkingDir) {
1911                 r = fchdir(t->initial_dir_fd);
1912                 if (r == 0)
1913                         t->flags &= ~onWorkingDir;
1914         }
1915         return (r);
1916 }
1917
1918 /*
1919  * Restore working directory of directory traversals.
1920  */
1921 static int
1922 tree_enter_working_dir(struct tree *t)
1923 {
1924         int r = 0;
1925
1926         /*
1927          * Change the current directory if really needed.
1928          * Sometimes this is unneeded when we did not do
1929          * descent.
1930          */
1931         if (t->depth > 0 && (t->flags & onWorkingDir) == 0) {
1932                 r = fchdir(t->working_dir_fd);
1933                 if (r == 0)
1934                         t->flags |= onWorkingDir;
1935         }
1936         return (r);
1937 }
1938
1939 static int
1940 tree_current_dir_fd(struct tree *t)
1941 {
1942         return (t->working_dir_fd);
1943 }
1944
1945 /*
1946  * Pop the working stack.
1947  */
1948 static void
1949 tree_pop(struct tree *t)
1950 {
1951         struct tree_entry *te;
1952
1953         t->path.s[t->dirname_length] = '\0';
1954         t->path.length = t->dirname_length;
1955         if (t->stack == t->current && t->current != NULL)
1956                 t->current = t->current->parent;
1957         te = t->stack;
1958         t->stack = te->next;
1959         t->dirname_length = te->dirname_length;
1960         t->basename = t->path.s + t->dirname_length;
1961         while (t->basename[0] == '/')
1962                 t->basename++;
1963         archive_string_free(&te->name);
1964         free(te);
1965 }
1966
1967 /*
1968  * Get the next item in the tree traversal.
1969  */
1970 static int
1971 tree_next(struct tree *t)
1972 {
1973         int r;
1974
1975         while (t->stack != NULL) {
1976                 /* If there's an open dir, get the next entry from there. */
1977                 if (t->d != INVALID_DIR_HANDLE) {
1978                         r = tree_dir_next_posix(t);
1979                         if (r == 0)
1980                                 continue;
1981                         return (r);
1982                 }
1983
1984                 if (t->stack->flags & needsFirstVisit) {
1985                         /* Top stack item needs a regular visit. */
1986                         t->current = t->stack;
1987                         tree_append(t, t->stack->name.s,
1988                             archive_strlen(&(t->stack->name)));
1989                         /* t->dirname_length = t->path_length; */
1990                         /* tree_pop(t); */
1991                         t->stack->flags &= ~needsFirstVisit;
1992                         return (t->visit_type = TREE_REGULAR);
1993                 } else if (t->stack->flags & needsDescent) {
1994                         /* Top stack item is dir to descend into. */
1995                         t->current = t->stack;
1996                         tree_append(t, t->stack->name.s,
1997                             archive_strlen(&(t->stack->name)));
1998                         t->stack->flags &= ~needsDescent;
1999                         r = tree_descent(t);
2000                         if (r != 0) {
2001                                 tree_pop(t);
2002                                 t->visit_type = r;
2003                         } else
2004                                 t->visit_type = TREE_POSTDESCENT;
2005                         return (t->visit_type);
2006                 } else if (t->stack->flags & needsOpen) {
2007                         t->stack->flags &= ~needsOpen;
2008                         r = tree_dir_next_posix(t);
2009                         if (r == 0)
2010                                 continue;
2011                         return (r);
2012                 } else if (t->stack->flags & needsAscent) {
2013                         /* Top stack item is dir and we're done with it. */
2014                         r = tree_ascend(t);
2015                         tree_pop(t);
2016                         t->visit_type = r != 0 ? r : TREE_POSTASCENT;
2017                         return (t->visit_type);
2018                 } else {
2019                         /* Top item on stack is dead. */
2020                         tree_pop(t);
2021                         t->flags &= ~hasLstat;
2022                         t->flags &= ~hasStat;
2023                 }
2024         }
2025         return (t->visit_type = 0);
2026 }
2027
2028 static int
2029 tree_dir_next_posix(struct tree *t)
2030 {
2031         int r;
2032         const char *name;
2033         size_t namelen;
2034
2035         if (t->d == NULL) {
2036 #if defined(HAVE_READDIR_R)
2037                 size_t dirent_size;
2038 #endif
2039
2040 #if defined(HAVE_FDOPENDIR)
2041                 if ((t->d = fdopendir(dup(t->working_dir_fd))) == NULL) {
2042 #else
2043                 if ((t->d = opendir(".")) == NULL) {
2044 #endif
2045                         r = tree_ascend(t); /* Undo "chdir" */
2046                         tree_pop(t);
2047                         t->tree_errno = errno;
2048                         t->visit_type = r != 0 ? r : TREE_ERROR_DIR;
2049                         return (t->visit_type);
2050                 }
2051 #if defined(HAVE_READDIR_R)
2052                 dirent_size = offsetof(struct dirent, d_name) +
2053                   t->filesystem_table[t->current->filesystem_id].name_max + 1;
2054                 if (t->dirent == NULL || t->dirent_allocated < dirent_size) {
2055                         free(t->dirent);
2056                         t->dirent = malloc(dirent_size);
2057                         if (t->dirent == NULL) {
2058                                 closedir(t->d);
2059                                 t->d = INVALID_DIR_HANDLE;
2060                                 (void)tree_ascend(t);
2061                                 tree_pop(t);
2062                                 t->tree_errno = ENOMEM;
2063                                 t->visit_type = TREE_ERROR_DIR;
2064                                 return (t->visit_type);
2065                         }
2066                         t->dirent_allocated = dirent_size;
2067                 }
2068 #endif /* HAVE_READDIR_R */
2069         }
2070         for (;;) {
2071 #if defined(HAVE_READDIR_R)
2072                 r = readdir_r(t->d, t->dirent, &t->de);
2073                 if (r != 0 || t->de == NULL) {
2074 #else
2075                 errno = 0;
2076                 t->de = readdir(t->d);
2077                 if (t->de == NULL) {
2078                         r = errno;
2079 #endif
2080                         closedir(t->d);
2081                         t->d = INVALID_DIR_HANDLE;
2082                         if (r != 0) {
2083                                 t->tree_errno = r;
2084                                 t->visit_type = TREE_ERROR_DIR;
2085                                 return (t->visit_type);
2086                         } else
2087                                 return (0);
2088                 }
2089                 name = t->de->d_name;
2090                 namelen = D_NAMELEN(t->de);
2091                 t->flags &= ~hasLstat;
2092                 t->flags &= ~hasStat;
2093                 if (name[0] == '.' && name[1] == '\0')
2094                         continue;
2095                 if (name[0] == '.' && name[1] == '.' && name[2] == '\0')
2096                         continue;
2097                 tree_append(t, name, namelen);
2098                 return (t->visit_type = TREE_REGULAR);
2099         }
2100 }
2101
2102
2103 /*
2104  * Get the stat() data for the entry just returned from tree_next().
2105  */
2106 static const struct stat *
2107 tree_current_stat(struct tree *t)
2108 {
2109         if (!(t->flags & hasStat)) {
2110 #ifdef HAVE_FSTATAT
2111                 if (fstatat(tree_current_dir_fd(t),
2112                     tree_current_access_path(t), &t->st, 0) != 0)
2113 #else
2114                 if (stat(tree_current_access_path(t), &t->st) != 0)
2115 #endif
2116                         return NULL;
2117                 t->flags |= hasStat;
2118         }
2119         return (&t->st);
2120 }
2121
2122 /*
2123  * Get the lstat() data for the entry just returned from tree_next().
2124  */
2125 static const struct stat *
2126 tree_current_lstat(struct tree *t)
2127 {
2128         if (!(t->flags & hasLstat)) {
2129 #ifdef HAVE_FSTATAT
2130                 if (fstatat(tree_current_dir_fd(t),
2131                     tree_current_access_path(t), &t->lst,
2132                     AT_SYMLINK_NOFOLLOW) != 0)
2133 #else
2134                 if (lstat(tree_current_access_path(t), &t->lst) != 0)
2135 #endif
2136                         return NULL;
2137                 t->flags |= hasLstat;
2138         }
2139         return (&t->lst);
2140 }
2141
2142 /*
2143  * Test whether current entry is a dir or link to a dir.
2144  */
2145 static int
2146 tree_current_is_dir(struct tree *t)
2147 {
2148         const struct stat *st;
2149         /*
2150          * If we already have lstat() info, then try some
2151          * cheap tests to determine if this is a dir.
2152          */
2153         if (t->flags & hasLstat) {
2154                 /* If lstat() says it's a dir, it must be a dir. */
2155                 if (S_ISDIR(tree_current_lstat(t)->st_mode))
2156                         return 1;
2157                 /* Not a dir; might be a link to a dir. */
2158                 /* If it's not a link, then it's not a link to a dir. */
2159                 if (!S_ISLNK(tree_current_lstat(t)->st_mode))
2160                         return 0;
2161                 /*
2162                  * It's a link, but we don't know what it's a link to,
2163                  * so we'll have to use stat().
2164                  */
2165         }
2166
2167         st = tree_current_stat(t);
2168         /* If we can't stat it, it's not a dir. */
2169         if (st == NULL)
2170                 return 0;
2171         /* Use the definitive test.  Hopefully this is cached. */
2172         return (S_ISDIR(st->st_mode));
2173 }
2174
2175 /*
2176  * Test whether current entry is a physical directory.  Usually, we
2177  * already have at least one of stat() or lstat() in memory, so we
2178  * use tricks to try to avoid an extra trip to the disk.
2179  */
2180 static int
2181 tree_current_is_physical_dir(struct tree *t)
2182 {
2183         const struct stat *st;
2184
2185         /*
2186          * If stat() says it isn't a dir, then it's not a dir.
2187          * If stat() data is cached, this check is free, so do it first.
2188          */
2189         if ((t->flags & hasStat)
2190             && (!S_ISDIR(tree_current_stat(t)->st_mode)))
2191                 return 0;
2192
2193         /*
2194          * Either stat() said it was a dir (in which case, we have
2195          * to determine whether it's really a link to a dir) or
2196          * stat() info wasn't available.  So we use lstat(), which
2197          * hopefully is already cached.
2198          */
2199
2200         st = tree_current_lstat(t);
2201         /* If we can't stat it, it's not a dir. */
2202         if (st == NULL)
2203                 return 0;
2204         /* Use the definitive test.  Hopefully this is cached. */
2205         return (S_ISDIR(st->st_mode));
2206 }
2207
2208 /*
2209  * Test whether the same file has been in the tree as its parent.
2210  */
2211 static int
2212 tree_target_is_same_as_parent(struct tree *t, const struct stat *st)
2213 {
2214         struct tree_entry *te;
2215
2216         for (te = t->current->parent; te != NULL; te = te->parent) {
2217                 if (te->dev == st->st_dev && te->ino == st->st_ino)
2218                         return (1);
2219         }
2220         return (0);
2221 }
2222
2223 /*
2224  * Test whether the current file is symbolic link target and
2225  * on the other filesystem.
2226  */
2227 static int
2228 tree_current_is_symblic_link_target(struct tree *t)
2229 {
2230         static const struct stat *lst, *st;
2231
2232         lst = tree_current_lstat(t);
2233         st = tree_current_stat(t);
2234         return (st != NULL && st->st_dev == t->current_filesystem->dev &&
2235             st->st_dev != lst->st_dev);
2236 }
2237
2238 /*
2239  * Return the access path for the entry just returned from tree_next().
2240  */
2241 static const char *
2242 tree_current_access_path(struct tree *t)
2243 {
2244         return (t->basename);
2245 }
2246
2247 /*
2248  * Return the full path for the entry just returned from tree_next().
2249  */
2250 static const char *
2251 tree_current_path(struct tree *t)
2252 {
2253         return (t->path.s);
2254 }
2255
2256 /*
2257  * Terminate the traversal.
2258  */
2259 static void
2260 tree_close(struct tree *t)
2261 {
2262
2263         if (t == NULL)
2264                 return;
2265         if (t->entry_fd >= 0) {
2266                 close_and_restore_time(t->entry_fd, t, &t->restore_time);
2267                 t->entry_fd = -1;
2268         }
2269         /* Close the handle of readdir(). */
2270         if (t->d != INVALID_DIR_HANDLE) {
2271                 closedir(t->d);
2272                 t->d = INVALID_DIR_HANDLE;
2273         }
2274         /* Release anything remaining in the stack. */
2275         while (t->stack != NULL) {
2276                 if (t->stack->flags & isDirLink)
2277                         close(t->stack->symlink_parent_fd);
2278                 tree_pop(t);
2279         }
2280         if (t->working_dir_fd >= 0) {
2281                 close(t->working_dir_fd);
2282                 t->working_dir_fd = -1;
2283         }
2284         if (t->initial_dir_fd >= 0) {
2285                 close(t->initial_dir_fd);
2286                 t->initial_dir_fd = -1;
2287         }
2288 }
2289
2290 /*
2291  * Release any resources.
2292  */
2293 static void
2294 tree_free(struct tree *t)
2295 {
2296         int i;
2297
2298         if (t == NULL)
2299                 return;
2300         archive_string_free(&t->path);
2301 #if defined(HAVE_READDIR_R)
2302         free(t->dirent);
2303 #endif
2304         free(t->sparse_list);
2305         for (i = 0; i < t->max_filesystem_id; i++)
2306                 free(t->filesystem_table[i].allocation_ptr);
2307         free(t->filesystem_table);
2308         free(t);
2309 }
2310
2311 #endif