/*-

 * Copyright (c) 2009 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.

 * 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$");

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#if HAVE_LIBXML_XMLREADER_H

#include <libxml/xmlreader.h>

#elif HAVE_BSDXML_H

#include <bsdxml.h>

#elif HAVE_EXPAT_H

#include <expat.h>

#endif

#ifdef HAVE_BZLIB_H

#include <bzlib.h>

#endif

#if HAVE_LZMA_H

#include <lzma.h>

#endif

#ifdef HAVE_ZLIB_H

#include <zlib.h>

#endif

#include "archive.h"

#include "archive_digest_private.h"

#include "archive_endian.h"

#include "archive_entry.h"

#include "archive_entry_locale.h"

#include "archive_private.h"

#include "archive_read_private.h"

#if (!defined(HAVE_LIBXML_XMLREADER_H) && \

     !defined(HAVE_BSDXML_H) && !defined(HAVE_EXPAT_H)) ||\

	!defined(HAVE_ZLIB_H) || \

	!defined(ARCHIVE_HAS_MD5) || !defined(ARCHIVE_HAS_SHA1)

/*

 * xar needs several external libraries.

 *   o libxml2 or expat --- XML parser

 *   o openssl or MD5/SHA1 hash function

 *   o zlib

 *   o bzlib2 (option)

 *   o liblzma (option)

 */

int

archive_read_support_format_xar(struct archive *_a)

{

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

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_read_support_format_xar");

	archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

	    "Xar not supported on this platform");

	return (ARCHIVE_WARN);

}

#else	/* Support xar format */

/* #define DEBUG 1 */

/* #define DEBUG_PRINT_TOC 1 */

#if DEBUG_PRINT_TOC

#define PRINT_TOC(d, outbytes)	do {				\

	unsigned char *x = (unsigned char *)(uintptr_t)d;	\

	unsigned char c = x[outbytes-1];			\

	x[outbytes - 1] = 0;					\

	fprintf(stderr, "%s", x);				\

	fprintf(stderr, "%c", c);				\

	x[outbytes - 1] = c;					\

} while (0)

#else

#define PRINT_TOC(d, outbytes)

#endif

#define HEADER_MAGIC	0x78617221

#define HEADER_SIZE	28

#define HEADER_VERSION	1

#define CKSUM_NONE	0

#define CKSUM_SHA1	1

#define CKSUM_MD5	2

#define MD5_SIZE	16

#define SHA1_SIZE	20

#define MAX_SUM_SIZE	20

enum enctype {

	NONE,

	GZIP,

	BZIP2,

	LZMA,

	XZ,

};

struct chksumval {

	int			 alg;

	size_t			 len;

	unsigned char		 val[MAX_SUM_SIZE];

};

struct chksumwork {

	int			 alg;

#ifdef ARCHIVE_HAS_MD5

	archive_md5_ctx		 md5ctx;

#endif

#ifdef ARCHIVE_HAS_SHA1

	archive_sha1_ctx	 sha1ctx;

#endif

};

struct xattr {

	struct xattr		*next;

	struct archive_string	 name;

	uint64_t		 id;

	uint64_t		 length;

	uint64_t		 offset;

	uint64_t		 size;

	enum enctype		 encoding;

	struct chksumval	 a_sum;

	struct chksumval	 e_sum;

	struct archive_string	 fstype;

};

struct xar_file {

	struct xar_file		*next;

	struct xar_file		*hdnext;

	struct xar_file		*parent;

	int			 subdirs;

	unsigned int		 has;

#define HAS_DATA		0x00001

#define HAS_PATHNAME		0x00002

#define HAS_SYMLINK		0x00004

#define HAS_TIME		0x00008

#define HAS_UID			0x00010

#define HAS_GID			0x00020

#define HAS_MODE		0x00040

#define HAS_TYPE		0x00080

#define HAS_DEV			0x00100

#define HAS_DEVMAJOR		0x00200

#define HAS_DEVMINOR		0x00400

#define HAS_INO			0x00800

#define HAS_FFLAGS		0x01000

#define HAS_XATTR		0x02000

#define HAS_ACL			0x04000

	uint64_t		 id;

	uint64_t		 length;

	uint64_t		 offset;

	uint64_t		 size;

	enum enctype		 encoding;

	struct chksumval	 a_sum;

	struct chksumval	 e_sum;

	struct archive_string	 pathname;

	struct archive_string	 symlink;

	time_t			 ctime;

	time_t			 mtime;

	time_t			 atime;

