/*-

 * Copyright (c) 2003-2009 Tim Kientzle

 * Copyright (c) 2010-2012 Michihiro NAKAJIMA

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer

 *    in this position and unchanged.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "archive_platform.h"

__FBSDID("$FreeBSD$");

#if defined(_WIN32) && !defined(__CYGWIN__)

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include <winioctl.h>

#include "archive.h"

#include "archive_string.h"

#include "archive_entry.h"

#include "archive_private.h"

#include "archive_read_disk_private.h"

#ifndef O_BINARY

#define O_BINARY	0

#endif

#ifndef IO_REPARSE_TAG_SYMLINK

/* Old SDKs do not provide IO_REPARSE_TAG_SYMLINK */

#define	IO_REPARSE_TAG_SYMLINK 0xA000000CL

#endif

/*-

 * This is a new directory-walking system that addresses a number

 * of problems I've had with fts(3).  In particular, it has no

 * pathname-length limits (other than the size of 'int'), handles

 * deep logical traversals, uses considerably less memory, and has

 * an opaque interface (easier to modify in the future).

 *

 * Internally, it keeps a single list of "tree_entry" items that

 * represent filesystem objects that require further attention.

 * Non-directories are not kept in memory: they are pulled from

 * readdir(), returned to the client, then freed as soon as possible.

 * Any directory entry to be traversed gets pushed onto the stack.

 *

 * There is surprisingly little information that needs to be kept for

 * each item on the stack.  Just the name, depth (represented here as the

 * string length of the parent directory's pathname), and some markers

 * indicating how to get back to the parent (via chdir("..") for a

 * regular dir or via fchdir(2) for a symlink).

 */

struct restore_time {

	const wchar_t		*full_path;

	FILETIME		 lastWriteTime;

	FILETIME		 lastAccessTime;

	mode_t			 filetype;

};

struct tree_entry {

	int			 depth;

	struct tree_entry	*next;

	struct tree_entry	*parent;

	size_t			 full_path_dir_length;

	struct archive_wstring	 name;

	struct archive_wstring	 full_path;

	size_t			 dirname_length;

	int64_t			 dev;

	int64_t			 ino;

	int			 flags;

	int			 filesystem_id;

	/* How to restore time of a directory. */

	struct restore_time	 restore_time;

};

struct filesystem {

	int64_t		dev;

	int		synthetic;

	int		remote;

	DWORD		bytesPerSector;

};

/* Definitions for tree_entry.flags bitmap. */

#define	isDir		1  /* This entry is a regular directory. */

#define	isDirLink	2  /* This entry is a symbolic link to a directory. */

#define	needsFirstVisit	4  /* This is an initial entry. */

#define	needsDescent	8  /* This entry needs to be previsited. */

#define	needsOpen	16 /* This is a directory that needs to be opened. */

#define	needsAscent	32 /* This entry needs to be postvisited. */

/*

 * On Windows, "first visit" is handled as a pattern to be handed to

 * _findfirst().  This is consistent with Windows conventions that

 * file patterns are handled within the application.  On Posix,

 * "first visit" is just returned to the client.

 */

#define MAX_OVERLAPPED	8

#define READ_BUFFER_SIZE	(1024 * 64) /* Default to 64KB per https://technet.microsoft.com/en-us/library/cc938632.aspx */

#define DIRECT_IO	0/* Disabled */

#define ASYNC_IO	1/* Enabled */

/*

 * Local data for this package.

 */

struct tree {

	struct tree_entry	*stack;

	struct tree_entry	*current;

	HANDLE d;

	WIN32_FIND_DATAW	_findData;

	WIN32_FIND_DATAW	*findData;

	int			 flags;

	int			 visit_type;

	/* Error code from last failed operation. */

	int			 tree_errno;

	/* A full path with "\\?\" prefix. */

	struct archive_wstring	 full_path;

	size_t			 full_path_dir_length;

	/* Dynamically-sized buffer for holding path */

	struct archive_wstring	 path;

	/* Last path element */

	const wchar_t		*basename;

	/* Leading dir length */

	size_t			 dirname_length;

	int	 depth;

