Utilities/cmlibarchive/libarchive/archive_read_disk_windows.c

   1 /*-
   2  * Copyright (c) 2003-2009 Tim Kientzle
   3  * Copyright (c) 2010-2012 Michihiro NAKAJIMA
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer
  11  *    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 #include "archive_platform.h"
  28 __FBSDID("$FreeBSD$");
  29
  30 #if defined(_WIN32) && !defined(__CYGWIN__)
  31
  32 #ifdef HAVE_ERRNO_H
  33 #include <errno.h>
  34 #endif
  35 #ifdef HAVE_STDLIB_H
  36 #include <stdlib.h>
  37 #endif
  38 #include <winioctl.h>
  39
  40 #include "archive.h"
  41 #include "archive_string.h"
  42 #include "archive_entry.h"
  43 #include "archive_private.h"
  44 #include "archive_read_disk_private.h"
  45
  46 #ifndef O_BINARY
  47 #define O_BINARY        0
  48 #endif
  49 #ifndef IO_REPARSE_TAG_SYMLINK
  50 /* Old SDKs do not provide IO_REPARSE_TAG_SYMLINK */
  51 #define IO_REPARSE_TAG_SYMLINK 0xA000000CL
  52 #endif
  53
  54 /*-
  55  * This is a new directory-walking system that addresses a number
  56  * of problems I've had with fts(3).  In particular, it has no
  57  * pathname-length limits (other than the size of 'int'), handles
  58  * deep logical traversals, uses considerably less memory, and has
  59  * an opaque interface (easier to modify in the future).
  60  *
  61  * Internally, it keeps a single list of "tree_entry" items that
  62  * represent filesystem objects that require further attention.
  63  * Non-directories are not kept in memory: they are pulled from
  64  * readdir(), returned to the client, then freed as soon as possible.
  65  * Any directory entry to be traversed gets pushed onto the stack.
  66  *
  67  * There is surprisingly little information that needs to be kept for
  68  * each item on the stack.  Just the name, depth (represented here as the
  69  * string length of the parent directory's pathname), and some markers
  70  * indicating how to get back to the parent (via chdir("..") for a
  71  * regular dir or via fchdir(2) for a symlink).
  72  */
  73
  74 struct restore_time {
  75         const wchar_t           *full_path;
  76         FILETIME                 lastWriteTime;
  77         FILETIME                 lastAccessTime;
  78         mode_t                   filetype;
  79 };
  80
  81 struct tree_entry {
  82         int                      depth;
  83         struct tree_entry       *next;
  84         struct tree_entry       *parent;
  85         size_t                   full_path_dir_length;
  86         struct archive_wstring   name;
  87         struct archive_wstring   full_path;
  88         size_t                   dirname_length;
  89         int64_t                  dev;
  90         int64_t                  ino;
  91         int                      flags;
  92         int                      filesystem_id;
  93         /* How to restore time of a directory. */
  94         struct restore_time      restore_time;
  95 };
  96
  97 struct filesystem {
  98         int64_t         dev;
  99         int             synthetic;
 100         int             remote;
 101         DWORD           bytesPerSector;
 102 };
 103
 104 /* Definitions for tree_entry.flags bitmap. */
 105 #define isDir           1  /* This entry is a regular directory. */
 106 #define isDirLink       2  /* This entry is a symbolic link to a directory. */
 107 #define needsFirstVisit 4  /* This is an initial entry. */
 108 #define needsDescent    8  /* This entry needs to be previsited. */
 109 #define needsOpen       16 /* This is a directory that needs to be opened. */
 110 #define needsAscent     32 /* This entry needs to be postvisited. */
 111
 112 /*
 113  * On Windows, "first visit" is handled as a pattern to be handed to
 114  * _findfirst().  This is consistent with Windows conventions that
 115  * file patterns are handled within the application.  On Posix,
 116  * "first visit" is just returned to the client.
 117  */
 118
 119 #define MAX_OVERLAPPED  8
 120 #define READ_BUFFER_SIZE        (1024 * 64) /* Default to 64KB per https://technet.microsoft.com/en-us/library/cc938632.aspx */
 121 #define DIRECT_IO       0/* Disabled */
 122 #define ASYNC_IO        1/* Enabled */
 123
 124 /*
 125  * Local data for this package.
 126  */
 127 struct tree {
 128         struct tree_entry       *stack;
 129         struct tree_entry       *current;
 130         HANDLE d;
 131         WIN32_FIND_DATAW        _findData;
 132         WIN32_FIND_DATAW        *findData;
 133         int                      flags;
 134         int                      visit_type;
 135         /* Error code from last failed operation. */
 136         int                      tree_errno;
 137
 138         /* A full path with "\\?\" prefix. */
 139         struct archive_wstring   full_path;
 140         size_t                   full_path_dir_length;
 141         /* Dynamically-sized buffer for holding path */
 142         struct archive_wstring   path;
 143
 144         /* Last path element */
 145         const wchar_t           *basename;
 146         /* Leading dir length */
 147         size_t                   dirname_length;
 148
 149         int      depth;
 150
 151         BY_HANDLE_FILE_INFORMATION      lst;
 152         BY_HANDLE_FILE_INFORMATION      st;
 153         int                      descend;
 154         /* How to restore time of a file. */
 155         struct restore_time     restore_time;
 156
 157         struct entry_sparse {
 158                 int64_t          length;
 159                 int64_t          offset;
 160         }                       *sparse_list, *current_sparse;
 161         int                      sparse_count;
 162         int                      sparse_list_size;
 163
 164         char                     initial_symlink_mode;
 165         char                     symlink_mode;
 166         struct filesystem       *current_filesystem;
 167         struct filesystem       *filesystem_table;
 168         int                      initial_filesystem_id;
 169         int                      current_filesystem_id;
 170         int                      max_filesystem_id;
 171         int                      allocated_filesystem;
 172
 173         HANDLE                   entry_fh;
 174         int                      entry_eof;
 175         int64_t                  entry_remaining_bytes;
 176         int64_t                  entry_total;
 177
 178         int                      ol_idx_doing;
 179         int                      ol_idx_done;
 180         int                      ol_num_doing;
 181         int                      ol_num_done;
 182         int64_t                  ol_remaining_bytes;
 183         int64_t                  ol_total;
 184         struct la_overlapped {
 185                 OVERLAPPED       ol;
 186                 struct archive * _a;
 187                 unsigned char   *buff;
 188                 size_t           buff_size;
 189                 int64_t          offset;
 190                 size_t           bytes_expected;
 191                 size_t           bytes_transferred;
 192         }                        ol[MAX_OVERLAPPED];
 193         int                      direct_io;
 194         int                      async_io;
 195 };
 196
 197 #define bhfi_dev(bhfi)  ((bhfi)->dwVolumeSerialNumber)
 198 /* Treat FileIndex as i-node. We should remove a sequence number
 199  * which is high-16-bits of nFileIndexHigh. */
 200 #define bhfi_ino(bhfi)  \
 201         ((((int64_t)((bhfi)->nFileIndexHigh & 0x0000FFFFUL)) << 32) \
 202     + (bhfi)->nFileIndexLow)
 203
 204 /* Definitions for tree.flags bitmap. */
 205 #define hasStat         16 /* The st entry is valid. */
 206 #define hasLstat        32 /* The lst entry is valid. */
 207 #define needsRestoreTimes 128
 208
 209 static int
 210 tree_dir_next_windows(struct tree *t, const wchar_t *pattern);
 211
 212 /* Initiate/terminate a tree traversal. */
 213 static struct tree *tree_open(const wchar_t *, int, int);
 214 static struct tree *tree_reopen(struct tree *, const wchar_t *, int);
 215 static void tree_close(struct tree *);
 216 static void tree_free(struct tree *);
 217 static void tree_push(struct tree *, const wchar_t *, const wchar_t *,
 218                 int, int64_t, int64_t, struct restore_time *);
 219
 220 /*
 221  * tree_next() returns Zero if there is no next entry, non-zero if
 222  * there is.  Note that directories are visited three times.
 223  * Directories are always visited first as part of enumerating their
 224  * parent; that is a "regular" visit.  If tree_descend() is invoked at
 225  * that time, the directory is added to a work list and will
 226  * subsequently be visited two more times: once just after descending
 227  * into the directory ("postdescent") and again just after ascending
 228  * back to the parent ("postascent").
 229  *
 230  * TREE_ERROR_DIR is returned if the descent failed (because the
 231  * directory couldn't be opened, for instance).  This is returned
 232  * instead of TREE_POSTDESCENT/TREE_POSTASCENT.  TREE_ERROR_DIR is not a
 233  * fatal error, but it does imply that the relevant subtree won't be
 234  * visited.  TREE_ERROR_FATAL is returned for an error that left the
 235  * traversal completely hosed.  Right now, this is only returned for
 236  * chdir() failures during ascent.
 237  */
 238 #define TREE_REGULAR            1
 239 #define TREE_POSTDESCENT        2
 240 #define TREE_POSTASCENT         3
 241 #define TREE_ERROR_DIR          -1
 242 #define TREE_ERROR_FATAL        -2
 243
 244 static int tree_next(struct tree *);
 245
 246 /*
 247  * Return information about the current entry.
 248  */
 249
 250 /*
 251  * The current full pathname, length of the full pathname, and a name
 252  * that can be used to access the file.  Because tree does use chdir
 253  * extensively, the access path is almost never the same as the full
 254  * current path.
 255  *
 256  */
 257 static const wchar_t *tree_current_path(struct tree *);
 258 static const wchar_t *tree_current_access_path(struct tree *);
 259
 260 /*
 261  * Request the lstat() or stat() data for the current path.  Since the
 262  * tree package needs to do some of this anyway, and caches the
 263  * results, you should take advantage of it here if you need it rather
 264  * than make a redundant stat() or lstat() call of your own.
 265  */
 266 static const BY_HANDLE_FILE_INFORMATION *tree_current_stat(struct tree *);
 267 static const BY_HANDLE_FILE_INFORMATION *tree_current_lstat(struct tree *);
 268
 269 /* The following functions use tricks to avoid a certain number of
 270  * stat()/lstat() calls. */
 271 /* "is_physical_dir" is equivalent to S_ISDIR(tree_current_lstat()->st_mode) */
 272 static int tree_current_is_physical_dir(struct tree *);
 273 /* "is_physical_link" is equivalent to S_ISLNK(tree_current_lstat()->st_mode) */
 274 static int tree_current_is_physical_link(struct tree *);
 275 /* Instead of archive_entry_copy_stat for BY_HANDLE_FILE_INFORMATION */
 276 static void tree_archive_entry_copy_bhfi(struct archive_entry *,
 277                     struct tree *, const BY_HANDLE_FILE_INFORMATION *);
 278 /* "is_dir" is equivalent to S_ISDIR(tree_current_stat()->st_mode) */
 279 static int tree_current_is_dir(struct tree *);
 280 static int update_current_filesystem(struct archive_read_disk *a,
 281                     int64_t dev);
 282 static int setup_current_filesystem(struct archive_read_disk *);
 283 static int tree_target_is_same_as_parent(struct tree *,
 284                     const BY_HANDLE_FILE_INFORMATION *);
 285
 286 static int      _archive_read_disk_open_w(struct archive *, const wchar_t *);
 287 static int      _archive_read_free(struct archive *);
 288 static int      _archive_read_close(struct archive *);
 289 static int      _archive_read_data_block(struct archive *,
 290                     const void **, size_t *, int64_t *);
 291 static int      _archive_read_next_header(struct archive *,
 292                     struct archive_entry **);
 293 static int      _archive_read_next_header2(struct archive *,
 294                     struct archive_entry *);
 295 static const char *trivial_lookup_gname(void *, int64_t gid);
 296 static const char *trivial_lookup_uname(void *, int64_t uid);
 297 static int      setup_sparse(struct archive_read_disk *, struct archive_entry *);
 298 static int      close_and_restore_time(HANDLE, struct tree *,
 299                     struct restore_time *);
 300 static int      setup_sparse_from_disk(struct archive_read_disk *,
 301                     struct archive_entry *, HANDLE);
 302 static int      la_linkname_from_handle(HANDLE, wchar_t **, int *);
 303 static int      la_linkname_from_pathw(const wchar_t *, wchar_t **, int *);
 304 static void     entry_symlink_from_pathw(struct archive_entry *,
 305                     const wchar_t *path);
 306
 307 typedef struct _REPARSE_DATA_BUFFER {
 308         ULONG   ReparseTag;
 309         USHORT ReparseDataLength;
 310         USHORT  Reserved;
 311         union {
 312                 struct {
 313                         USHORT  SubstituteNameOffset;
 314                         USHORT  SubstituteNameLength;
 315                         USHORT  PrintNameOffset;
 316                         USHORT  PrintNameLength;
 317                         ULONG   Flags;
 318                         WCHAR   PathBuffer[1];
 319                 } SymbolicLinkReparseBuffer;
 320                 struct {
 321                         USHORT  SubstituteNameOffset;
 322                         USHORT  SubstituteNameLength;
 323                         USHORT  PrintNameOffset;
 324                         USHORT  PrintNameLength;
 325                         WCHAR   PathBuffer[1];
 326                 } MountPointReparseBuffer;
 327                 struct {
 328                         UCHAR   DataBuffer[1];
 329                 } GenericReparseBuffer;
 330         } DUMMYUNIONNAME;
 331 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
 332
 333 /*
 334  * Reads the target of a symbolic link
 335  *
 336  * Returns 0 on success and -1 on failure
 337  * outbuf is allocated in the function
 338  */
 339 static int
 340 la_linkname_from_handle(HANDLE h, wchar_t **linkname, int *linktype)
 341 {
 342         DWORD inbytes;
 343         REPARSE_DATA_BUFFER *buf;
 344         BY_HANDLE_FILE_INFORMATION st;
 345         size_t len;
 346         BOOL ret;
 347         BYTE *indata;
 348         wchar_t *tbuf;
 349
 350         ret = GetFileInformationByHandle(h, &st);
 351         if (ret == 0 ||
 352             (st.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0) {
 353                 return (-1);
 354         }
 355
 356         indata = malloc(MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
 357         ret = DeviceIoControl(h, FSCTL_GET_REPARSE_POINT, NULL, 0, indata,
 358             1024, &inbytes, NULL);
 359         if (ret == 0) {
 360                 la_dosmaperr(GetLastError());
 361                 free(indata);
 362                 return (-1);
 363         }
 364
 365         buf = (REPARSE_DATA_BUFFER *) indata;
 366         if (buf->ReparseTag != IO_REPARSE_TAG_SYMLINK) {
 367                 free(indata);
 368                 /* File is not a symbolic link */
 369                 errno = EINVAL;
 370                 return (-1);
 371         }
 372
 373         len = buf->SymbolicLinkReparseBuffer.SubstituteNameLength;
 374         if (len <= 0) {
 375                 free(indata);
 376                 return (-1);
 377         }
 378
 379         tbuf = malloc(len + 1 * sizeof(wchar_t));
 380         if (tbuf == NULL) {
 381                 free(indata);
 382                 return (-1);
 383         }
 384
 385         memcpy(tbuf, &((BYTE *)buf->SymbolicLinkReparseBuffer.PathBuffer)
 386             [buf->SymbolicLinkReparseBuffer.SubstituteNameOffset], len);
 387         free(indata);
 388
 389         tbuf[len / sizeof(wchar_t)] = L'\0';
 390
 391         *linkname = tbuf;
 392
 393         /*
 394          * Translate backslashes to slashes for libarchive internal use
 395          */
 396         while(*tbuf != L'\0') {
 397                 if (*tbuf == L'\\')
 398                         *tbuf = L'/';
 399                 tbuf++;
 400         }
 401
 402         if ((st.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
 403                 *linktype = AE_SYMLINK_TYPE_FILE;
 404         else
 405                 *linktype = AE_SYMLINK_TYPE_DIRECTORY;
 406
 407         return (0);
 408 }
 409
 410 /*
 411  * Returns AE_SYMLINK_TYPE_FILE, AE_SYMLINK_TYPE_DIRECTORY or -1 on error
 412  */
 413 static int
 414 la_linkname_from_pathw(const wchar_t *path, wchar_t **outbuf, int *linktype)
 415 {
 416         HANDLE h;
 417         const DWORD flag = FILE_FLAG_BACKUP_SEMANTICS |
 418             FILE_FLAG_OPEN_REPARSE_POINT;
 419         int ret;
 420
 421         h = CreateFileW(path, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, flag,
 422             NULL);
 423         if (h == INVALID_HANDLE_VALUE) {
 424                 la_dosmaperr(GetLastError());
 425                 return (-1);
 426         }
 427
 428         ret = la_linkname_from_handle(h, outbuf, linktype);
 429         CloseHandle(h);
 430
 431         return (ret);
 432 }
 433
 434 static void
 435 entry_symlink_from_pathw(struct archive_entry *entry, const wchar_t *path)
 436 {
 437         wchar_t *linkname = NULL;
 438         int ret, linktype;
 439
 440         ret = la_linkname_from_pathw(path, &linkname, &linktype);
 441         if (ret != 0)
 442                 return;
 443         if (linktype >= 0) {
 444                 archive_entry_copy_symlink_w(entry, linkname);
 445                 archive_entry_set_symlink_type(entry, linktype);
 446         }
 447         free(linkname);
 448
 449         return;
 450 }
 451
 452 static struct archive_vtable *
 453 archive_read_disk_vtable(void)
 454 {
 455         static struct archive_vtable av;
 456         static int inited = 0;
 457
 458         if (!inited) {
 459                 av.archive_free = _archive_read_free;
 460                 av.archive_close = _archive_read_close;
 461                 av.archive_read_data_block = _archive_read_data_block;
 462                 av.archive_read_next_header = _archive_read_next_header;
 463                 av.archive_read_next_header2 = _archive_read_next_header2;
 464                 inited = 1;
 465         }
 466         return (&av);
 467 }
 468
 469 const char *
 470 archive_read_disk_gname(struct archive *_a, la_int64_t gid)
 471 {
 472         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 473         if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 474                 ARCHIVE_STATE_ANY, "archive_read_disk_gname"))
 475                 return (NULL);
 476         if (a->lookup_gname == NULL)
 477                 return (NULL);
 478         return ((*a->lookup_gname)(a->lookup_gname_data, gid));
 479 }
 480
 481 const char *
 482 archive_read_disk_uname(struct archive *_a, la_int64_t uid)
 483 {
 484         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 485         if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 486                 ARCHIVE_STATE_ANY, "archive_read_disk_uname"))
 487                 return (NULL);
 488         if (a->lookup_uname == NULL)
 489                 return (NULL);
 490         return ((*a->lookup_uname)(a->lookup_uname_data, uid));
 491 }
 492
 493 int
 494 archive_read_disk_set_gname_lookup(struct archive *_a,
 495     void *private_data,
 496     const char * (*lookup_gname)(void *private, la_int64_t gid),
 497     void (*cleanup_gname)(void *private))
 498 {
 499         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 500         archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
 501             ARCHIVE_STATE_ANY, "archive_read_disk_set_gname_lookup");
 502
 503         if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)
 504                 (a->cleanup_gname)(a->lookup_gname_data);
 505
 506         a->lookup_gname = lookup_gname;
 507         a->cleanup_gname = cleanup_gname;
 508         a->lookup_gname_data = private_data;
 509         return (ARCHIVE_OK);
 510 }
 511
 512 int
 513 archive_read_disk_set_uname_lookup(struct archive *_a,
 514     void *private_data,
 515     const char * (*lookup_uname)(void *private, int64_t uid),
 516     void (*cleanup_uname)(void *private))
 517 {
 518         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 519         archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
 520             ARCHIVE_STATE_ANY, "archive_read_disk_set_uname_lookup");
 521
 522         if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL)
 523                 (a->cleanup_uname)(a->lookup_uname_data);
 524
 525         a->lookup_uname = lookup_uname;
 526         a->cleanup_uname = cleanup_uname;
 527         a->lookup_uname_data = private_data;
 528         return (ARCHIVE_OK);
 529 }
 530
 531 /*
 532  * Create a new archive_read_disk object and initialize it with global state.
 533  */
 534 struct archive *
 535 archive_read_disk_new(void)
 536 {
 537         struct archive_read_disk *a;
 538
 539         a = (struct archive_read_disk *)calloc(1, sizeof(*a));
 540         if (a == NULL)
 541                 return (NULL);
 542         a->archive.magic = ARCHIVE_READ_DISK_MAGIC;
 543         a->archive.state = ARCHIVE_STATE_NEW;
 544         a->archive.vtable = archive_read_disk_vtable();
 545         a->entry = archive_entry_new2(&a->archive);
 546         a->lookup_uname = trivial_lookup_uname;
 547         a->lookup_gname = trivial_lookup_gname;
 548         a->flags = ARCHIVE_READDISK_MAC_COPYFILE;
 549         return (&a->archive);
 550 }
 551
 552 static int
 553 _archive_read_free(struct archive *_a)
 554 {
 555         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 556         int r;
 557
 558         if (_a == NULL)
 559                 return (ARCHIVE_OK);
 560         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 561             ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_free");
 562
 563         if (a->archive.state != ARCHIVE_STATE_CLOSED)
 564                 r = _archive_read_close(&a->archive);
 565         else
 566                 r = ARCHIVE_OK;
 567
 568         tree_free(a->tree);
 569         if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)
 570                 (a->cleanup_gname)(a->lookup_gname_data);
 571         if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL)
 572                 (a->cleanup_uname)(a->lookup_uname_data);
 573         archive_string_free(&a->archive.error_string);
 574         archive_entry_free(a->entry);
 575         a->archive.magic = 0;
 576         free(a);
 577         return (r);
 578 }
 579
 580 static int
 581 _archive_read_close(struct archive *_a)
 582 {
 583         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 584
 585         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 586             ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_close");
 587
 588         if (a->archive.state != ARCHIVE_STATE_FATAL)
 589                 a->archive.state = ARCHIVE_STATE_CLOSED;
 590
 591         tree_close(a->tree);
 592
 593         return (ARCHIVE_OK);
 594 }
 595
 596 static void
 597 setup_symlink_mode(struct archive_read_disk *a, char symlink_mode,
 598     int follow_symlinks)
 599 {
 600         a->symlink_mode = symlink_mode;
 601         a->follow_symlinks = follow_symlinks;
 602         if (a->tree != NULL) {
 603                 a->tree->initial_symlink_mode = a->symlink_mode;
 604                 a->tree->symlink_mode = a->symlink_mode;
 605         }
 606 }
 607
 608 int
 609 archive_read_disk_set_symlink_logical(struct archive *_a)
 610 {
 611         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 612         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 613             ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_logical");
 614         setup_symlink_mode(a, 'L', 1);
 615         return (ARCHIVE_OK);
 616 }
 617
 618 int
 619 archive_read_disk_set_symlink_physical(struct archive *_a)
 620 {
 621         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 622         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 623             ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_physical");
 624         setup_symlink_mode(a, 'P', 0);
 625         return (ARCHIVE_OK);
 626 }
 627
 628 int
 629 archive_read_disk_set_symlink_hybrid(struct archive *_a)
 630 {
 631         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 632         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 633             ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_hybrid");
 634         setup_symlink_mode(a, 'H', 1);/* Follow symlinks initially. */
 635         return (ARCHIVE_OK);
 636 }
 637
 638 int
 639 archive_read_disk_set_atime_restored(struct archive *_a)
 640 {
 641         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 642         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 643             ARCHIVE_STATE_ANY, "archive_read_disk_restore_atime");
 644         a->flags |= ARCHIVE_READDISK_RESTORE_ATIME;
 645         if (a->tree != NULL)
 646                 a->tree->flags |= needsRestoreTimes;
 647         return (ARCHIVE_OK);
 648 }
 649
 650 int
 651 archive_read_disk_set_behavior(struct archive *_a, int flags)
 652 {
 653         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 654         int r = ARCHIVE_OK;
 655
 656         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
 657             ARCHIVE_STATE_ANY, "archive_read_disk_honor_nodump");
 658
 659         a->flags = flags;
 660
 661         if (flags & ARCHIVE_READDISK_RESTORE_ATIME)
 662                 r = archive_read_disk_set_atime_restored(_a);
 663         else {
 664                 if (a->tree != NULL)
 665                         a->tree->flags &= ~needsRestoreTimes;
 666         }
 667         return (r);
 668 }
 669
 670 /*
 671  * Trivial implementations of gname/uname lookup functions.
 672  * These are normally overridden by the client, but these stub
 673  * versions ensure that we always have something that works.
 674  */
 675 static const char *
 676 trivial_lookup_gname(void *private_data, int64_t gid)
 677 {
 678         (void)private_data; /* UNUSED */
 679         (void)gid; /* UNUSED */
 680         return (NULL);
 681 }
 682
 683 static const char *
 684 trivial_lookup_uname(void *private_data, int64_t uid)
 685 {
 686         (void)private_data; /* UNUSED */
 687         (void)uid; /* UNUSED */
 688         return (NULL);
 689 }
 690
 691 static int64_t
 692 align_num_per_sector(struct tree *t, int64_t size)
 693 {
 694         int64_t surplus;
 695
 696         size += t->current_filesystem->bytesPerSector -1;
 697         surplus = size % t->current_filesystem->bytesPerSector;
 698         size -= surplus;
 699         return (size);
 700 }
 701
 702 static int
 703 start_next_async_read(struct archive_read_disk *a, struct tree *t)
 704 {
 705         struct la_overlapped *olp;
 706         DWORD buffbytes, rbytes;
 707
 708         if (t->ol_remaining_bytes == 0)
 709                 return (ARCHIVE_EOF);
 710
 711         olp = &(t->ol[t->ol_idx_doing]);
 712         t->ol_idx_doing = (t->ol_idx_doing + 1) % MAX_OVERLAPPED;
 713
 714         /* Allocate read buffer. */
 715         if (olp->buff == NULL) {
 716                 void *p;
 717                 size_t s = (size_t)align_num_per_sector(t, READ_BUFFER_SIZE);
 718                 p = VirtualAlloc(NULL, s, MEM_COMMIT, PAGE_READWRITE);
 719                 if (p == NULL) {
 720                         archive_set_error(&a->archive, ENOMEM,
 721                             "Couldn't allocate memory");
 722                         a->archive.state = ARCHIVE_STATE_FATAL;
 723                         return (ARCHIVE_FATAL);
 724                 }
 725                 olp->buff = p;
 726                 olp->buff_size = s;
 727                 olp->_a = &a->archive;
 728                 olp->ol.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 729                 if (olp->ol.hEvent == NULL) {
 730                         la_dosmaperr(GetLastError());
 731                         archive_set_error(&a->archive, errno,
 732                             "CreateEvent failed");
 733                         a->archive.state = ARCHIVE_STATE_FATAL;
 734                         return (ARCHIVE_FATAL);
 735                 }
 736         } else
 737                 ResetEvent(olp->ol.hEvent);
 738
 739         buffbytes = (DWORD)olp->buff_size;
 740         if (buffbytes > t->current_sparse->length)
 741                 buffbytes = (DWORD)t->current_sparse->length;
 742
 743         /* Skip hole. */
 744         if (t->current_sparse->offset > t->ol_total) {
 745                 t->ol_remaining_bytes -=
 746                         t->current_sparse->offset - t->ol_total;
 747         }
 748
 749         olp->offset = t->current_sparse->offset;
 750         olp->ol.Offset = (DWORD)(olp->offset & 0xffffffff);
 751         olp->ol.OffsetHigh = (DWORD)(olp->offset >> 32);
 752
 753         if (t->ol_remaining_bytes > buffbytes) {
 754                 olp->bytes_expected = buffbytes;
 755                 t->ol_remaining_bytes -= buffbytes;
 756         } else {
 757                 olp->bytes_expected = (size_t)t->ol_remaining_bytes;
 758                 t->ol_remaining_bytes = 0;
 759         }
 760         olp->bytes_transferred = 0;
 761         t->current_sparse->offset += buffbytes;
 762         t->current_sparse->length -= buffbytes;
 763         t->ol_total = t->current_sparse->offset;
 764         if (t->current_sparse->length == 0 && t->ol_remaining_bytes > 0)
 765                 t->current_sparse++;
 766
 767         if (!ReadFile(t->entry_fh, olp->buff, buffbytes, &rbytes, &(olp->ol))) {
 768                 DWORD lasterr;
 769
 770                 lasterr = GetLastError();
 771                 if (lasterr == ERROR_HANDLE_EOF) {
 772                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 773                             "Reading file truncated");
 774                         a->archive.state = ARCHIVE_STATE_FATAL;
 775                         return (ARCHIVE_FATAL);
 776                 } else if (lasterr != ERROR_IO_PENDING) {
 777                         if (lasterr == ERROR_NO_DATA)
 778                                 errno = EAGAIN;
 779                         else if (lasterr == ERROR_ACCESS_DENIED)
 780                                 errno = EBADF;
 781                         else
 782                                 la_dosmaperr(lasterr);
 783                         archive_set_error(&a->archive, errno, "Read error");
 784                         a->archive.state = ARCHIVE_STATE_FATAL;
 785                         return (ARCHIVE_FATAL);
 786                 }
 787         } else
 788                 olp->bytes_transferred = rbytes;
 789         t->ol_num_doing++;
 790
 791         return (t->ol_remaining_bytes == 0)? ARCHIVE_EOF: ARCHIVE_OK;
 792 }
 793
 794 static void
 795 cancel_async(struct tree *t)
 796 {
 797         if (t->ol_num_doing != t->ol_num_done) {
 798                 CancelIo(t->entry_fh);
 799                 t->ol_num_doing = t->ol_num_done = 0;
 800         }
 801 }
 802
 803 static int
 804 _archive_read_data_block(struct archive *_a, const void **buff,
 805     size_t *size, int64_t *offset)
 806 {
 807         struct archive_read_disk *a = (struct archive_read_disk *)_a;
 808         struct tree *t = a->tree;
 809         struct la_overlapped *olp;
 810         DWORD bytes_transferred;
 811         int r = ARCHIVE_FATAL;
 812
 813         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,
 814             "archive_read_data_block");
 815
 816         if (t->entry_eof || t->entry_remaining_bytes <= 0) {
 817                 r = ARCHIVE_EOF;
 818                 goto abort_read_data;
 819         }
 820
 821         /*
 822          * Make a request to read the file in asynchronous.
 823          */
 824         if (t->ol_num_doing == 0) {
 825                 do {
 826                         r = start_next_async_read(a, t);
 827                         if (r == ARCHIVE_FATAL)
 828                                 goto abort_read_data;
 829                         if (!t->async_io)
 830                                 break;
 831                 } while (r == ARCHIVE_OK && t->ol_num_doing < MAX_OVERLAPPED);
 832         } else {
 833                 if ((r = start_next_async_read(a, t)) == ARCHIVE_FATAL)
 834                         goto abort_read_data;
 835         }
 836
 837         olp = &(t->ol[t->ol_idx_done]);
 838         t->ol_idx_done = (t->ol_idx_done + 1) % MAX_OVERLAPPED;
 839         if (olp->bytes_transferred)
 840                 bytes_transferred = (DWORD)olp->bytes_transferred;
 841         else if (!GetOverlappedResult(t->entry_fh, &(olp->ol),
 842             &bytes_transferred, TRUE)) {
 843                 la_dosmaperr(GetLastError());
 844                 archive_set_error(&a->archive, errno,
 845                     "GetOverlappedResult failed");
 846                 a->archive.state = ARCHIVE_STATE_FATAL;
 847                 r = ARCHIVE_FATAL;
 848                 goto abort_read_data;
 849         }
 850         t->ol_num_done++;
 851
 852         if (bytes_transferred == 0 ||
 853             olp->bytes_expected != bytes_transferred) {
 854                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 855                     "Reading file truncated");
 856                 a->archive.state = ARCHIVE_STATE_FATAL;
 857                 r = ARCHIVE_FATAL;
 858                 goto abort_read_data;
 859         }
 860
 861         *buff = olp->buff;
 862         *size = bytes_transferred;
 863         *offset = olp->offset;
 864         if (olp->offset > t->entry_total)
 865                 t->entry_remaining_bytes -= olp->offset - t->entry_total;
 866         t->entry_total = olp->offset + *size;
 867         t->entry_remaining_bytes -= *size;
 868         if (t->entry_remaining_bytes == 0) {
 869                 /* Close the current file descriptor */
 870                 close_and_restore_time(t->entry_fh, t, &t->restore_time);
 871                 t->entry_fh = INVALID_HANDLE_VALUE;
 872                 t->entry_eof = 1;
 873         }
 874         return (ARCHIVE_OK);
 875
 876 abort_read_data:
 877         *buff = NULL;
 878         *size = 0;
 879         *offset = t->entry_total;
 880         if (t->entry_fh != INVALID_HANDLE_VALUE) {
 881                 cancel_async(t);
 882                 /* Close the current file descriptor */
 883                 close_and_restore_time(t->entry_fh, t, &t->restore_time);
 884                 t->entry_fh = INVALID_HANDLE_VALUE;
 885         }
 886         return (r);
 887 }
 888
 889 static int
 890 next_entry(struct archive_read_disk *a, struct tree *t,
 891     struct archive_entry *entry)
 892 {
 893         const BY_HANDLE_FILE_INFORMATION *st;
 894         const BY_HANDLE_FILE_INFORMATION *lst;
 895         const char*name;
 896         int descend, r;
 897
 898         st = NULL;
 899         lst = NULL;
 900         t->descend = 0;
 901         do {
 902                 switch (tree_next(t)) {
 903                 case TREE_ERROR_FATAL:
 904                         archive_set_error(&a->archive, t->tree_errno,
 905                             "%ls: Unable to continue traversing directory tree",
 906                             tree_current_path(t));
 907                         a->archive.state = ARCHIVE_STATE_FATAL;
 908                         return (ARCHIVE_FATAL);
 909                 case TREE_ERROR_DIR:
 910                         archive_set_error(&a->archive, t->tree_errno,
 911                             "%ls: Couldn't visit directory",
 912                             tree_current_path(t));
 913                         return (ARCHIVE_FAILED);
 914                 case 0:
 915                         return (ARCHIVE_EOF);
 916                 case TREE_POSTDESCENT:
 917                 case TREE_POSTASCENT:
 918                         break;
 919                 case TREE_REGULAR:
 920                         lst = tree_current_lstat(t);
 921                         if (lst == NULL) {
 922                                 archive_set_error(&a->archive, t->tree_errno,
 923                                     "%ls: Cannot stat",
 924                                     tree_current_path(t));
 925                                 return (ARCHIVE_FAILED);
 926                         }
 927                         break;
 928                 }
 929         } while (lst == NULL);
 930
 931         archive_entry_copy_pathname_w(entry, tree_current_path(t));
 932
 933         /*
 934          * Perform path matching.
 935          */
 936         if (a->matching) {
 937                 r = archive_match_path_excluded(a->matching, entry);
 938                 if (r < 0) {
 939                         archive_set_error(&(a->archive), errno,
 940                             "Failed : %s", archive_error_string(a->matching));
 941                         return (r);
 942                 }
 943                 if (r) {
 944                         if (a->excluded_cb_func)
 945                                 a->excluded_cb_func(&(a->archive),
 946                                     a->excluded_cb_data, entry);
 947                         return (ARCHIVE_RETRY);
 948                 }
 949         }
 950
 951         /*
 952          * Distinguish 'L'/'P'/'H' symlink following.
 953          */
 954         switch(t->symlink_mode) {
 955         case 'H':
 956                 /* 'H': After the first item, rest like 'P'. */
 957                 t->symlink_mode = 'P';
 958                 /* 'H': First item (from command line) like 'L'. */
 959                 /* FALLTHROUGH */
 960         case 'L':
 961                 /* 'L': Do descend through a symlink to dir. */
 962                 descend = tree_current_is_dir(t);
 963                 /* 'L': Follow symlinks to files. */
 964                 a->symlink_mode = 'L';
 965                 a->follow_symlinks = 1;
 966                 /* 'L': Archive symlinks as targets, if we can. */
 967                 st = tree_current_stat(t);
 968                 if (st != NULL && !tree_target_is_same_as_parent(t, st))
 969                         break;
 970                 /* If stat fails, we have a broken symlink;
 971                  * in that case, don't follow the link. */
 972                 /* FALLTHROUGH */
 973         default:
 974                 /* 'P': Don't descend through a symlink to dir. */
 975                 descend = tree_current_is_physical_dir(t);
 976                 /* 'P': Don't follow symlinks to files. */
 977                 a->symlink_mode = 'P';
 978                 a->follow_symlinks = 0;
 979                 /* 'P': Archive symlinks as symlinks. */
 980                 st = lst;
 981                 break;
 982         }
 983
 984         if (update_current_filesystem(a, bhfi_dev(st)) != ARCHIVE_OK) {
 985                 a->archive.state = ARCHIVE_STATE_FATAL;
 986                 return (ARCHIVE_FATAL);
 987         }
 988         if (t->initial_filesystem_id == -1)
 989                 t->initial_filesystem_id = t->current_filesystem_id;
 990         if (a->flags & ARCHIVE_READDISK_NO_TRAVERSE_MOUNTS) {
 991                 if (t->initial_filesystem_id != t->current_filesystem_id)
 992                         return (ARCHIVE_RETRY);
 993         }
 994         t->descend = descend;
 995
 996         tree_archive_entry_copy_bhfi(entry, t, st);
 997
 998         /* Save the times to be restored. This must be in before
 999          * calling archive_read_disk_descend() or any chance of it,
1000          * especially, invoking a callback. */
1001         t->restore_time.lastWriteTime = st->ftLastWriteTime;
1002         t->restore_time.lastAccessTime = st->ftLastAccessTime;
1003         t->restore_time.filetype = archive_entry_filetype(entry);
1004
1005         /*
1006          * Perform time matching.
1007          */
1008         if (a->matching) {
1009                 r = archive_match_time_excluded(a->matching, entry);
1010                 if (r < 0) {
1011                         archive_set_error(&(a->archive), errno,
1012                             "Failed : %s", archive_error_string(a->matching));
1013                         return (r);
1014                 }
1015                 if (r) {
1016                         if (a->excluded_cb_func)
1017                                 a->excluded_cb_func(&(a->archive),
1018                                     a->excluded_cb_data, entry);
1019                         return (ARCHIVE_RETRY);
1020                 }
1021         }
1022
1023         /* Lookup uname/gname */
1024         name = archive_read_disk_uname(&(a->archive), archive_entry_uid(entry));
1025         if (name != NULL)
1026                 archive_entry_copy_uname(entry, name);
1027         name = archive_read_disk_gname(&(a->archive), archive_entry_gid(entry));
1028         if (name != NULL)
1029                 archive_entry_copy_gname(entry, name);
1030
1031         /*
1032          * Perform owner matching.
1033          */
1034         if (a->matching) {
1035                 r = archive_match_owner_excluded(a->matching, entry);
1036                 if (r < 0) {
1037                         archive_set_error(&(a->archive), errno,
1038                             "Failed : %s", archive_error_string(a->matching));
1039                         return (r);
1040                 }
1041                 if (r) {
1042                         if (a->excluded_cb_func)
1043                                 a->excluded_cb_func(&(a->archive),
1044                                     a->excluded_cb_data, entry);
1045                         return (ARCHIVE_RETRY);
1046                 }
1047         }
1048
1049         /*
1050          * File attributes
1051          */
1052         if ((a->flags & ARCHIVE_READDISK_NO_FFLAGS) == 0) {
1053                 const int supported_attrs =
1054                     FILE_ATTRIBUTE_READONLY |
1055                     FILE_ATTRIBUTE_HIDDEN |
1056                     FILE_ATTRIBUTE_SYSTEM;
1057                 DWORD file_attrs = st->dwFileAttributes & supported_attrs;
1058                 if (file_attrs != 0)
1059                         archive_entry_set_fflags(entry, file_attrs, 0);
1060         }
1061
1062         /*
1063          * Invoke a meta data filter callback.
1064          */
1065         if (a->metadata_filter_func) {
1066                 if (!a->metadata_filter_func(&(a->archive),
1067                     a->metadata_filter_data, entry))
1068                         return (ARCHIVE_RETRY);
1069         }
1070
1071         archive_entry_copy_sourcepath_w(entry, tree_current_access_path(t));
1072
1073         r = ARCHIVE_OK;
1074         if (archive_entry_filetype(entry) == AE_IFREG &&
1075             archive_entry_size(entry) > 0) {
1076                 DWORD flags = FILE_FLAG_BACKUP_SEMANTICS;
1077                 if (t->async_io)
1078                         flags |= FILE_FLAG_OVERLAPPED;
1079                 if (t->direct_io)
1080                         flags |= FILE_FLAG_NO_BUFFERING;
1081                 else
1082                         flags |= FILE_FLAG_SEQUENTIAL_SCAN;
1083                 t->entry_fh = CreateFileW(tree_current_access_path(t),
1084                     GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, flags, NULL);
1085                 if (t->entry_fh == INVALID_HANDLE_VALUE) {
1086                         la_dosmaperr(GetLastError());
1087                         archive_set_error(&a->archive, errno,
1088                             "Couldn't open %ls", tree_current_path(a->tree));
1089                         return (ARCHIVE_FAILED);
1090                 }
1091
1092                 /* Find sparse data from the disk. */
1093                 if (archive_entry_hardlink(entry) == NULL &&
1094                     (st->dwFileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) != 0)
1095                         r = setup_sparse_from_disk(a, entry, t->entry_fh);
1096         }
1097         return (r);
1098 }
1099
1100 static int
1101 _archive_read_next_header(struct archive *_a, struct archive_entry **entryp)
1102 {
1103        int ret;
1104        struct archive_read_disk *a = (struct archive_read_disk *)_a;
1105        *entryp = NULL;
1106        ret = _archive_read_next_header2(_a, a->entry);
1107        *entryp = a->entry;
1108        return ret;
1109 }
1110
1111 static int
1112 _archive_read_next_header2(struct archive *_a, struct archive_entry *entry)
1113 {
1114         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1115         struct tree *t;
1116         int r;
1117
1118         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
1119             ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
1120             "archive_read_next_header2");
1121
1122         t = a->tree;
1123         if (t->entry_fh != INVALID_HANDLE_VALUE) {
1124                 cancel_async(t);
1125                 close_and_restore_time(t->entry_fh, t, &t->restore_time);
1126                 t->entry_fh = INVALID_HANDLE_VALUE;
1127         }
1128
1129         archive_entry_clear(entry);
1130
1131         while ((r = next_entry(a, t, entry)) == ARCHIVE_RETRY)
1132                 archive_entry_clear(entry);
1133
1134         /*
1135          * EOF and FATAL are persistent at this layer.  By
1136          * modifying the state, we guarantee that future calls to
1137          * read a header or read data will fail.
1138          */
1139         switch (r) {
1140         case ARCHIVE_EOF:
1141                 a->archive.state = ARCHIVE_STATE_EOF;
1142                 break;
1143         case ARCHIVE_OK:
1144         case ARCHIVE_WARN:
1145                 t->entry_total = 0;
1146                 if (archive_entry_filetype(entry) == AE_IFREG) {
1147                         t->entry_remaining_bytes = archive_entry_size(entry);
1148                         t->entry_eof = (t->entry_remaining_bytes == 0)? 1: 0;
1149                         if (!t->entry_eof &&
1150                             setup_sparse(a, entry) != ARCHIVE_OK)
1151                                 return (ARCHIVE_FATAL);
1152                 } else {
1153                         t->entry_remaining_bytes = 0;
1154                         t->entry_eof = 1;
1155                 }
1156                 t->ol_idx_doing = t->ol_idx_done = 0;
1157                 t->ol_num_doing = t->ol_num_done = 0;
1158                 t->ol_remaining_bytes = t->entry_remaining_bytes;
1159                 t->ol_total = 0;
1160                 a->archive.state = ARCHIVE_STATE_DATA;
1161                 break;
1162         case ARCHIVE_RETRY:
1163                 break;
1164         case ARCHIVE_FATAL:
1165                 a->archive.state = ARCHIVE_STATE_FATAL;
1166                 break;
1167         }
1168
1169         __archive_reset_read_data(&a->archive);
1170         return (r);
1171 }
1172
1173 static int
1174 setup_sparse(struct archive_read_disk *a, struct archive_entry *entry)
1175 {
1176         struct tree *t = a->tree;
1177         int64_t aligned, length, offset;
1178         int i;
1179
1180         t->sparse_count = archive_entry_sparse_reset(entry);
1181         if (t->sparse_count+1 > t->sparse_list_size) {
1182                 free(t->sparse_list);
1183                 t->sparse_list_size = t->sparse_count + 1;
1184                 t->sparse_list = malloc(sizeof(t->sparse_list[0]) *
1185                     t->sparse_list_size);
1186                 if (t->sparse_list == NULL) {
1187                         t->sparse_list_size = 0;
1188                         archive_set_error(&a->archive, ENOMEM,
1189                             "Can't allocate data");
1190                         a->archive.state = ARCHIVE_STATE_FATAL;
1191                         return (ARCHIVE_FATAL);
1192                 }
1193         }
1194         /*
1195          * Get sparse list and make sure those offsets and lengths are
1196          * aligned by a sector size.
1197          */
1198         for (i = 0; i < t->sparse_count; i++) {
1199                 archive_entry_sparse_next(entry, &offset, &length);
1200                 aligned = align_num_per_sector(t, offset);
1201                 if (aligned != offset) {
1202                         aligned -= t->current_filesystem->bytesPerSector;
1203                         length += offset - aligned;
1204                 }
1205                 t->sparse_list[i].offset = aligned;
1206                 aligned = align_num_per_sector(t, length);
1207                 t->sparse_list[i].length = aligned;
1208         }
1209
1210         aligned = align_num_per_sector(t, archive_entry_size(entry));
1211         if (i == 0) {
1212                 t->sparse_list[i].offset = 0;
1213                 t->sparse_list[i].length = aligned;
1214         } else {
1215                 int j, last = i;
1216
1217                 t->sparse_list[i].offset = aligned;
1218                 t->sparse_list[i].length = 0;
1219                 for (i = 0; i < last; i++) {
1220                         if ((t->sparse_list[i].offset +
1221                                t->sparse_list[i].length) <=
1222                                         t->sparse_list[i+1].offset)
1223                                 continue;
1224                         /*
1225                          * Now sparse_list[i+1] is overlapped by sparse_list[i].
1226                          * Merge those two.
1227                          */
1228                         length = t->sparse_list[i+1].offset -
1229                                         t->sparse_list[i].offset;
1230                         t->sparse_list[i+1].offset = t->sparse_list[i].offset;
1231                         t->sparse_list[i+1].length += length;
1232                         /* Remove sparse_list[i]. */
1233                         for (j = i; j < last; j++) {
1234                                 t->sparse_list[j].offset =
1235                                     t->sparse_list[j+1].offset;
1236                                 t->sparse_list[j].length =
1237                                     t->sparse_list[j+1].length;
1238                         }
1239                         last--;
1240                 }
1241         }
1242         t->current_sparse = t->sparse_list;
1243
1244         return (ARCHIVE_OK);
1245 }
1246
1247 int
1248 archive_read_disk_set_matching(struct archive *_a, struct archive *_ma,
1249     void (*_excluded_func)(struct archive *, void *, struct archive_entry *),
1250     void *_client_data)
1251 {
1252         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1253         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
1254             ARCHIVE_STATE_ANY, "archive_read_disk_set_matching");
1255         a->matching = _ma;
1256         a->excluded_cb_func = _excluded_func;
1257         a->excluded_cb_data = _client_data;
1258         return (ARCHIVE_OK);
1259 }
1260
1261 int
1262 archive_read_disk_set_metadata_filter_callback(struct archive *_a,
1263     int (*_metadata_filter_func)(struct archive *, void *,
1264     struct archive_entry *), void *_client_data)
1265 {
1266         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1267
1268         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_ANY,
1269             "archive_read_disk_set_metadata_filter_callback");
1270
1271         a->metadata_filter_func = _metadata_filter_func;
1272         a->metadata_filter_data = _client_data;
1273         return (ARCHIVE_OK);
1274 }
1275
1276 int
1277 archive_read_disk_can_descend(struct archive *_a)
1278 {
1279         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1280         struct tree *t = a->tree;
1281
1282         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
1283             ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
1284             "archive_read_disk_can_descend");
1285
1286         return (t->visit_type == TREE_REGULAR && t->descend);
1287 }
1288
1289 /*
1290  * Called by the client to mark the directory just returned from
1291  * tree_next() as needing to be visited.
1292  */
1293 int
1294 archive_read_disk_descend(struct archive *_a)
1295 {
1296         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1297         struct tree *t = a->tree;
1298
1299         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
1300             ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
1301             "archive_read_disk_descend");
1302
1303         if (t->visit_type != TREE_REGULAR || !t->descend)
1304                 return (ARCHIVE_OK);
1305
1306         if (tree_current_is_physical_dir(t)) {
1307                 tree_push(t, t->basename, t->full_path.s,
1308                     t->current_filesystem_id,
1309                     bhfi_dev(&(t->lst)), bhfi_ino(&(t->lst)),
1310                     &t->restore_time);
1311                 t->stack->flags |= isDir;
1312         } else if (tree_current_is_dir(t)) {
1313                 tree_push(t, t->basename, t->full_path.s,
1314                     t->current_filesystem_id,
1315                     bhfi_dev(&(t->st)), bhfi_ino(&(t->st)),
1316                     &t->restore_time);
1317                 t->stack->flags |= isDirLink;
1318         }
1319         t->descend = 0;
1320         return (ARCHIVE_OK);
1321 }
1322
1323 int
1324 archive_read_disk_open(struct archive *_a, const char *pathname)
1325 {
1326         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1327         struct archive_wstring wpath;
1328         int ret;
1329
1330         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
1331             ARCHIVE_STATE_NEW | ARCHIVE_STATE_CLOSED,
1332             "archive_read_disk_open");
1333         archive_clear_error(&a->archive);
1334
1335         /* Make a wchar_t string from a char string. */
1336         archive_string_init(&wpath);
1337         if (archive_wstring_append_from_mbs(&wpath, pathname,
1338             strlen(pathname)) != 0) {
1339                 if (errno == ENOMEM)
1340                         archive_set_error(&a->archive, ENOMEM,
1341                             "Can't allocate memory");
1342                 else
1343                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1344                             "Can't convert a path to a wchar_t string");
1345                 a->archive.state = ARCHIVE_STATE_FATAL;
1346                 ret = ARCHIVE_FATAL;
1347         } else
1348                 ret = _archive_read_disk_open_w(_a, wpath.s);
1349
1350         archive_wstring_free(&wpath);
1351         return (ret);
1352 }
1353
1354 int
1355 archive_read_disk_open_w(struct archive *_a, const wchar_t *pathname)
1356 {
1357         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1358
1359         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
1360             ARCHIVE_STATE_NEW | ARCHIVE_STATE_CLOSED,
1361             "archive_read_disk_open_w");
1362         archive_clear_error(&a->archive);
1363
1364         return (_archive_read_disk_open_w(_a, pathname));
1365 }
1366
1367 static int
1368 _archive_read_disk_open_w(struct archive *_a, const wchar_t *pathname)
1369 {
1370         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1371
1372         if (a->tree != NULL)
1373                 a->tree = tree_reopen(a->tree, pathname,
1374                     a->flags & ARCHIVE_READDISK_RESTORE_ATIME);
1375         else
1376                 a->tree = tree_open(pathname, a->symlink_mode,
1377                     a->flags & ARCHIVE_READDISK_RESTORE_ATIME);
1378         if (a->tree == NULL) {
1379                 archive_set_error(&a->archive, ENOMEM,
1380                     "Can't allocate directory traversal data");
1381                 a->archive.state = ARCHIVE_STATE_FATAL;
1382                 return (ARCHIVE_FATAL);
1383         }
1384         a->archive.state = ARCHIVE_STATE_HEADER;
1385
1386         return (ARCHIVE_OK);
1387 }
1388
1389 /*
1390  * Return a current filesystem ID which is index of the filesystem entry
1391  * you've visited through archive_read_disk.
1392  */
1393 int
1394 archive_read_disk_current_filesystem(struct archive *_a)
1395 {
1396         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1397
1398         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,
1399             "archive_read_disk_current_filesystem");
1400
1401         return (a->tree->current_filesystem_id);
1402 }
1403
1404 static int
1405 update_current_filesystem(struct archive_read_disk *a, int64_t dev)
1406 {
1407         struct tree *t = a->tree;
1408         int i, fid;
1409
1410         if (t->current_filesystem != NULL &&
1411             t->current_filesystem->dev == dev)
1412                 return (ARCHIVE_OK);
1413
1414         for (i = 0; i < t->max_filesystem_id; i++) {
1415                 if (t->filesystem_table[i].dev == dev) {
1416                         /* There is the filesystem ID we've already generated. */
1417                         t->current_filesystem_id = i;
1418                         t->current_filesystem = &(t->filesystem_table[i]);
1419                         return (ARCHIVE_OK);
1420                 }
1421         }
1422
1423         /*
1424          * There is a new filesystem, we generate a new ID for.
1425          */
1426         fid = t->max_filesystem_id++;
1427         if (t->max_filesystem_id > t->allocated_filesystem) {
1428                 size_t s;
1429                 void *p;
1430
1431                 s = t->max_filesystem_id * 2;
1432                 p = realloc(t->filesystem_table,
1433                         s * sizeof(*t->filesystem_table));
1434                 if (p == NULL) {
1435                         archive_set_error(&a->archive, ENOMEM,
1436                             "Can't allocate tar data");
1437                         return (ARCHIVE_FATAL);
1438                 }
1439                 t->filesystem_table = (struct filesystem *)p;
1440                 t->allocated_filesystem = (int)s;
1441         }
1442         t->current_filesystem_id = fid;
1443         t->current_filesystem = &(t->filesystem_table[fid]);
1444         t->current_filesystem->dev = dev;
1445
1446         return (setup_current_filesystem(a));
1447 }
1448
1449 /*
1450  * Returns 1 if current filesystem is generated filesystem, 0 if it is not
1451  * or -1 if it is unknown.
1452  */
1453 int
1454 archive_read_disk_current_filesystem_is_synthetic(struct archive *_a)
1455 {
1456         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1457
1458         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,
1459             "archive_read_disk_current_filesystem");
1460
1461         return (a->tree->current_filesystem->synthetic);
1462 }
1463
1464 /*
1465  * Returns 1 if current filesystem is remote filesystem, 0 if it is not
1466  * or -1 if it is unknown.
1467  */
1468 int
1469 archive_read_disk_current_filesystem_is_remote(struct archive *_a)
1470 {
1471         struct archive_read_disk *a = (struct archive_read_disk *)_a;
1472
1473         archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,
1474             "archive_read_disk_current_filesystem");
1475
1476         return (a->tree->current_filesystem->remote);
1477 }
1478
1479 /*
1480  * If symlink is broken, statfs or statvfs will fail.
1481  * Use its directory path instead.
1482  */
1483 static wchar_t *
1484 safe_path_for_statfs(struct tree *t)
1485 {
1486         const wchar_t *path;
1487         wchar_t *cp, *p = NULL;
1488
1489         path = tree_current_access_path(t);
1490         if (tree_current_stat(t) == NULL) {
1491                 p = _wcsdup(path);
1492                 cp = wcsrchr(p, '/');
1493                 if (cp != NULL && wcslen(cp) >= 2) {
1494                         cp[1] = '.';
1495                         cp[2] = '\0';
1496                         path = p;
1497                 }
1498         } else
1499                 p = _wcsdup(path);
1500         return (p);
1501 }
1502
1503 /*
1504  * Get conditions of synthetic and remote on Windows
1505  */
1506 static int
1507 setup_current_filesystem(struct archive_read_disk *a)
1508 {
1509         struct tree *t = a->tree;
1510         wchar_t vol[256];
1511         wchar_t *path;
1512
1513         t->current_filesystem->synthetic = -1;/* Not supported */
1514         path = safe_path_for_statfs(t);
1515         if (!GetVolumePathNameW(path, vol, sizeof(vol)/sizeof(vol[0]))) {
1516                 free(path);
1517                 t->current_filesystem->remote = -1;
1518                 t->current_filesystem->bytesPerSector = 0;
1519                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1520                         "GetVolumePathName failed: %d", (int)GetLastError());
1521                 return (ARCHIVE_FAILED);
1522         }
1523         free(path);
1524         switch (GetDriveTypeW(vol)) {
1525         case DRIVE_UNKNOWN:
1526         case DRIVE_NO_ROOT_DIR:
1527                 t->current_filesystem->remote = -1;
1528                 break;
1529         case DRIVE_REMOTE:
1530                 t->current_filesystem->remote = 1;
1531                 break;
1532         default:
1533                 t->current_filesystem->remote = 0;
1534                 break;
1535         }
1536
1537         if (!GetDiskFreeSpaceW(vol, NULL,
1538             &(t->current_filesystem->bytesPerSector), NULL, NULL)) {
1539                 t->current_filesystem->bytesPerSector = 0;
1540                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1541                         "GetDiskFreeSpace failed: %d", (int)GetLastError());
1542                 return (ARCHIVE_FAILED);
1543         }
1544
1545         return (ARCHIVE_OK);
1546 }
1547
1548 static int
1549 close_and_restore_time(HANDLE h, struct tree *t, struct restore_time *rt)
1550 {
1551         HANDLE handle;
1552         int r = 0;
1553
1554         if (h == INVALID_HANDLE_VALUE && AE_IFLNK == rt->filetype)
1555                 return (0);
1556
1557         /* Close a file descriptor.
1558          * It will not be used for SetFileTime() because it has been opened
1559          * by a read only mode.
1560          */
1561         if (h != INVALID_HANDLE_VALUE)
1562                 CloseHandle(h);
1563         if ((t->flags & needsRestoreTimes) == 0)
1564                 return (r);
1565
1566         handle = CreateFileW(rt->full_path, FILE_WRITE_ATTRIBUTES,
1567                     0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
1568         if (handle == INVALID_HANDLE_VALUE) {
1569                 errno = EINVAL;
1570                 return (-1);
1571         }
1572
1573         if (SetFileTime(handle, NULL, &rt->lastAccessTime,
1574             &rt->lastWriteTime) == 0) {
1575                 errno = EINVAL;
1576                 r = -1;
1577         } else
1578                 r = 0;
1579         CloseHandle(handle);
1580         return (r);
1581 }
1582
1583 /*
1584  * Add a directory path to the current stack.
1585  */
1586 static void
1587 tree_push(struct tree *t, const wchar_t *path, const wchar_t *full_path,
1588     int filesystem_id, int64_t dev, int64_t ino, struct restore_time *rt)
1589 {
1590         struct tree_entry *te;
1591
1592         te = calloc(1, sizeof(*te));
1593         te->next = t->stack;
1594         te->parent = t->current;
1595         if (te->parent)
1596                 te->depth = te->parent->depth + 1;
1597         t->stack = te;
1598         archive_string_init(&te->name);
1599         archive_wstrcpy(&te->name, path);
1600         archive_string_init(&te->full_path);
1601         archive_wstrcpy(&te->full_path, full_path);
1602         te->flags = needsDescent | needsOpen | needsAscent;
1603         te->filesystem_id = filesystem_id;
1604         te->dev = dev;
1605         te->ino = ino;
1606         te->dirname_length = t->dirname_length;
1607         te->full_path_dir_length = t->full_path_dir_length;
1608         te->restore_time.full_path = te->full_path.s;
1609         if (rt != NULL) {
1610                 te->restore_time.lastWriteTime = rt->lastWriteTime;
1611                 te->restore_time.lastAccessTime = rt->lastAccessTime;
1612                 te->restore_time.filetype = rt->filetype;
1613         }
1614 }
1615
1616 /*
1617  * Append a name to the current dir path.
1618  */
1619 static void
1620 tree_append(struct tree *t, const wchar_t *name, size_t name_length)
1621 {
1622         size_t size_needed;
1623
1624         t->path.s[t->dirname_length] = L'\0';
1625         t->path.length = t->dirname_length;
1626         /* Strip trailing '/' from name, unless entire name is "/". */
1627         while (name_length > 1 && name[name_length - 1] == L'/')
1628                 name_length--;
1629
1630         /* Resize pathname buffer as needed. */
1631         size_needed = name_length + t->dirname_length + 2;
1632         archive_wstring_ensure(&t->path, size_needed);
1633         /* Add a separating '/' if it's needed. */
1634         if (t->dirname_length > 0 &&
1635             t->path.s[archive_strlen(&t->path)-1] != L'/')
1636                 archive_wstrappend_wchar(&t->path, L'/');
1637         t->basename = t->path.s + archive_strlen(&t->path);
1638         archive_wstrncat(&t->path, name, name_length);
1639         t->restore_time.full_path = t->basename;
1640         if (t->full_path_dir_length > 0) {
1641                 t->full_path.s[t->full_path_dir_length] = L'\0';
1642                 t->full_path.length = t->full_path_dir_length;
1643                 size_needed = name_length + t->full_path_dir_length + 2;
1644                 archive_wstring_ensure(&t->full_path, size_needed);
1645                 /* Add a separating '\' if it's needed. */
1646                 if (t->full_path.s[archive_strlen(&t->full_path)-1] != L'\\')
1647                         archive_wstrappend_wchar(&t->full_path, L'\\');
1648                 archive_wstrncat(&t->full_path, name, name_length);
1649                 t->restore_time.full_path = t->full_path.s;
1650         }
1651 }
1652
1653 /*
1654  * Open a directory tree for traversal.
1655  */
1656 static struct tree *
1657 tree_open(const wchar_t *path, int symlink_mode, int restore_time)
1658 {
1659         struct tree *t;
1660
1661         t = calloc(1, sizeof(*t));
1662         archive_string_init(&(t->full_path));
1663         archive_string_init(&t->path);
1664         archive_wstring_ensure(&t->path, 15);
1665         t->initial_symlink_mode = symlink_mode;
1666         return (tree_reopen(t, path, restore_time));
1667 }
1668
1669 static struct tree *
1670 tree_reopen(struct tree *t, const wchar_t *path, int restore_time)
1671 {
1672         struct archive_wstring ws;
1673         wchar_t *pathname, *p, *base;
1674
1675         t->flags = (restore_time != 0)?needsRestoreTimes:0;
1676         t->visit_type = 0;
1677         t->tree_errno = 0;
1678         t->full_path_dir_length = 0;
1679         t->dirname_length = 0;
1680         t->depth = 0;
1681         t->descend = 0;
1682         t->current = NULL;
1683         t->d = INVALID_HANDLE_VALUE;
1684         t->symlink_mode = t->initial_symlink_mode;
1685         archive_string_empty(&(t->full_path));
1686         archive_string_empty(&t->path);
1687         t->entry_fh = INVALID_HANDLE_VALUE;
1688         t->entry_eof = 0;
1689         t->entry_remaining_bytes = 0;
1690         t->initial_filesystem_id = -1;
1691
1692         /* Get wchar_t strings from char strings. */
1693         archive_string_init(&ws);
1694         archive_wstrcpy(&ws, path);
1695         pathname = ws.s;
1696         /* Get a full-path-name. */
1697         p = __la_win_permissive_name_w(pathname);
1698         if (p == NULL)
1699                 goto failed;
1700         archive_wstrcpy(&(t->full_path), p);
1701         free(p);
1702
1703         /* Convert path separators from '\' to '/' */
1704         for (p = pathname; *p != L'\0'; ++p) {
1705                 if (*p == L'\\')
1706                         *p = L'/';
1707         }
1708         base = pathname;
1709
1710         /* First item is set up a lot like a symlink traversal. */
1711         /* printf("Looking for wildcard in %s\n", path); */
1712         if ((base[0] == L'/' && base[1] == L'/' &&
1713              base[2] == L'?' && base[3] == L'/' &&
1714              (wcschr(base+4, L'*') || wcschr(base+4, L'?'))) ||
1715             (!(base[0] == L'/' && base[1] == L'/' &&
1716                base[2] == L'?' && base[3] == L'/') &&
1717                (wcschr(base, L'*') || wcschr(base, L'?')))) {
1718                 // It has a wildcard in it...
1719                 // Separate the last element.
1720                 p = wcsrchr(base, L'/');
1721                 if (p != NULL) {
1722                         *p = L'\0';
1723                         tree_append(t, base, p - base);
1724                         t->dirname_length = archive_strlen(&t->path);
1725                         base = p + 1;
1726                 }
1727                 p = wcsrchr(t->full_path.s, L'\\');
1728                 if (p != NULL) {
1729                         *p = L'\0';
1730                         t->full_path.length = wcslen(t->full_path.s);
1731                         t->full_path_dir_length = archive_strlen(&t->full_path);
1732                 }
1733         }
1734         tree_push(t, base, t->full_path.s, 0, 0, 0, NULL);
1735         archive_wstring_free(&ws);
1736         t->stack->flags = needsFirstVisit;
1737         /*
1738          * Debug flag for Direct IO(No buffering) or Async IO.
1739          * Those dependent on environment variable switches
1740          * will be removed until next release.
1741          */
1742         {
1743                 const char *e;
1744                 if ((e = getenv("LIBARCHIVE_DIRECT_IO")) != NULL) {
1745                         if (e[0] == '0')
1746                                 t->direct_io = 0;
1747                         else
1748                                 t->direct_io = 1;
1749                         fprintf(stderr, "LIBARCHIVE_DIRECT_IO=%s\n",
1750                                 (t->direct_io)?"Enabled":"Disabled");
1751                 } else
1752                         t->direct_io = DIRECT_IO;
1753                 if ((e = getenv("LIBARCHIVE_ASYNC_IO")) != NULL) {
1754                         if (e[0] == '0')
1755                                 t->async_io = 0;
1756                         else
1757                                 t->async_io = 1;
1758                         fprintf(stderr, "LIBARCHIVE_ASYNC_IO=%s\n",
1759                             (t->async_io)?"Enabled":"Disabled");
1760                 } else
1761                         t->async_io = ASYNC_IO;
1762         }
1763         return (t);
1764 failed:
1765         archive_wstring_free(&ws);
1766         tree_free(t);
1767         return (NULL);
1768 }
1769
1770 static int
1771 tree_descent(struct tree *t)
1772 {
1773         t->dirname_length = archive_strlen(&t->path);
1774         t->full_path_dir_length = archive_strlen(&t->full_path);
1775         t->depth++;
1776         return (0);
1777 }
1778
1779 /*
1780  * We've finished a directory; ascend back to the parent.
1781  */
1782 static int
1783 tree_ascend(struct tree *t)
1784 {
1785         struct tree_entry *te;
1786
1787         te = t->stack;
1788         t->depth--;
1789         close_and_restore_time(INVALID_HANDLE_VALUE, t, &te->restore_time);
1790         return (0);
1791 }
1792
1793 /*
1794  * Pop the working stack.
1795  */
1796 static void
1797 tree_pop(struct tree *t)
1798 {
1799         struct tree_entry *te;
1800
1801         t->full_path.s[t->full_path_dir_length] = L'\0';
1802         t->full_path.length = t->full_path_dir_length;
1803         t->path.s[t->dirname_length] = L'\0';
1804         t->path.length = t->dirname_length;
1805         if (t->stack == t->current && t->current != NULL)
1806                 t->current = t->current->parent;
1807         te = t->stack;
1808         t->stack = te->next;
1809         t->dirname_length = te->dirname_length;
1810         t->basename = t->path.s + t->dirname_length;
1811         t->full_path_dir_length = te->full_path_dir_length;
1812         while (t->basename[0] == L'/')
1813                 t->basename++;
1814         archive_wstring_free(&te->name);
1815         archive_wstring_free(&te->full_path);
1816         free(te);
1817 }
1818
1819 /*
1820  * Get the next item in the tree traversal.
1821  */
1822 static int
1823 tree_next(struct tree *t)
1824 {
1825         int r;
1826
1827         while (t->stack != NULL) {
1828                 /* If there's an open dir, get the next entry from there. */
1829                 if (t->d != INVALID_HANDLE_VALUE) {
1830                         r = tree_dir_next_windows(t, NULL);
1831                         if (r == 0)
1832                                 continue;
1833                         return (r);
1834                 }
1835
1836                 if (t->stack->flags & needsFirstVisit) {
1837                         wchar_t *d = t->stack->name.s;
1838                         t->stack->flags &= ~needsFirstVisit;
1839                         if (!(d[0] == L'/' && d[1] == L'/' &&
1840                               d[2] == L'?' && d[3] == L'/') &&
1841                             (wcschr(d, L'*') || wcschr(d, L'?'))) {
1842                                 r = tree_dir_next_windows(t, d);
1843                                 if (r == 0)
1844                                         continue;
1845                                 return (r);
1846                         } else {
1847                                 HANDLE h = FindFirstFileW(d, &t->_findData);
1848                                 if (h == INVALID_HANDLE_VALUE) {
1849                                         la_dosmaperr(GetLastError());
1850                                         t->tree_errno = errno;
1851                                         t->visit_type = TREE_ERROR_DIR;
1852                                         return (t->visit_type);
1853                                 }
1854                                 t->findData = &t->_findData;
1855                                 FindClose(h);
1856                         }
1857                         /* Top stack item needs a regular visit. */
1858                         t->current = t->stack;
1859                         tree_append(t, t->stack->name.s,
1860                             archive_strlen(&(t->stack->name)));
1861                         //t->dirname_length = t->path_length;
1862                         //tree_pop(t);
1863                         t->stack->flags &= ~needsFirstVisit;
1864                         return (t->visit_type = TREE_REGULAR);
1865                 } else if (t->stack->flags & needsDescent) {
1866                         /* Top stack item is dir to descend into. */
1867                         t->current = t->stack;
1868                         tree_append(t, t->stack->name.s,
1869                             archive_strlen(&(t->stack->name)));
1870                         t->stack->flags &= ~needsDescent;
1871                         r = tree_descent(t);
1872                         if (r != 0) {
1873                                 tree_pop(t);
1874                                 t->visit_type = r;
1875                         } else
1876                                 t->visit_type = TREE_POSTDESCENT;
1877                         return (t->visit_type);
1878                 } else if (t->stack->flags & needsOpen) {
1879                         t->stack->flags &= ~needsOpen;
1880                         r = tree_dir_next_windows(t, L"*");
1881                         if (r == 0)
1882                                 continue;
1883                         return (r);
1884                 } else if (t->stack->flags & needsAscent) {
1885                         /* Top stack item is dir and we're done with it. */
1886                         r = tree_ascend(t);
1887                         tree_pop(t);
1888                         t->visit_type = r != 0 ? r : TREE_POSTASCENT;
1889                         return (t->visit_type);
1890                 } else {
1891                         /* Top item on stack is dead. */
1892                         tree_pop(t);
1893                         t->flags &= ~hasLstat;
1894                         t->flags &= ~hasStat;
1895                 }
1896         }
1897         return (t->visit_type = 0);
1898 }
1899
1900 static int
1901 tree_dir_next_windows(struct tree *t, const wchar_t *pattern)
1902 {
1903         const wchar_t *name;
1904         size_t namelen;
1905         int r;
1906
1907         for (;;) {
1908                 if (pattern != NULL) {
1909                         struct archive_wstring pt;
1910
1911                         archive_string_init(&pt);
1912                         archive_wstring_ensure(&pt,
1913                             archive_strlen(&(t->full_path))
1914                               + 2 + wcslen(pattern));
1915                         archive_wstring_copy(&pt, &(t->full_path));
1916                         archive_wstrappend_wchar(&pt, L'\\');
1917                         archive_wstrcat(&pt, pattern);
1918                         t->d = FindFirstFileW(pt.s, &t->_findData);
1919                         archive_wstring_free(&pt);
1920                         if (t->d == INVALID_HANDLE_VALUE) {
1921                                 la_dosmaperr(GetLastError());
1922                                 t->tree_errno = errno;
1923                                 r = tree_ascend(t); /* Undo "chdir" */
1924                                 tree_pop(t);
1925                                 t->visit_type = r != 0 ? r : TREE_ERROR_DIR;
1926                                 return (t->visit_type);
1927                         }
1928                         t->findData = &t->_findData;
1929                         pattern = NULL;
1930                 } else if (!FindNextFileW(t->d, &t->_findData)) {
1931                         FindClose(t->d);
1932                         t->d = INVALID_HANDLE_VALUE;
1933                         t->findData = NULL;
1934                         return (0);
1935                 }
1936                 name = t->findData->cFileName;
1937                 namelen = wcslen(name);
1938                 t->flags &= ~hasLstat;
1939                 t->flags &= ~hasStat;
1940                 if (name[0] == L'.' && name[1] == L'\0')
1941                         continue;
1942                 if (name[0] == L'.' && name[1] == L'.' && name[2] == L'\0')
1943                         continue;
1944                 tree_append(t, name, namelen);
1945                 return (t->visit_type = TREE_REGULAR);
1946         }
1947 }
1948
1949 #define EPOC_TIME ARCHIVE_LITERAL_ULL(116444736000000000)
1950 static void
1951 fileTimeToUtc(const FILETIME *filetime, time_t *t, long *ns)
1952 {
1953         ULARGE_INTEGER utc;
1954
1955         utc.HighPart = filetime->dwHighDateTime;
1956         utc.LowPart  = filetime->dwLowDateTime;
1957         if (utc.QuadPart >= EPOC_TIME) {
1958                 utc.QuadPart -= EPOC_TIME;
1959                 /* milli seconds base */
1960                 *t = (time_t)(utc.QuadPart / 10000000);
1961                 /* nano seconds base */
1962                 *ns = (long)(utc.QuadPart % 10000000) * 100;
1963         } else {
1964                 *t = 0;
1965                 *ns = 0;
1966         }
1967 }
1968
1969 static void
1970 entry_copy_bhfi(struct archive_entry *entry, const wchar_t *path,
1971         const WIN32_FIND_DATAW *findData,
1972         const BY_HANDLE_FILE_INFORMATION *bhfi)
1973 {
1974         time_t secs;
1975         long nsecs;
1976         mode_t mode;
1977
1978         fileTimeToUtc(&bhfi->ftLastAccessTime, &secs, &nsecs);
1979         archive_entry_set_atime(entry, secs, nsecs);
1980         fileTimeToUtc(&bhfi->ftLastWriteTime, &secs, &nsecs);
1981         archive_entry_set_mtime(entry, secs, nsecs);
1982         fileTimeToUtc(&bhfi->ftCreationTime, &secs, &nsecs);
1983         archive_entry_set_birthtime(entry, secs, nsecs);
1984         archive_entry_set_ctime(entry, secs, nsecs);
1985         archive_entry_set_dev(entry, bhfi_dev(bhfi));
1986         archive_entry_set_ino64(entry, bhfi_ino(bhfi));
1987         if (bhfi->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1988                 archive_entry_set_nlink(entry, bhfi->nNumberOfLinks + 1);
1989         else
1990                 archive_entry_set_nlink(entry, bhfi->nNumberOfLinks);
1991         archive_entry_set_size(entry,
1992             (((int64_t)bhfi->nFileSizeHigh) << 32)
1993             + bhfi->nFileSizeLow);
1994         archive_entry_set_uid(entry, 0);
1995         archive_entry_set_gid(entry, 0);
1996         archive_entry_set_rdev(entry, 0);
1997
1998         mode = S_IRUSR | S_IRGRP | S_IROTH;
1999         if ((bhfi->dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0)
2000                 mode |= S_IWUSR | S_IWGRP | S_IWOTH;
2001         if ((bhfi->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) &&
2002             findData != NULL &&
2003             findData->dwReserved0 == IO_REPARSE_TAG_SYMLINK) {
2004                 mode |= S_IFLNK;
2005                 entry_symlink_from_pathw(entry, path);
2006         } else if (bhfi->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2007                 mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
2008         else {
2009                 const wchar_t *p;
2010
2011                 mode |= S_IFREG;
2012                 p = wcsrchr(path, L'.');
2013                 if (p != NULL && wcslen(p) == 4) {
2014                         switch (p[1]) {
2015                         case L'B': case L'b':
2016                                 if ((p[2] == L'A' || p[2] == L'a' ) &&
2017                                     (p[3] == L'T' || p[3] == L't' ))
2018                                         mode |= S_IXUSR | S_IXGRP | S_IXOTH;
2019                                 break;
2020                         case L'C': case L'c':
2021                                 if (((p[2] == L'M' || p[2] == L'm' ) &&
2022                                     (p[3] == L'D' || p[3] == L'd' )))
2023                                         mode |= S_IXUSR | S_IXGRP | S_IXOTH;
2024                                 break;
2025                         case L'E': case L'e':
2026                                 if ((p[2] == L'X' || p[2] == L'x' ) &&
2027                                     (p[3] == L'E' || p[3] == L'e' ))
2028                                         mode |= S_IXUSR | S_IXGRP | S_IXOTH;
2029                                 break;
2030                         default:
2031                                 break;
2032                         }
2033                 }
2034         }
2035         archive_entry_set_mode(entry, mode);
2036 }
2037
2038 static void
2039 tree_archive_entry_copy_bhfi(struct archive_entry *entry, struct tree *t,
2040         const BY_HANDLE_FILE_INFORMATION *bhfi)
2041 {
2042         entry_copy_bhfi(entry, tree_current_path(t), t->findData, bhfi);
2043 }
2044
2045 static int
2046 tree_current_file_information(struct tree *t, BY_HANDLE_FILE_INFORMATION *st,
2047  int sim_lstat)
2048 {
2049         HANDLE h;
2050         int r;
2051         DWORD flag = FILE_FLAG_BACKUP_SEMANTICS;
2052
2053         if (sim_lstat && tree_current_is_physical_link(t))
2054                 flag |= FILE_FLAG_OPEN_REPARSE_POINT;
2055         h = CreateFileW(tree_current_access_path(t), 0, FILE_SHARE_READ, NULL,
2056             OPEN_EXISTING, flag, NULL);
2057         if (h == INVALID_HANDLE_VALUE) {
2058                 la_dosmaperr(GetLastError());
2059                 t->tree_errno = errno;
2060                 return (0);
2061         }
2062         r = GetFileInformationByHandle(h, st);
2063         CloseHandle(h);
2064         return (r);
2065 }
2066
2067 /*
2068  * Get the stat() data for the entry just returned from tree_next().
2069  */
2070 static const BY_HANDLE_FILE_INFORMATION *
2071 tree_current_stat(struct tree *t)
2072 {
2073         if (!(t->flags & hasStat)) {
2074                 if (!tree_current_file_information(t, &t->st, 0))
2075                         return NULL;
2076                 t->flags |= hasStat;
2077         }
2078         return (&t->st);
2079 }
2080
2081 /*
2082  * Get the lstat() data for the entry just returned from tree_next().
2083  */
2084 static const BY_HANDLE_FILE_INFORMATION *
2085 tree_current_lstat(struct tree *t)
2086 {
2087         if (!(t->flags & hasLstat)) {
2088                 if (!tree_current_file_information(t, &t->lst, 1))
2089                         return NULL;
2090                 t->flags |= hasLstat;
2091         }
2092         return (&t->lst);
2093 }
2094
2095 /*
2096  * Test whether current entry is a dir or link to a dir.
2097  */
2098 static int
2099 tree_current_is_dir(struct tree *t)
2100 {
2101         if (t->findData)
2102                 return (t->findData->dwFileAttributes
2103                     & FILE_ATTRIBUTE_DIRECTORY);
2104         return (0);
2105 }
2106
2107 /*
2108  * Test whether current entry is a physical directory.  Usually, we
2109  * already have at least one of stat() or lstat() in memory, so we
2110  * use tricks to try to avoid an extra trip to the disk.
2111  */
2112 static int
2113 tree_current_is_physical_dir(struct tree *t)
2114 {
2115         if (tree_current_is_physical_link(t))
2116                 return (0);
2117         return (tree_current_is_dir(t));
2118 }
2119
2120 /*
2121  * Test whether current entry is a symbolic link.
2122  */
2123 static int
2124 tree_current_is_physical_link(struct tree *t)
2125 {
2126         if (t->findData)
2127                 return ((t->findData->dwFileAttributes
2128                                 & FILE_ATTRIBUTE_REPARSE_POINT) &&
2129                         (t->findData->dwReserved0
2130                             == IO_REPARSE_TAG_SYMLINK));
2131         return (0);
2132 }
2133
2134 /*
2135  * Test whether the same file has been in the tree as its parent.
2136  */
2137 static int
2138 tree_target_is_same_as_parent(struct tree *t,
2139     const BY_HANDLE_FILE_INFORMATION *st)
2140 {
2141         struct tree_entry *te;
2142         int64_t dev = bhfi_dev(st);
2143         int64_t ino = bhfi_ino(st);
2144
2145         for (te = t->current->parent; te != NULL; te = te->parent) {
2146                 if (te->dev == dev && te->ino == ino)
2147                         return (1);
2148         }
2149         return (0);
2150 }
2151
2152 /*
2153  * Return the access path for the entry just returned from tree_next().
2154  */
2155 static const wchar_t *
2156 tree_current_access_path(struct tree *t)
2157 {
2158         return (t->full_path.s);
2159 }
2160
2161 /*
2162  * Return the full path for the entry just returned from tree_next().
2163  */
2164 static const wchar_t *
2165 tree_current_path(struct tree *t)
2166 {
2167         return (t->path.s);
2168 }
2169
2170 /*
2171  * Terminate the traversal.
2172  */
2173 static void
2174 tree_close(struct tree *t)
2175 {
2176
2177         if (t == NULL)
2178                 return;
2179         if (t->entry_fh != INVALID_HANDLE_VALUE) {
2180                 cancel_async(t);
2181                 close_and_restore_time(t->entry_fh, t, &t->restore_time);
2182                 t->entry_fh = INVALID_HANDLE_VALUE;
2183         }
2184         /* Close the handle of FindFirstFileW */
2185         if (t->d != INVALID_HANDLE_VALUE) {
2186                 FindClose(t->d);
2187                 t->d = INVALID_HANDLE_VALUE;
2188                 t->findData = NULL;
2189         }
2190         /* Release anything remaining in the stack. */
2191         while (t->stack != NULL)
2192                 tree_pop(t);
2193 }
2194
2195 /*
2196  * Release any resources.
2197  */
2198 static void
2199 tree_free(struct tree *t)
2200 {
2201         int i;
2202
2203         if (t == NULL)
2204                 return;
2205         archive_wstring_free(&t->path);
2206         archive_wstring_free(&t->full_path);
2207         free(t->sparse_list);
2208         free(t->filesystem_table);
2209         for (i = 0; i < MAX_OVERLAPPED; i++) {
2210                 if (t->ol[i].buff)
2211                         VirtualFree(t->ol[i].buff, 0, MEM_RELEASE);
2212                 CloseHandle(t->ol[i].ol.hEvent);
2213         }
2214         free(t);
2215 }
2216
2217
2218 /*
2219  * Populate the archive_entry with metadata from the disk.
2220  */
2221 int
2222 archive_read_disk_entry_from_file(struct archive *_a,
2223     struct archive_entry *entry, int fd, const struct stat *st)
2224 {
2225         struct archive_read_disk *a = (struct archive_read_disk *)_a;
2226         const wchar_t *path;
2227         const wchar_t *wname;
2228         const char *name;
2229         HANDLE h;
2230         BY_HANDLE_FILE_INFORMATION bhfi;
2231         DWORD fileAttributes = 0;
2232         int r;
2233
2234         archive_clear_error(_a);
2235         wname = archive_entry_sourcepath_w(entry);
2236         if (wname == NULL)
2237                 wname = archive_entry_pathname_w(entry);
2238         if (wname == NULL) {
2239                 archive_set_error(&a->archive, EINVAL,
2240                     "Can't get a wide character version of the path");
2241                 return (ARCHIVE_FAILED);
2242         }
2243         path = __la_win_permissive_name_w(wname);
2244
2245         if (st == NULL) {
2246                 /*
2247                  * Get metadata through GetFileInformationByHandle().
2248                  */
2249                 if (fd >= 0) {
2250                         h = (HANDLE)_get_osfhandle(fd);
2251                         r = GetFileInformationByHandle(h, &bhfi);
2252                         if (r == 0) {
2253                                 la_dosmaperr(GetLastError());
2254                                 archive_set_error(&a->archive, errno,
2255                                     "Can't GetFileInformationByHandle");
2256                                 return (ARCHIVE_FAILED);
2257                         }
2258                         entry_copy_bhfi(entry, path, NULL, &bhfi);
2259                 } else {
2260                         WIN32_FIND_DATAW findData;
2261                         DWORD flag, desiredAccess;
2262
2263                         h = FindFirstFileW(path, &findData);
2264                         if (h == INVALID_HANDLE_VALUE) {
2265                                 la_dosmaperr(GetLastError());
2266                                 archive_set_error(&a->archive, errno,
2267                                     "Can't FindFirstFileW");
2268                                 return (ARCHIVE_FAILED);
2269                         }
2270                         FindClose(h);
2271
2272                         flag = FILE_FLAG_BACKUP_SEMANTICS;
2273                         if (!a->follow_symlinks &&
2274                             (findData.dwFileAttributes
2275                               & FILE_ATTRIBUTE_REPARSE_POINT) &&
2276                                   (findData.dwReserved0 == IO_REPARSE_TAG_SYMLINK)) {
2277                                 flag |= FILE_FLAG_OPEN_REPARSE_POINT;
2278                                 desiredAccess = 0;
2279                         } else if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
2280                                 desiredAccess = 0;
2281                         } else
2282                                 desiredAccess = GENERIC_READ;
2283
2284                         h = CreateFileW(path, desiredAccess, FILE_SHARE_READ, NULL,
2285                             OPEN_EXISTING, flag, NULL);
2286                         if (h == INVALID_HANDLE_VALUE) {
2287                                 la_dosmaperr(GetLastError());
2288                                 archive_set_error(&a->archive, errno,
2289                                     "Can't CreateFileW");
2290                                 return (ARCHIVE_FAILED);
2291                         }
2292                         r = GetFileInformationByHandle(h, &bhfi);
2293                         if (r == 0) {
2294                                 la_dosmaperr(GetLastError());
2295                                 archive_set_error(&a->archive, errno,
2296                                     "Can't GetFileInformationByHandle");
2297                                 CloseHandle(h);
2298                                 return (ARCHIVE_FAILED);
2299                         }
2300                         entry_copy_bhfi(entry, path, &findData, &bhfi);
2301                 }
2302                 fileAttributes = bhfi.dwFileAttributes;
2303         } else {
2304                 archive_entry_copy_stat(entry, st);
2305                 if (st->st_mode & S_IFLNK)
2306                         entry_symlink_from_pathw(entry, path);
2307                 h = INVALID_HANDLE_VALUE;
2308         }
2309
2310         /* Lookup uname/gname */
2311         name = archive_read_disk_uname(_a, archive_entry_uid(entry));
2312         if (name != NULL)
2313                 archive_entry_copy_uname(entry, name);
2314         name = archive_read_disk_gname(_a, archive_entry_gid(entry));
2315         if (name != NULL)
2316                 archive_entry_copy_gname(entry, name);
2317
2318         /*
2319          * File attributes
2320          */
2321         if ((a->flags & ARCHIVE_READDISK_NO_FFLAGS) == 0) {
2322                 const int supported_attrs =
2323                     FILE_ATTRIBUTE_READONLY |
2324                     FILE_ATTRIBUTE_HIDDEN |
2325                     FILE_ATTRIBUTE_SYSTEM;
2326                 DWORD file_attrs = fileAttributes & supported_attrs;
2327                 if (file_attrs != 0)
2328                         archive_entry_set_fflags(entry, file_attrs, 0);
2329         }
2330
2331         /*
2332          * Can this file be sparse file ?
2333          */
2334         if (archive_entry_filetype(entry) != AE_IFREG
2335             || archive_entry_size(entry) <= 0
2336                 || archive_entry_hardlink(entry) != NULL) {
2337                 if (h != INVALID_HANDLE_VALUE && fd < 0)
2338                         CloseHandle(h);
2339                 return (ARCHIVE_OK);
2340         }
2341
2342         if (h == INVALID_HANDLE_VALUE) {
2343                 if (fd >= 0) {
2344                         h = (HANDLE)_get_osfhandle(fd);
2345                 } else {
2346                         h = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL,
2347                             OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
2348                         if (h == INVALID_HANDLE_VALUE) {
2349                                 la_dosmaperr(GetLastError());
2350                                 archive_set_error(&a->archive, errno,
2351                                     "Can't CreateFileW");
2352                                 return (ARCHIVE_FAILED);
2353                         }
2354                 }
2355                 r = GetFileInformationByHandle(h, &bhfi);
2356                 if (r == 0) {
2357                         la_dosmaperr(GetLastError());
2358                         archive_set_error(&a->archive, errno,
2359                             "Can't GetFileInformationByHandle");
2360                         if (h != INVALID_HANDLE_VALUE && fd < 0)
2361                                 CloseHandle(h);
2362                         return (ARCHIVE_FAILED);
2363                 }
2364                 fileAttributes = bhfi.dwFileAttributes;
2365         }
2366
2367         /* Sparse file must be set a mark, FILE_ATTRIBUTE_SPARSE_FILE */
2368         if ((fileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) == 0) {
2369                 if (fd < 0)
2370                         CloseHandle(h);
2371                 return (ARCHIVE_OK);
2372         }
2373
2374         r = setup_sparse_from_disk(a, entry, h);
2375         if (fd < 0)
2376                 CloseHandle(h);
2377
2378         return (r);
2379 }
2380
2381 /*
2382  * Windows sparse interface.
2383  */
2384 #if defined(__MINGW32__) && !defined(FSCTL_QUERY_ALLOCATED_RANGES)
2385 #define FSCTL_QUERY_ALLOCATED_RANGES 0x940CF
2386 typedef struct {
2387         LARGE_INTEGER FileOffset;
2388         LARGE_INTEGER Length;
2389 } FILE_ALLOCATED_RANGE_BUFFER;
2390 #endif
2391
2392 static int
2393 setup_sparse_from_disk(struct archive_read_disk *a,
2394     struct archive_entry *entry, HANDLE handle)
2395 {
2396         FILE_ALLOCATED_RANGE_BUFFER range, *outranges = NULL;
2397         size_t outranges_size;
2398         int64_t entry_size = archive_entry_size(entry);
2399         int exit_sts = ARCHIVE_OK;
2400
2401         range.FileOffset.QuadPart = 0;
2402         range.Length.QuadPart = entry_size;
2403         outranges_size = 2048;
2404         outranges = (FILE_ALLOCATED_RANGE_BUFFER *)malloc(outranges_size);
2405         if (outranges == NULL) {
2406                 archive_set_error(&a->archive, ENOMEM,
2407                         "Couldn't allocate memory");
2408                 exit_sts = ARCHIVE_FATAL;
2409                 goto exit_setup_sparse;
2410         }
2411
2412         for (;;) {
2413                 DWORD retbytes;
2414                 BOOL ret;
2415
2416                 for (;;) {
2417                         ret = DeviceIoControl(handle,
2418                             FSCTL_QUERY_ALLOCATED_RANGES,
2419                             &range, sizeof(range), outranges,
2420                             (DWORD)outranges_size, &retbytes, NULL);
2421                         if (ret == 0 && GetLastError() == ERROR_MORE_DATA) {
2422                                 free(outranges);
2423                                 outranges_size *= 2;
2424                                 outranges = (FILE_ALLOCATED_RANGE_BUFFER *)
2425                                     malloc(outranges_size);
2426                                 if (outranges == NULL) {
2427                                         archive_set_error(&a->archive, ENOMEM,
2428                                             "Couldn't allocate memory");
2429                                         exit_sts = ARCHIVE_FATAL;
2430                                         goto exit_setup_sparse;
2431                                 }
2432                                 continue;
2433                         } else
2434                                 break;
2435                 }
2436                 if (ret != 0) {
2437                         if (retbytes > 0) {
2438                                 DWORD i, n;
2439
2440                                 n = retbytes / sizeof(outranges[0]);
2441                                 if (n == 1 &&
2442                                     outranges[0].FileOffset.QuadPart == 0 &&
2443                                     outranges[0].Length.QuadPart == entry_size)
2444                                         break;/* This is not sparse. */
2445                                 for (i = 0; i < n; i++)
2446                                         archive_entry_sparse_add_entry(entry,
2447                                             outranges[i].FileOffset.QuadPart,
2448                                                 outranges[i].Length.QuadPart);
2449                                 range.FileOffset.QuadPart =
2450                                     outranges[n-1].FileOffset.QuadPart
2451                                     + outranges[n-1].Length.QuadPart;
2452                                 range.Length.QuadPart =
2453                                     entry_size - range.FileOffset.QuadPart;
2454                                 if (range.Length.QuadPart > 0)
2455                                         continue;
2456                         } else {
2457                                 /* The entire file is a hole. Add one data block of size 0 at the end. */
2458                                 archive_entry_sparse_add_entry(entry,
2459                                     entry_size,
2460                                     0);
2461                         }
2462                         break;
2463                 } else {
2464                         la_dosmaperr(GetLastError());
2465                         archive_set_error(&a->archive, errno,
2466                             "DeviceIoControl Failed: %lu", GetLastError());
2467                         exit_sts = ARCHIVE_FAILED;
2468                         goto exit_setup_sparse;
2469                 }
2470         }
2471 exit_setup_sparse:
2472         free(outranges);
2473
2474         return (exit_sts);
2475 }
2476
2477 #endif