	struct archive_string	 uname;

	int64_t			 uid;

	struct archive_string	 gname;

	int64_t			 gid;

	mode_t			 mode;

	dev_t			 dev;

	dev_t			 devmajor;

	dev_t			 devminor;

	int64_t			 ino64;

	struct archive_string	 fflags_text;

	unsigned int		 link;

	unsigned int		 nlink;

	struct archive_string	 hardlink;

	struct xattr		*xattr_list;

};

struct hdlink {

	struct hdlink		 *next;

	unsigned int		 id;

	int			 cnt;

	struct xar_file		 *files;

};

struct heap_queue {

	struct xar_file		**files;

	int			 allocated;

	int			 used;

};

enum xmlstatus {

	INIT,

	XAR,

	TOC,

	TOC_CREATION_TIME,

	TOC_CHECKSUM,

	TOC_CHECKSUM_OFFSET,

	TOC_CHECKSUM_SIZE,

	TOC_FILE,

	FILE_DATA,

	FILE_DATA_LENGTH,

	FILE_DATA_OFFSET,

	FILE_DATA_SIZE,

	FILE_DATA_ENCODING,

	FILE_DATA_A_CHECKSUM,

	FILE_DATA_E_CHECKSUM,

	FILE_DATA_CONTENT,

	FILE_EA,

	FILE_EA_LENGTH,

	FILE_EA_OFFSET,

	FILE_EA_SIZE,

	FILE_EA_ENCODING,

	FILE_EA_A_CHECKSUM,

	FILE_EA_E_CHECKSUM,

	FILE_EA_NAME,

	FILE_EA_FSTYPE,

	FILE_CTIME,

	FILE_MTIME,

	FILE_ATIME,

	FILE_GROUP,

	FILE_GID,

	FILE_USER,

	FILE_UID,

	FILE_MODE,

	FILE_DEVICE,

	FILE_DEVICE_MAJOR,

	FILE_DEVICE_MINOR,

	FILE_DEVICENO,

	FILE_INODE,

	FILE_LINK,

	FILE_TYPE,

	FILE_NAME,

	FILE_ACL,

	FILE_ACL_DEFAULT,

	FILE_ACL_ACCESS,

	FILE_ACL_APPLEEXTENDED,

	/* BSD file flags. */

	FILE_FLAGS,

	FILE_FLAGS_USER_NODUMP,

	FILE_FLAGS_USER_IMMUTABLE,

	FILE_FLAGS_USER_APPEND,

	FILE_FLAGS_USER_OPAQUE,

	FILE_FLAGS_USER_NOUNLINK,

	FILE_FLAGS_SYS_ARCHIVED,

	FILE_FLAGS_SYS_IMMUTABLE,

	FILE_FLAGS_SYS_APPEND,

	FILE_FLAGS_SYS_NOUNLINK,

	FILE_FLAGS_SYS_SNAPSHOT,

	/* Linux file flags. */

	FILE_EXT2,

	FILE_EXT2_SecureDeletion,

	FILE_EXT2_Undelete,

	FILE_EXT2_Compress,

	FILE_EXT2_Synchronous,

	FILE_EXT2_Immutable,

	FILE_EXT2_AppendOnly,

	FILE_EXT2_NoDump,

	FILE_EXT2_NoAtime,

	FILE_EXT2_CompDirty,

	FILE_EXT2_CompBlock,

	FILE_EXT2_NoCompBlock,

	FILE_EXT2_CompError,

	FILE_EXT2_BTree,

	FILE_EXT2_HashIndexed,

	FILE_EXT2_iMagic,

	FILE_EXT2_Journaled,

	FILE_EXT2_NoTail,

	FILE_EXT2_DirSync,

	FILE_EXT2_TopDir,

	FILE_EXT2_Reserved,

	UNKNOWN,

};

struct unknown_tag {

	struct unknown_tag	*next;

	struct archive_string	 name;

};

struct xar {

	uint64_t		 offset; /* Current position in the file. */

	int64_t			 total;

	uint64_t		 h_base;

	int			 end_of_file;

#define OUTBUFF_SIZE	(1024 * 64)

	unsigned char		*outbuff;

	enum xmlstatus		 xmlsts;

	enum xmlstatus		 xmlsts_unknown;

	struct unknown_tag	*unknowntags;

	int			 base64text;

	/*

	 * TOC

	 */

	uint64_t		 toc_remaining;

	uint64_t		 toc_total;

	uint64_t		 toc_chksum_offset;

	uint64_t		 toc_chksum_size;