	BY_HANDLE_FILE_INFORMATION	lst;

	BY_HANDLE_FILE_INFORMATION	st;

	int			 descend;

	/* How to restore time of a file. */

	struct restore_time	restore_time;

	struct entry_sparse {

		int64_t		 length;

		int64_t		 offset;

	}			*sparse_list, *current_sparse;

	int			 sparse_count;

	int			 sparse_list_size;

	char			 initial_symlink_mode;

	char			 symlink_mode;

	struct filesystem	*current_filesystem;

	struct filesystem	*filesystem_table;

	int			 initial_filesystem_id;

	int			 current_filesystem_id;

	int			 max_filesystem_id;

	int			 allocated_filesystem;

	HANDLE			 entry_fh;

	int			 entry_eof;

	int64_t			 entry_remaining_bytes;

	int64_t			 entry_total;

	int			 ol_idx_doing;

	int			 ol_idx_done;

	int			 ol_num_doing;

	int			 ol_num_done;

	int64_t			 ol_remaining_bytes;

	int64_t			 ol_total;

	struct la_overlapped {

		OVERLAPPED	 ol;

		struct archive * _a;

		unsigned char	*buff;

		size_t		 buff_size;

		int64_t		 offset;

		size_t		 bytes_expected;

		size_t		 bytes_transferred;

	}			 ol[MAX_OVERLAPPED];

	int			 direct_io;

	int			 async_io;

};

#define bhfi_dev(bhfi)	((bhfi)->dwVolumeSerialNumber)

/* Treat FileIndex as i-node. We should remove a sequence number

 * which is high-16-bits of nFileIndexHigh. */

#define bhfi_ino(bhfi)	\

	((((int64_t)((bhfi)->nFileIndexHigh & 0x0000FFFFUL)) << 32) \

    + (bhfi)->nFileIndexLow)

/* Definitions for tree.flags bitmap. */

#define	hasStat		16 /* The st entry is valid. */

#define	hasLstat	32 /* The lst entry is valid. */

#define	needsRestoreTimes 128

static int

tree_dir_next_windows(struct tree *t, const wchar_t *pattern);

/* Initiate/terminate a tree traversal. */

static struct tree *tree_open(const wchar_t *, int, int);

static struct tree *tree_reopen(struct tree *, const wchar_t *, int);

static void tree_close(struct tree *);

static void tree_free(struct tree *);

static void tree_push(struct tree *, const wchar_t *, const wchar_t *,

		int, int64_t, int64_t, struct restore_time *);

/*

 * tree_next() returns Zero if there is no next entry, non-zero if

 * there is.  Note that directories are visited three times.

 * Directories are always visited first as part of enumerating their

 * parent; that is a "regular" visit.  If tree_descend() is invoked at

 * that time, the directory is added to a work list and will

 * subsequently be visited two more times: once just after descending

 * into the directory ("postdescent") and again just after ascending

 * back to the parent ("postascent").

 *

 * TREE_ERROR_DIR is returned if the descent failed (because the

 * directory couldn't be opened, for instance).  This is returned

 * instead of TREE_POSTDESCENT/TREE_POSTASCENT.  TREE_ERROR_DIR is not a

 * fatal error, but it does imply that the relevant subtree won't be

 * visited.  TREE_ERROR_FATAL is returned for an error that left the

 * traversal completely hosed.  Right now, this is only returned for

 * chdir() failures during ascent.

 */

#define	TREE_REGULAR		1

#define	TREE_POSTDESCENT	2

#define	TREE_POSTASCENT		3

#define	TREE_ERROR_DIR		-1

#define	TREE_ERROR_FATAL	-2

static int tree_next(struct tree *);

/*

 * Return information about the current entry.

 */

/*

 * The current full pathname, length of the full pathname, and a name

 * that can be used to access the file.  Because tree does use chdir

 * extensively, the access path is almost never the same as the full

 * current path.

 *

 */

static const wchar_t *tree_current_path(struct tree *);

static const wchar_t *tree_current_access_path(struct tree *);

/*

 * Request the lstat() or stat() data for the current path.  Since the

 * tree package needs to do some of this anyway, and caches the

 * results, you should take advantage of it here if you need it rather

 * than make a redundant stat() or lstat() call of your own.

 */