	/*

	 * For Decoding data.

	 */

	enum enctype 		 rd_encoding;

	z_stream		 stream;

	int			 stream_valid;

#if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)

	bz_stream		 bzstream;

	int			 bzstream_valid;

#endif

#if HAVE_LZMA_H && HAVE_LIBLZMA

	lzma_stream		 lzstream;

	int			 lzstream_valid;

#endif

	/*

	 * For Checksum data.

	 */

	struct chksumwork	 a_sumwrk;

	struct chksumwork	 e_sumwrk;

	struct xar_file		*file;	/* current reading file. */

	struct xattr		*xattr; /* current reading extended attribute. */

	struct heap_queue	 file_queue;

	struct xar_file		*hdlink_orgs;

	struct hdlink		*hdlink_list;

	int	 		 entry_init;

	uint64_t		 entry_total;

	uint64_t		 entry_remaining;

	size_t			 entry_unconsumed;

	uint64_t		 entry_size;

	enum enctype 		 entry_encoding;

	struct chksumval	 entry_a_sum;

	struct chksumval	 entry_e_sum;

	struct archive_string_conv *sconv;

};

struct xmlattr {

	struct xmlattr	*next;

	char		*name;

	char		*value;

};

struct xmlattr_list {

	struct xmlattr	*first;

	struct xmlattr	**last;

};

static int	xar_bid(struct archive_read *, int);

static int	xar_read_header(struct archive_read *,

		    struct archive_entry *);

static int	xar_read_data(struct archive_read *,

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

static int	xar_read_data_skip(struct archive_read *);

static int	xar_cleanup(struct archive_read *);

static int	move_reading_point(struct archive_read *, uint64_t);

static int	rd_contents_init(struct archive_read *,

		    enum enctype, int, int);

static int	rd_contents(struct archive_read *, const void **,

		    size_t *, size_t *, uint64_t);

static uint64_t	atol10(const char *, size_t);

static int64_t	atol8(const char *, size_t);

static size_t	atohex(unsigned char *, size_t, const char *, size_t);

static time_t	parse_time(const char *p, size_t n);

static int	heap_add_entry(struct archive_read *a,

    struct heap_queue *, struct xar_file *);

static struct xar_file *heap_get_entry(struct heap_queue *);

static int	add_link(struct archive_read *,

    struct xar *, struct xar_file *);

static void	checksum_init(struct archive_read *, int, int);

static void	checksum_update(struct archive_read *, const void *,

		    size_t, const void *, size_t);

static int	checksum_final(struct archive_read *, const void *,

		    size_t, const void *, size_t);

static void	checksum_cleanup(struct archive_read *);

static int	decompression_init(struct archive_read *, enum enctype);

static int	decompress(struct archive_read *, const void **,

		    size_t *, const void *, size_t *);

static int	decompression_cleanup(struct archive_read *);

static void	xmlattr_cleanup(struct xmlattr_list *);

static int	file_new(struct archive_read *,

    struct xar *, struct xmlattr_list *);

static void	file_free(struct xar_file *);

static int	xattr_new(struct archive_read *,

    struct xar *, struct xmlattr_list *);

static void	xattr_free(struct xattr *);

static int	getencoding(struct xmlattr_list *);

static int	getsumalgorithm(struct xmlattr_list *);

static int	unknowntag_start(struct archive_read *,

    struct xar *, const char *);

static void	unknowntag_end(struct xar *, const char *);

static int	xml_start(struct archive_read *,

    const char *, struct xmlattr_list *);

static void	xml_end(void *, const char *);

static void	xml_data(void *, const char *, int);

static int	xml_parse_file_flags(struct xar *, const char *);

static int	xml_parse_file_ext2(struct xar *, const char *);

#if defined(HAVE_LIBXML_XMLREADER_H)

static int	xml2_xmlattr_setup(struct archive_read *,

    struct xmlattr_list *, xmlTextReaderPtr);

static int	xml2_read_cb(void *, char *, int);

static int	xml2_close_cb(void *);

static void	xml2_error_hdr(void *, const char *, xmlParserSeverities,

		    xmlTextReaderLocatorPtr);

static int	xml2_read_toc(struct archive_read *);

#elif defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H)

struct expat_userData {

	int state;

	struct archive_read *archive;

};

static int	expat_xmlattr_setup(struct archive_read *,

    struct xmlattr_list *, const XML_Char **);

static void	expat_start_cb(void *, const XML_Char *, const XML_Char **);

static void	expat_end_cb(void *, const XML_Char *);

static void	expat_data_cb(void *, const XML_Char *, int);

static int	expat_read_toc(struct archive_read *);

#endif

int

archive_read_support_format_xar(struct archive *_a)

{

	struct xar *xar;

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

	int r;

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_read_support_format_xar");

	xar = (struct xar *)calloc(1, sizeof(*xar));

	if (xar == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate xar data");

		return (ARCHIVE_FATAL);

	}

	r = __archive_read_register_format(a,

	    xar,

	    "xar",

	    xar_bid,

	    NULL,

	    xar_read_header,

	    xar_read_data,

	    xar_read_data_skip,

	    NULL,

	    xar_cleanup,

	    NULL,

	    NULL);

	if (r != ARCHIVE_OK)

		free(xar);

	return (r);

}

static int

xar_bid(struct archive_read *a, int best_bid)

{

	const unsigned char *b;

	int bid;

	(void)best_bid; /* UNUSED */

	b = __archive_read_ahead(a, HEADER_SIZE, NULL);

	if (b == NULL)

		return (-1);

	bid = 0;

	/*

	 * Verify magic code

	 */

	if (archive_be32dec(b) != HEADER_MAGIC)

		return (0);

	bid += 32;

	/*

	 * Verify header size

	 */

	if (archive_be16dec(b+4) != HEADER_SIZE)

		return (0);

	bid += 16;

	/*

	 * Verify header version

	 */

	if (archive_be16dec(b+6) != HEADER_VERSION)

		return (0);

	bid += 16;

	/*

	 * Verify type of checksum

	 */

	switch (archive_be32dec(b+24)) {

	case CKSUM_NONE:

	case CKSUM_SHA1:

	case CKSUM_MD5:

		bid += 32;

		break;

	default:

		return (0);

	}

	return (bid);

}

static int

read_toc(struct archive_read *a)

{

	struct xar *xar;

	struct xar_file *file;

	const unsigned char *b;

	uint64_t toc_compressed_size;

	uint64_t toc_uncompressed_size;

	uint32_t toc_chksum_alg;

	ssize_t bytes;

	int r;

	xar = (struct xar *)(a->format->data);

	/*

	 * Read xar header.

	 */

	b = __archive_read_ahead(a, HEADER_SIZE, &bytes);

	if (bytes < 0)

		return ((int)bytes);

	if (bytes < HEADER_SIZE) {

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_FILE_FORMAT,

		    "Truncated archive header");

		return (ARCHIVE_FATAL);

	}

	if (archive_be32dec(b) != HEADER_MAGIC) {

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_FILE_FORMAT,

		    "Invalid header magic");

		return (ARCHIVE_FATAL);

	}

	if (archive_be16dec(b+6) != HEADER_VERSION) {

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_FILE_FORMAT,

		    "Unsupported header version(%d)",

		    archive_be16dec(b+6));

		return (ARCHIVE_FATAL);

	}

	toc_compressed_size = archive_be64dec(b+8);

	xar->toc_remaining = toc_compressed_size;

	toc_uncompressed_size = archive_be64dec(b+16);

	toc_chksum_alg = archive_be32dec(b+24);

	__archive_read_consume(a, HEADER_SIZE);

	xar->offset += HEADER_SIZE;

	xar->toc_total = 0;

	/*

	 * Read TOC(Table of Contents).

	 */

	/* Initialize reading contents. */

	r = move_reading_point(a, HEADER_SIZE);

	if (r != ARCHIVE_OK)

		return (r);

	r = rd_contents_init(a, GZIP, toc_chksum_alg, CKSUM_NONE);

	if (r != ARCHIVE_OK)

		return (r);

#ifdef HAVE_LIBXML_XMLREADER_H

	r = xml2_read_toc(a);

#elif defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H)

	r = expat_read_toc(a);