static const BY_HANDLE_FILE_INFORMATION *tree_current_stat(struct tree *);

static const BY_HANDLE_FILE_INFORMATION *tree_current_lstat(struct tree *);

/* The following functions use tricks to avoid a certain number of

 * stat()/lstat() calls. */

/* "is_physical_dir" is equivalent to S_ISDIR(tree_current_lstat()->st_mode) */

static int tree_current_is_physical_dir(struct tree *);

/* "is_physical_link" is equivalent to S_ISLNK(tree_current_lstat()->st_mode) */

static int tree_current_is_physical_link(struct tree *);

/* Instead of archive_entry_copy_stat for BY_HANDLE_FILE_INFORMATION */

static void tree_archive_entry_copy_bhfi(struct archive_entry *,

		    struct tree *, const BY_HANDLE_FILE_INFORMATION *);

/* "is_dir" is equivalent to S_ISDIR(tree_current_stat()->st_mode) */

static int tree_current_is_dir(struct tree *);

static int update_current_filesystem(struct archive_read_disk *a,

		    int64_t dev);

static int setup_current_filesystem(struct archive_read_disk *);

static int tree_target_is_same_as_parent(struct tree *,

		    const BY_HANDLE_FILE_INFORMATION *);

static int	_archive_read_disk_open_w(struct archive *, const wchar_t *);

static int	_archive_read_free(struct archive *);

static int	_archive_read_close(struct archive *);

static int	_archive_read_data_block(struct archive *,

		    const void **, size_t *, int64_t *);

static int	_archive_read_next_header(struct archive *,

		    struct archive_entry **);

static int	_archive_read_next_header2(struct archive *,

		    struct archive_entry *);

static const char *trivial_lookup_gname(void *, int64_t gid);

static const char *trivial_lookup_uname(void *, int64_t uid);

static int	setup_sparse(struct archive_read_disk *, struct archive_entry *);

static int	close_and_restore_time(HANDLE, struct tree *,

		    struct restore_time *);

static int	setup_sparse_from_disk(struct archive_read_disk *,

		    struct archive_entry *, HANDLE);

static struct archive_vtable *

archive_read_disk_vtable(void)

{

	static struct archive_vtable av;

	static int inited = 0;

	if (!inited) {

		av.archive_free = _archive_read_free;

		av.archive_close = _archive_read_close;

		av.archive_read_data_block = _archive_read_data_block;

		av.archive_read_next_header = _archive_read_next_header;

		av.archive_read_next_header2 = _archive_read_next_header2;

		inited = 1;

	}

	return (&av;;

}

const char *

archive_read_disk_gname(struct archive *_a, la_int64_t gid)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,

		ARCHIVE_STATE_ANY, "archive_read_disk_gname"))

		return (NULL);

	if (a->lookup_gname == NULL)

		return (NULL);

	return ((*a->lookup_gname)(a->lookup_gname_data, gid));

}

const char *

archive_read_disk_uname(struct archive *_a, la_int64_t uid)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,

		ARCHIVE_STATE_ANY, "archive_read_disk_uname"))

		return (NULL);

	if (a->lookup_uname == NULL)

		return (NULL);

	return ((*a->lookup_uname)(a->lookup_uname_data, uid));

}

int

archive_read_disk_set_gname_lookup(struct archive *_a,

    void *private_data,

    const char * (*lookup_gname)(void *private, la_int64_t gid),

    void (*cleanup_gname)(void *private))

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,

	    ARCHIVE_STATE_ANY, "archive_read_disk_set_gname_lookup");

	if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)

		(a->cleanup_gname)(a->lookup_gname_data);

	a->lookup_gname = lookup_gname;

	a->cleanup_gname = cleanup_gname;

	a->lookup_gname_data = private_data;

	return (ARCHIVE_OK);

}

int

archive_read_disk_set_uname_lookup(struct archive *_a,

    void *private_data,

    const char * (*lookup_uname)(void *private, int64_t uid),

    void (*cleanup_uname)(void *private))

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,

	    ARCHIVE_STATE_ANY, "archive_read_disk_set_uname_lookup");

	if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL)

		(a->cleanup_uname)(a->lookup_uname_data);

	a->lookup_uname = lookup_uname;

	a->cleanup_uname = cleanup_uname;

	a->lookup_uname_data = private_data;

	return (ARCHIVE_OK);

}

/*

 * Create a new archive_read_disk object and initialize it with global state.

 */

struct archive *

archive_read_disk_new(void)

{

	struct archive_read_disk *a;

	a = (struct archive_read_disk *)calloc(1, sizeof(*a));

	if (a == NULL)

		return (NULL);

	a->archive.magic = ARCHIVE_READ_DISK_MAGIC;

	a->archive.state = ARCHIVE_STATE_NEW;

	a->archive.vtable = archive_read_disk_vtable();

	a->entry = archive_entry_new2(&a->archive);

	a->lookup_uname = trivial_lookup_uname;

	a->lookup_gname = trivial_lookup_gname;

	a->flags = ARCHIVE_READDISK_MAC_COPYFILE;

	return (&a->archive);

}

static int

_archive_read_free(struct archive *_a)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	int r;

	if (_a == NULL)

		return (ARCHIVE_OK);

	archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,

	    ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_free");

	if (a->archive.state != ARCHIVE_STATE_CLOSED)

		r = _archive_read_close(&a->archive);

	else

		r = ARCHIVE_OK;

	tree_free(a->tree);

	if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)

		(a->cleanup_gname)(a->lookup_gname_data);

	if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL)

		(a->cleanup_uname)(a->lookup_uname_data);

	archive_string_free(&a->archive.error_string);

	archive_entry_free(a->entry);

	a->archive.magic = 0;

	free(a);

	return (r);

}

static int

_archive_read_close(struct archive *_a)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,

	    ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_close");

	if (a->archive.state != ARCHIVE_STATE_FATAL)

		a->archive.state = ARCHIVE_STATE_CLOSED;

	tree_close(a->tree);

	return (ARCHIVE_OK);

}

static void

setup_symlink_mode(struct archive_read_disk *a, char symlink_mode, 

    int follow_symlinks)

{

	a->symlink_mode = symlink_mode;

	a->follow_symlinks = follow_symlinks;

	if (a->tree != NULL) {

		a->tree->initial_symlink_mode = a->symlink_mode;

		a->tree->symlink_mode = a->symlink_mode;

	}

}

int

archive_read_disk_set_symlink_logical(struct archive *_a)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,

	    ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_logical");

	setup_symlink_mode(a, 'L', 1);

	return (ARCHIVE_OK);

}

int

archive_read_disk_set_symlink_physical(struct archive *_a)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,

	    ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_physical");

	setup_symlink_mode(a, 'P', 0);

	return (ARCHIVE_OK);

}

int

archive_read_disk_set_symlink_hybrid(struct archive *_a)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,

	    ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_hybrid");

	setup_symlink_mode(a, 'H', 1);/* Follow symlinks initially. */

	return (ARCHIVE_OK);

}

int

archive_read_disk_set_atime_restored(struct archive *_a)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,

	    ARCHIVE_STATE_ANY, "archive_read_disk_restore_atime");

	a->flags |= ARCHIVE_READDISK_RESTORE_ATIME;

	if (a->tree != NULL)

		a->tree->flags |= needsRestoreTimes;

	return (ARCHIVE_OK);

}

int

archive_read_disk_set_behavior(struct archive *_a, int flags)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	int r = ARCHIVE_OK;

	archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,

	    ARCHIVE_STATE_ANY, "archive_read_disk_honor_nodump");

	a->flags = flags;

	if (flags & ARCHIVE_READDISK_RESTORE_ATIME)

		r = archive_read_disk_set_atime_restored(_a);

	else {

		if (a->tree != NULL)

			a->tree->flags &= ~needsRestoreTimes;

	}

	return (r);

}

/*

 * Trivial implementations of gname/uname lookup functions.

 * These are normally overridden by the client, but these stub

 * versions ensure that we always have something that works.

 */

static const char *

trivial_lookup_gname(void *private_data, int64_t gid)