#endif

	if (r != ARCHIVE_OK)

		return (r);

	/* Set 'The HEAP' base. */

	xar->h_base = xar->offset;

	if (xar->toc_total != toc_uncompressed_size) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

		    "TOC uncompressed size error");

		return (ARCHIVE_FATAL);

	}

	/*

	 * Checksum TOC

	 */

	if (toc_chksum_alg != CKSUM_NONE) {

		r = move_reading_point(a, xar->toc_chksum_offset);

		if (r != ARCHIVE_OK)

			return (r);

		b = __archive_read_ahead(a,

			(size_t)xar->toc_chksum_size, &bytes);

		if (bytes < 0)

			return ((int)bytes);

		if ((uint64_t)bytes < xar->toc_chksum_size) {

			archive_set_error(&a->archive,

			    ARCHIVE_ERRNO_FILE_FORMAT,

			    "Truncated archive file");

			return (ARCHIVE_FATAL);

		}

		r = checksum_final(a, b,

			(size_t)xar->toc_chksum_size, NULL, 0);

		__archive_read_consume(a, xar->toc_chksum_size);

		xar->offset += xar->toc_chksum_size;

		if (r != ARCHIVE_OK)

			return (ARCHIVE_FATAL);

	}

	/*

	 * Connect hardlinked files.

	 */

	for (file = xar->hdlink_orgs; file != NULL; file = file->hdnext) {

		struct hdlink **hdlink;

		for (hdlink = &(xar->hdlink_list); *hdlink != NULL;

		    hdlink = &((*hdlink)->next)) {

			if ((*hdlink)->id == file->id) {

				struct hdlink *hltmp;

				struct xar_file *f2;

				int nlink = (*hdlink)->cnt + 1;

				file->nlink = nlink;

				for (f2 = (*hdlink)->files; f2 != NULL;

				    f2 = f2->hdnext) {

					f2->nlink = nlink;

					archive_string_copy(

					    &(f2->hardlink), &(file->pathname));

				}

				/* Remove resolved files from hdlist_list. */

				hltmp = *hdlink;

				*hdlink = hltmp->next;

				free(hltmp);

				break;

			}

		}

	}

	a->archive.archive_format = ARCHIVE_FORMAT_XAR;

	a->archive.archive_format_name = "xar";

	return (ARCHIVE_OK);

}

static int

xar_read_header(struct archive_read *a, struct archive_entry *entry)