{

	(void)private_data; /* UNUSED */

	(void)gid; /* UNUSED */

	return (NULL);

}

static const char *

trivial_lookup_uname(void *private_data, int64_t uid)

{

	(void)private_data; /* UNUSED */

	(void)uid; /* UNUSED */

	return (NULL);

}

static int64_t

align_num_per_sector(struct tree *t, int64_t size)

{

	int64_t surplus;

	size += t->current_filesystem->bytesPerSector -1;

	surplus = size % t->current_filesystem->bytesPerSector;

	size -= surplus;

	return (size);

}

static int

start_next_async_read(struct archive_read_disk *a, struct tree *t)

{

	struct la_overlapped *olp;

	DWORD buffbytes, rbytes;

	if (t->ol_remaining_bytes == 0)

		return (ARCHIVE_EOF);

	olp = &(t->ol[t->ol_idx_doing]);

	t->ol_idx_doing = (t->ol_idx_doing + 1) % MAX_OVERLAPPED;

	/* Allocate read buffer. */

	if (olp->buff == NULL) {

		void *p;

		size_t s = (size_t)align_num_per_sector(t, READ_BUFFER_SIZE);

		p = VirtualAlloc(NULL, s, MEM_COMMIT, PAGE_READWRITE);

		if (p == NULL) {

			archive_set_error(&a->archive, ENOMEM,

			    "Couldn't allocate memory");

			a->archive.state = ARCHIVE_STATE_FATAL;

			return (ARCHIVE_FATAL);

		}

		olp->buff = p;

		olp->buff_size = s;

		olp->_a = &a->archive;

		olp->ol.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);

		if (olp->ol.hEvent == NULL) {

			la_dosmaperr(GetLastError());

			archive_set_error(&a->archive, errno,

			    "CreateEvent failed");

			a->archive.state = ARCHIVE_STATE_FATAL;

			return (ARCHIVE_FATAL);

		}

	} else

		ResetEvent(olp->ol.hEvent);

	buffbytes = (DWORD)olp->buff_size;

	if (buffbytes > t->current_sparse->length)

		buffbytes = (DWORD)t->current_sparse->length;

	/* Skip hole. */

	if (t->current_sparse->offset > t->ol_total) {

		t->ol_remaining_bytes -=

			t->current_sparse->offset - t->ol_total;

	}

	olp->offset = t->current_sparse->offset;

	olp->ol.Offset = (DWORD)(olp->offset & 0xffffffff);

	olp->ol.OffsetHigh = (DWORD)(olp->offset >> 32);

	if (t->ol_remaining_bytes > buffbytes) {

		olp->bytes_expected = buffbytes;

		t->ol_remaining_bytes -= buffbytes;

	} else {

		olp->bytes_expected = (size_t)t->ol_remaining_bytes;

		t->ol_remaining_bytes = 0;

	}

	olp->bytes_transferred = 0;

	t->current_sparse->offset += buffbytes;

	t->current_sparse->length -= buffbytes;

	t->ol_total = t->current_sparse->offset;

	if (t->current_sparse->length == 0 && t->ol_remaining_bytes > 0)

		t->current_sparse++;

	if (!ReadFile(t->entry_fh, olp->buff, buffbytes, &rbytes, &(olp->ol))) {

		DWORD lasterr;

		lasterr = GetLastError();

		if (lasterr == ERROR_HANDLE_EOF) {

			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

			    "Reading file truncated");

			a->archive.state = ARCHIVE_STATE_FATAL;

			return (ARCHIVE_FATAL);

		} else if (lasterr != ERROR_IO_PENDING) {

			if (lasterr == ERROR_NO_DATA)

				errno = EAGAIN;

			else if (lasterr == ERROR_ACCESS_DENIED)

				errno = EBADF;

			else

				la_dosmaperr(lasterr);

			archive_set_error(&a->archive, errno, "Read error");

			a->archive.state = ARCHIVE_STATE_FATAL;

			return (ARCHIVE_FATAL);

		}

	} else

		olp->bytes_transferred = rbytes;

	t->ol_num_doing++;

	return (t->ol_remaining_bytes == 0)? ARCHIVE_EOF: ARCHIVE_OK;

}