{

	struct xar *xar;

	struct xar_file *file;

	struct xattr *xattr;

	int r;

	xar = (struct xar *)(a->format->data);

	r = ARCHIVE_OK;

	if (xar->offset == 0) {

		/* Create a character conversion object. */

		if (xar->sconv == NULL) {

			xar->sconv = archive_string_conversion_from_charset(

			    &(a->archive), "UTF-8", 1);

			if (xar->sconv == NULL)

				return (ARCHIVE_FATAL);

		}

		/* Read TOC. */

		r = read_toc(a);

		if (r != ARCHIVE_OK)

			return (r);

	}

	for (;;) {

		file = xar->file = heap_get_entry(&(xar->file_queue));

		if (file == NULL) {

			xar->end_of_file = 1;

			return (ARCHIVE_EOF);

		}

		if ((file->mode & AE_IFMT) != AE_IFDIR)

			break;

		if (file->has != (HAS_PATHNAME | HAS_TYPE))

			break;

		/*

		 * If a file type is a directory and it does not have

		 * any metadata, do not export.

		 */

		file_free(file);

	}

	archive_entry_set_atime(entry, file->atime, 0);

	archive_entry_set_ctime(entry, file->ctime, 0);

	archive_entry_set_mtime(entry, file->mtime, 0);

	archive_entry_set_gid(entry, file->gid);

	if (file->gname.length > 0 &&

	    archive_entry_copy_gname_l(entry, file->gname.s,

		archive_strlen(&(file->gname)), xar->sconv) != 0) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM,

			    "Can't allocate memory for Gname");

			return (ARCHIVE_FATAL);

		}

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_FILE_FORMAT,

		    "Gname cannot be converted from %s to current locale.",

		    archive_string_conversion_charset_name(xar->sconv));

		r = ARCHIVE_WARN;

	}

	archive_entry_set_uid(entry, file->uid);

	if (file->uname.length > 0 &&

	    archive_entry_copy_uname_l(entry, file->uname.s,

		archive_strlen(&(file->uname)), xar->sconv) != 0) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM,

			    "Can't allocate memory for Uname");

			return (ARCHIVE_FATAL);

		}

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_FILE_FORMAT,

		    "Uname cannot be converted from %s to current locale.",

		    archive_string_conversion_charset_name(xar->sconv));

		r = ARCHIVE_WARN;

	}

	archive_entry_set_mode(entry, file->mode);

	if (archive_entry_copy_pathname_l(entry, file->pathname.s,

	    archive_strlen(&(file->pathname)), xar->sconv) != 0) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM,

			    "Can't allocate memory for Pathname");

			return (ARCHIVE_FATAL);

		}

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_FILE_FORMAT,

		    "Pathname cannot be converted from %s to current locale.",

		    archive_string_conversion_charset_name(xar->sconv));

		r = ARCHIVE_WARN;

	}

	if (file->symlink.length > 0 &&

	    archive_entry_copy_symlink_l(entry, file->symlink.s,

		archive_strlen(&(file->symlink)), xar->sconv) != 0) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM,

			    "Can't allocate memory for Linkname");

			return (ARCHIVE_FATAL);

		}

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_FILE_FORMAT,

		    "Linkname cannot be converted from %s to current locale.",

		    archive_string_conversion_charset_name(xar->sconv));

		r = ARCHIVE_WARN;

	}

	/* Set proper nlink. */

	if ((file->mode & AE_IFMT) == AE_IFDIR)

		archive_entry_set_nlink(entry, file->subdirs + 2);

	else

		archive_entry_set_nlink(entry, file->nlink);

	archive_entry_set_size(entry, file->size);

	if (archive_strlen(&(file->hardlink)) > 0)

		archive_entry_set_hardlink(entry, file->hardlink.s);

	archive_entry_set_ino64(entry, file->ino64);

	if (file->has & HAS_DEV)

		archive_entry_set_dev(entry, file->dev);

	if (file->has & HAS_DEVMAJOR)

		archive_entry_set_devmajor(entry, file->devmajor);

	if (file->has & HAS_DEVMINOR)

		archive_entry_set_devminor(entry, file->devminor);

	if (archive_strlen(&(file->fflags_text)) > 0)

		archive_entry_copy_fflags_text(entry, file->fflags_text.s);

	xar->entry_init = 1;

	xar->entry_total = 0;

	xar->entry_remaining = file->length;

	xar->entry_size = file->size;

	xar->entry_encoding = file->encoding;

	xar->entry_a_sum = file->a_sum;

	xar->entry_e_sum = file->e_sum;

	/*

	 * Read extended attributes.

	 */

	xattr = file->xattr_list;

	while (xattr != NULL) {

		const void *d;

		size_t outbytes, used;

		r = move_reading_point(a, xattr->offset);

		if (r != ARCHIVE_OK)

			break;

		r = rd_contents_init(a, xattr->encoding,

		    xattr->a_sum.alg, xattr->e_sum.alg);

		if (r != ARCHIVE_OK)

			break;

		d = NULL;

		r = rd_contents(a, &d, &outbytes, &used, xattr->length);

		if (r != ARCHIVE_OK)

			break;

		if (outbytes != xattr->size) {

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

			    "Decompressed size error");

			r = ARCHIVE_FATAL;

			break;

		}

		r = checksum_final(a,

		    xattr->a_sum.val, xattr->a_sum.len,

		    xattr->e_sum.val, xattr->e_sum.len);

		if (r != ARCHIVE_OK)

			break;

		archive_entry_xattr_add_entry(entry,

		    xattr->name.s, d, outbytes);

		xattr = xattr->next;

	}

	if (r != ARCHIVE_OK) {

		file_free(file);

		return (r);

	}

	if (xar->entry_remaining > 0)

		/* Move reading point to the beginning of current

		 * file contents. */

		r = move_reading_point(a, file->offset);

	else

		r = ARCHIVE_OK;

	file_free(file);

	return (r);

}

static int

xar_read_data(struct archive_read *a,

    const void **buff, size_t *size, int64_t *offset)

{

	struct xar *xar;

	size_t used;

	int r;

	xar = (struct xar *)(a->format->data);

	if (xar->entry_unconsumed) {

		__archive_read_consume(a, xar->entry_unconsumed);

		xar->entry_unconsumed = 0;

	}

	if (xar->end_of_file || xar->entry_remaining <= 0) {

		r = ARCHIVE_EOF;

		goto abort_read_data;

	}

	if (xar->entry_init) {

		r = rd_contents_init(a, xar->entry_encoding,

		    xar->entry_a_sum.alg, xar->entry_e_sum.alg);

		if (r != ARCHIVE_OK) {

			xar->entry_remaining = 0;

			return (r);

		}

		xar->entry_init = 0;

	}

	*buff = NULL;

	r = rd_contents(a, buff, size, &used, xar->entry_remaining);

	if (r != ARCHIVE_OK)

		goto abort_read_data;

	*offset = xar->entry_total;

	xar->entry_total += *size;

	xar->total += *size;

	xar->offset += used;

	xar->entry_remaining -= used;

	xar->entry_unconsumed = used;

	if (xar->entry_remaining == 0) {

		if (xar->entry_total != xar->entry_size) {

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