static void

cancel_async(struct tree *t)

{

	if (t->ol_num_doing != t->ol_num_done) {

		CancelIo(t->entry_fh);

		t->ol_num_doing = t->ol_num_done = 0;

	}

}

static int

_archive_read_data_block(struct archive *_a, const void **buff,

    size_t *size, int64_t *offset)

{

	struct archive_read_disk *a = (struct archive_read_disk *)_a;

	struct tree *t = a->tree;

	struct la_overlapped *olp;

	DWORD bytes_transferred;

	int r = ARCHIVE_FATAL;

	archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC, ARCHIVE_STATE_DATA,

	    "archive_read_data_block");

	if (t->entry_eof || t->entry_remaining_bytes <= 0) {

		r = ARCHIVE_EOF;

		goto abort_read_data;

	}

	/*

	 * Make a request to read the file in asynchronous.

	 */

	if (t->ol_num_doing == 0) {

		do {

			r = start_next_async_read(a, t);

			if (r == ARCHIVE_FATAL)

				goto abort_read_data;

			if (!t->async_io)

				break;

		} while (r == ARCHIVE_OK && t->ol_num_doing < MAX_OVERLAPPED);

	} else {

		if ((r = start_next_async_read(a, t)) == ARCHIVE_FATAL)

			goto abort_read_data;

	}

	olp = &(t->ol[t->ol_idx_done]);

	t->ol_idx_done = (t->ol_idx_done + 1) % MAX_OVERLAPPED;

	if (olp->bytes_transferred)

		bytes_transferred = (DWORD)olp->bytes_transferred;

	else if (!GetOverlappedResult(t->entry_fh, &(olp->ol),

	    &bytes_transferred, TRUE)) {

		la_dosmaperr(GetLastError());

		archive_set_error(&a->archive, errno,

		    "GetOverlappedResult failed");

		a->archive.state = ARCHIVE_STATE_FATAL;

		r = ARCHIVE_FATAL;

		goto abort_read_data;

	}

	t->ol_num_done++;

	if (bytes_transferred == 0 ||

	    olp->bytes_expected != bytes_transferred) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

		    "Reading file truncated");

		a->archive.state = ARCHIVE_STATE_FATAL;

		r = ARCHIVE_FATAL;

		goto abort_read_data;

	}

	*buff = olp->buff;

	*size = bytes_transferred;

	*offset = olp->offset;

	if (olp->offset > t->entry_total)

		t->entry_remaining_bytes -= olp->offset - t->entry_total;

	t->entry_total = olp->offset + *size;

	t->entry_remaining_bytes -= *size;

	if (t->entry_remaining_bytes == 0) {

		/* Close the current file descriptor */

		close_and_restore_time(t->entry_fh, t, &t->restore_time);

		t->entry_fh = INVALID_HANDLE_VALUE;

		t->entry_eof = 1;

	}

	return (ARCHIVE_OK);

abort_read_data:

	*buff = NULL;

	*size = 0;

	*offset = t->entry_total;

	if (t->entry_fh != INVALID_HANDLE_VALUE) {

		cancel_async(t);

		/* Close the current file descriptor */

		close_and_restore_time(t->entry_fh, t, &t->restore_time);

		t->entry_fh = INVALID_HANDLE_VALUE;

	}

	return (r);

}

static int

next_entry(struct archive_read_disk *a, struct tree *t,

    struct archive_entry *entry)

{

	const BY_HANDLE_FILE_INFORMATION *st;

	const BY_HANDLE_FILE_INFORMATION *lst;

	const char*name;

	int descend, r;

	st = NULL;

	lst = NULL;

	t->descend = 0;

	do {

		switch (tree_next(t)) {

		case TREE_ERROR_FATAL:

			archive_set_error(&a->archive, t->tree_errno,

			    "%ls: Unable to continue traversing directory tree",

			    tree_current_path(t));

			a->archive.state = ARCHIVE_STATE_FATAL;

			return (ARCHIVE_FATAL);

		case TREE_ERROR_DIR:

			archive_set_error(&a->archive, t->tree_errno,

			    "%ls: Couldn't visit directory",

			    tree_current_path(t));

			return (ARCHIVE_FAILED);

		case 0:

			return (ARCHIVE_EOF);

		case TREE_POSTDESCENT:

		case TREE_POSTASCENT:

			break;

		case TREE_REGULAR:

			lst = tree_current_lstat(t);

			if (lst == NULL) {

				archive_set_error(&a->archive, t->tree_errno,

				    "%ls: Cannot stat",

				    tree_current_path(t));

				return (ARCHIVE_FAILED);

			}

			break;

		}	

	} while (lst == NULL);

	archive_entry_copy_pathname_w(entry, tree_current_path(t));

	/*

	 * Perform path matching.

	 */

	if (a->matching) {

		r = archive_match_path_excluded(a->matching, entry);

		if (r < 0) {

			archive_set_error(&(a->archive), errno,

			    "Failed : %s", archive_error_string(a->matching));

			return (r);

		}

		if (r) {

			if (a->excluded_cb_func)

				a->excluded_cb_func(&(a->archive),

				    a->excluded_cb_data, entry);

			return (ARCHIVE_RETRY);

		}

	}

	/*

	 * Distinguish 'L'/'P'/'H' symlink following.

	 */

	switch(t->symlink_mode) {

	case 'H':

		/* 'H': After the first item, rest like 'P'. */

		t->symlink_mode = 'P';

		/* 'H': First item (from command line) like 'L'. */

		/* FALLTHROUGH */

	case 'L':

		/* 'L': Do descend through a symlink to dir. */

		descend = tree_current_is_dir(t);

		/* 'L': Follow symlinks to files. */

		a->symlink_mode = 'L';

		a->follow_symlinks = 1;

		/* 'L': Archive symlinks as targets, if we can. */

		st = tree_current_stat(t);

		if (st != NULL && !tree_target_is_same_as_parent(t, st))

			break;

		/* If stat fails, we have a broken symlink;

		 * in that case, don't follow the link. */

		/* FALLTHROUGH */

	default:

		/* 'P': Don't descend through a symlink to dir. */

		descend = tree_current_is_physical_dir(t);

		/* 'P': Don't follow symlinks to files. */

		a->symlink_mode = 'P';

		a->follow_symlinks = 0;

		/* 'P': Archive symlinks as symlinks. */

		st = lst;

		break;

	}

	if (update_current_filesystem(a, bhfi_dev(st)) != ARCHIVE_OK) {

		a->archive.state = ARCHIVE_STATE_FATAL;

		return (ARCHIVE_FATAL);

	}

	if (t->initial_filesystem_id == -1)

		t->initial_filesystem_id = t->current_filesystem_id;

	if (a->flags & ARCHIVE_READDISK_NO_TRAVERSE_MOUNTS) {

		if (t->initial_filesystem_id != t->current_filesystem_id)

			return (ARCHIVE_RETRY);

	}

	t->descend = descend;

	tree_archive_entry_copy_bhfi(entry, t, st);

	/* Save the times to be restored. This must be in before

	 * calling archive_read_disk_descend() or any chance of it,

	 * especially, invoking a callback. */

	t->restore_time.lastWriteTime = st->ftLastWriteTime;

	t->restore_time.lastAccessTime = st->ftLastAccessTime;

	t->restore_time.filetype = archive_entry_filetype(entry);

	/*

	 * Perform time matching.

	 */

	if (a->matching) {

		r = archive_match_time_excluded(a->matching, entry);

		if (r < 0) {

			archive_set_error(&(a->archive), errno,

			    "Failed : %s", archive_error_string(a->matching));

			return (r);

		}

		if (r) {

			if (a->excluded_cb_func)

				a->excluded_cb_func(&(a->archive),

				    a->excluded_cb_data, entry);

			return (ARCHIVE_RETRY);

		}

	}

	/* Lookup uname/gname */

	name = archive_read_disk_uname(&(a->archive), archive_entry_uid(entry));

	if (name != NULL)

		archive_entry_copy_uname(entry, name);

	name = archive_read_disk_gname(&(a->archive), archive_entry_gid(entry));