/*-

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

#ifdef HAVE_BZLIB_H

#include <bzlib.h>

#endif

#ifdef HAVE_LZMA_H

#include <lzma.h>

#endif

#ifdef HAVE_ZLIB_H

#include <zlib.h>

#endif

#include "archive.h"

#include "archive_entry.h"

#include "archive_entry_locale.h"

#include "archive_ppmd7_private.h"

#include "archive_private.h"

#include "archive_read_private.h"

#include "archive_endian.h"

#ifndef HAVE_ZLIB_H

#include "archive_crc32.h"

#endif

#define _7ZIP_SIGNATURE	"7z\xBC\xAF\x27\x1C"

#define SFX_MIN_ADDR	0x27000

#define SFX_MAX_ADDR	0x60000

/*

 * Codec ID

 */

#define _7Z_COPY	0

#define _7Z_LZMA	0x030101

#define _7Z_LZMA2	0x21

#define _7Z_DEFLATE	0x040108

#define _7Z_BZ2		0x040202

#define _7Z_PPMD	0x030401

#define _7Z_DELTA	0x03

#define _7Z_CRYPTO_MAIN_ZIP			0x06F10101 /* Main Zip crypto algo */

#define _7Z_CRYPTO_RAR_29			0x06F10303 /* Rar29 AES-128 + (modified SHA-1) */

#define _7Z_CRYPTO_AES_256_SHA_256	0x06F10701 /* AES-256 + SHA-256 */

#define _7Z_X86		0x03030103

#define _7Z_X86_BCJ2	0x0303011B

#define _7Z_POWERPC	0x03030205

#define _7Z_IA64	0x03030401

#define _7Z_ARM		0x03030501

#define _7Z_ARMTHUMB	0x03030701

#define _7Z_SPARC	0x03030805

/*

 * 7-Zip header property IDs.

 */

#define kEnd			0x00

#define kHeader			0x01

#define kArchiveProperties	0x02

#define kAdditionalStreamsInfo	0x03

#define kMainStreamsInfo	0x04

#define kFilesInfo		0x05

#define kPackInfo		0x06

#define kUnPackInfo		0x07

#define kSubStreamsInfo		0x08

#define kSize			0x09

#define kCRC			0x0A

#define kFolder			0x0B

#define kCodersUnPackSize	0x0C

#define kNumUnPackStream	0x0D

#define kEmptyStream		0x0E

#define kEmptyFile		0x0F

#define kAnti			0x10

#define kName			0x11

#define kCTime			0x12

#define kATime			0x13

#define kMTime			0x14

#define kAttributes		0x15

#define kEncodedHeader		0x17

#define kDummy			0x19

struct _7z_digests {

	unsigned char	*defineds;

	uint32_t	*digests;

};

struct _7z_folder {

	uint64_t		 numCoders;

	struct _7z_coder {

		unsigned long	 codec;

		uint64_t	 numInStreams;

		uint64_t	 numOutStreams;

		uint64_t	 propertiesSize;

		unsigned char	*properties;

	} *coders;

	uint64_t		 numBindPairs;

	struct {

		uint64_t	 inIndex;

		uint64_t	 outIndex;

	} *bindPairs;

	uint64_t		 numPackedStreams;

	uint64_t		*packedStreams;

	uint64_t		 numInStreams;

	uint64_t		 numOutStreams;

	uint64_t		*unPackSize;

	unsigned char		 digest_defined;

	uint32_t		 digest;

	uint64_t		 numUnpackStreams;

	uint32_t		 packIndex;

	/* Unoperated bytes. */

	uint64_t		 skipped_bytes;

};

struct _7z_coders_info {

	uint64_t		 numFolders;

	struct _7z_folder	*folders;

	uint64_t		 dataStreamIndex;

};

struct _7z_pack_info {

	uint64_t		 pos;

	uint64_t		 numPackStreams;

	uint64_t		*sizes;

	struct _7z_digests	 digest;

	/* Calculated from pos and numPackStreams. */

	uint64_t		*positions;

};

struct _7z_substream_info {

	size_t			 unpack_streams;

	uint64_t		*unpackSizes;

	unsigned char		*digestsDefined;

	uint32_t		*digests;

};

struct _7z_stream_info {

	struct _7z_pack_info	 pi;

	struct _7z_coders_info	 ci;

	struct _7z_substream_info ss;

};

struct _7z_header_info {

	uint64_t		 dataIndex;

	unsigned char		*emptyStreamBools;

	unsigned char		*emptyFileBools;

	unsigned char		*antiBools;

	unsigned char		*attrBools;

};

struct _7zip_entry {

	size_t			 name_len;

	unsigned char		*utf16name;

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

	const wchar_t		*wname;

#endif

	uint32_t		 folderIndex;

	uint32_t		 ssIndex;

	unsigned		 flg;

#define MTIME_IS_SET	(1<<0)

#define ATIME_IS_SET	(1<<1)

#define CTIME_IS_SET	(1<<2)

#define CRC32_IS_SET	(1<<3)

#define HAS_STREAM	(1<<4)

	time_t			 mtime;

	time_t			 atime;

	time_t			 ctime;

	long			 mtime_ns;

	long			 atime_ns;

	long			 ctime_ns;

	uint32_t		 mode;

	uint32_t		 attr;

};

struct _7zip {

	/* Structural information about the archive. */

	struct _7z_stream_info	 si;

	int			 header_is_being_read;

	int			 header_is_encoded;

	uint64_t		 header_bytes_remaining;

	unsigned long		 header_crc32;

	/* Header offset to check that reading points of the file contents

	 * will not exceed the header. */

	uint64_t		 header_offset;

	/* Base offset of the archive file for a seek in case reading SFX. */

	uint64_t		 seek_base;

	/* List of entries */

	size_t			 entries_remaining;

	uint64_t		 numFiles;

	struct _7zip_entry	*entries;

	struct _7zip_entry	*entry;

	unsigned char		*entry_names;

	/* entry_bytes_remaining is the number of bytes we expect. */

	int64_t			 entry_offset;

	uint64_t		 entry_bytes_remaining;

	/* Running CRC32 of the decompressed data */

	unsigned long		 entry_crc32;

	/* Flags to mark progress of decompression. */

	char			 end_of_entry;

	/* Uncompressed buffer control.  */

#define UBUFF_SIZE	(64 * 1024)

	unsigned char 		*uncompressed_buffer;

	unsigned char 		*uncompressed_buffer_pointer;

	size_t 			 uncompressed_buffer_size;

	size_t			 uncompressed_buffer_bytes_remaining;

	/* Offset of the compressed data. */

	int64_t			 stream_offset;

	/*

	 * Decompressing control data.

	 */

	unsigned		 folder_index;

	uint64_t		 folder_outbytes_remaining;

	unsigned		 pack_stream_index;

	unsigned		 pack_stream_remaining;

	uint64_t		 pack_stream_inbytes_remaining;

	size_t			 pack_stream_bytes_unconsumed;

	/* The codec information of a folder. */

	unsigned long		 codec;

	unsigned long		 codec2;

	/*

	 * Decompressor controllers.

	 */

	/* Decoding LZMA1 and LZMA2 data. */

#ifdef HAVE_LZMA_H

	lzma_stream		 lzstream;

	int			 lzstream_valid;

#endif

	/* Decoding bzip2 data. */

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

	bz_stream		 bzstream;

	int			 bzstream_valid;

#endif

	/* Decoding deflate data. */

#ifdef HAVE_ZLIB_H

	z_stream		 stream;

	int			 stream_valid;

#endif

	/* Decoding PPMd data. */

	int			 ppmd7_stat;

	CPpmd7			 ppmd7_context;

	CPpmd7z_RangeDec	 range_dec;

	IByteIn			 bytein;

	struct {

		const unsigned char	*next_in;

		int64_t			 avail_in;

		int64_t			 total_in;

		unsigned char		*next_out;

		int64_t			 avail_out;

		int64_t			 total_out;

		int			 overconsumed;

	} ppstream;

	int			 ppmd7_valid;

	/* Decoding BCJ and BCJ2 data. */

	uint32_t		 bcj_state;

	size_t			 odd_bcj_size;

	unsigned char		 odd_bcj[4];

	/* Decoding BCJ data. */

	size_t			 bcj_prevPosT;

	uint32_t		 bcj_prevMask;

	uint32_t		 bcj_ip;

	/* Decoding BCJ2 data. */

	size_t			 main_stream_bytes_remaining;

	unsigned char		*sub_stream_buff[3];

	size_t			 sub_stream_size[3];

	size_t			 sub_stream_bytes_remaining[3];

	unsigned char		*tmp_stream_buff;

	size_t			 tmp_stream_buff_size;

	size_t			 tmp_stream_bytes_avail;

	size_t			 tmp_stream_bytes_remaining;

#ifdef _LZMA_PROB32

#define CProb uint32_t

#else

#define CProb uint16_t

#endif

	CProb			 bcj2_p[256 + 2];

	uint8_t			 bcj2_prevByte;

	uint32_t		 bcj2_range;

	uint32_t		 bcj2_code;

	uint64_t		 bcj2_outPos;

	/* Filename character-set conversion data. */

	struct archive_string_conv *sconv;

	char			 format_name[64];

	/* Custom value that is non-zero if this archive contains encrypted entries. */

	int			 has_encrypted_entries;

};

/* Maximum entry size. This limitation prevents reading intentional

 * corrupted 7-zip files on assuming there are not so many entries in

 * the files. */

#define UMAX_ENTRY	ARCHIVE_LITERAL_ULL(100000000)

static int	archive_read_format_7zip_has_encrypted_entries(struct archive_read *);

static int	archive_read_support_format_7zip_capabilities(struct archive_read *a);

static int	archive_read_format_7zip_bid(struct archive_read *, int);

static int	archive_read_format_7zip_cleanup(struct archive_read *);

static int	archive_read_format_7zip_read_data(struct archive_read *,

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

static int	archive_read_format_7zip_read_data_skip(struct archive_read *);

static int	archive_read_format_7zip_read_header(struct archive_read *,

		    struct archive_entry *);

static int	check_7zip_header_in_sfx(const char *);

static unsigned long decode_codec_id(const unsigned char *, size_t);

static int	decode_encoded_header_info(struct archive_read *,

		    struct _7z_stream_info *);

static int	decompress(struct archive_read *, struct _7zip *,

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

static ssize_t	extract_pack_stream(struct archive_read *, size_t);

static void	fileTimeToUtc(uint64_t, time_t *, long *);

static uint64_t folder_uncompressed_size(struct _7z_folder *);

static void	free_CodersInfo(struct _7z_coders_info *);

static void	free_Digest(struct _7z_digests *);

static void	free_Folder(struct _7z_folder *);

static void	free_Header(struct _7z_header_info *);

static void	free_PackInfo(struct _7z_pack_info *);

static void	free_StreamsInfo(struct _7z_stream_info *);

static void	free_SubStreamsInfo(struct _7z_substream_info *);

static int	free_decompression(struct archive_read *, struct _7zip *);

static ssize_t	get_uncompressed_data(struct archive_read *, const void **,

		    size_t, size_t);

static const unsigned char * header_bytes(struct archive_read *, size_t);

static int	init_decompression(struct archive_read *, struct _7zip *,

		    const struct _7z_coder *, const struct _7z_coder *);

static int	parse_7zip_uint64(struct archive_read *, uint64_t *);

static int	read_Bools(struct archive_read *, unsigned char *, size_t);

static int	read_CodersInfo(struct archive_read *,

		    struct _7z_coders_info *);

static int	read_Digests(struct archive_read *, struct _7z_digests *,

		    size_t);

static int	read_Folder(struct archive_read *, struct _7z_folder *);

static int	read_Header(struct archive_read *, struct _7z_header_info *,

		    int);

static int	read_PackInfo(struct archive_read *, struct _7z_pack_info *);

static int	read_StreamsInfo(struct archive_read *,

		    struct _7z_stream_info *);

static int	read_SubStreamsInfo(struct archive_read *,

		    struct _7z_substream_info *, struct _7z_folder *, size_t);

static int	read_Times(struct archive_read *, struct _7z_header_info *,

		    int);

static void	read_consume(struct archive_read *);

static ssize_t	read_stream(struct archive_read *, const void **, size_t,

		    size_t);

static int	seek_pack(struct archive_read *);

static int64_t	skip_stream(struct archive_read *, size_t);

static int	skip_sfx(struct archive_read *, ssize_t);

static int	slurp_central_directory(struct archive_read *, struct _7zip *,

		    struct _7z_header_info *);

static int	setup_decode_folder(struct archive_read *, struct _7z_folder *,

		    int);

static void	x86_Init(struct _7zip *);

static size_t	x86_Convert(struct _7zip *, uint8_t *, size_t);

static ssize_t		Bcj2_Decode(struct _7zip *, uint8_t *, size_t);

int

archive_read_support_format_7zip(struct archive *_a)

{

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

	struct _7zip *zip;

	int r;

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_read_support_format_7zip");

	zip = calloc(1, sizeof(*zip));

	if (zip == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate 7zip data");

		return (ARCHIVE_FATAL);

	}

	/*

	 * Until enough data has been read, we cannot tell about

	 * any encrypted entries yet.

	 */

	zip->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;

	r = __archive_read_register_format(a,

	    zip,

	    "7zip",

	    archive_read_format_7zip_bid,

	    NULL,

	    archive_read_format_7zip_read_header,

	    archive_read_format_7zip_read_data,

	    archive_read_format_7zip_read_data_skip,

	    NULL,

	    archive_read_format_7zip_cleanup,

	    archive_read_support_format_7zip_capabilities,

	    archive_read_format_7zip_has_encrypted_entries);

	if (r != ARCHIVE_OK)

		free(zip);

	return (ARCHIVE_OK);

}

static int

archive_read_support_format_7zip_capabilities(struct archive_read * a)

{

	(void)a; /* UNUSED */

	return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA |

			ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA);

}

static int

archive_read_format_7zip_has_encrypted_entries(struct archive_read *_a)

{

	if (_a && _a->format) {

		struct _7zip * zip = (struct _7zip *)_a->format->data;

		if (zip) {

			return zip->has_encrypted_entries;

		}

	}

	return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;

}

static int

archive_read_format_7zip_bid(struct archive_read *a, int best_bid)

{

	const char *p;

	/* If someone has already bid more than 32, then avoid

	   trashing the look-ahead buffers with a seek. */

	if (best_bid > 32)

		return (-1);

	if ((p = __archive_read_ahead(a, 6, NULL)) == NULL)

		return (0);

	/* If first six bytes are the 7-Zip signature,

	 * return the bid right now. */

	if (memcmp(p, _7ZIP_SIGNATURE, 6) == 0)

		return (48);

	/*

	 * It may a 7-Zip SFX archive file. If first two bytes are

	 * 'M' and 'Z' available on Windows or first four bytes are

	 * "\x7F\x45LF" available on posix like system, seek the 7-Zip

	 * signature. Although we will perform a seek when reading

	 * a header, what we do not use __archive_read_seek() here is

	 * due to a bidding performance.

	 */

	if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {

		ssize_t offset = SFX_MIN_ADDR;

		ssize_t window = 4096;

		ssize_t bytes_avail;

		while (offset + window <= (SFX_MAX_ADDR)) {

			const char *buff = __archive_read_ahead(a,

					offset + window, &bytes_avail);

			if (buff == NULL) {

				/* Remaining bytes are less than window. */

				window >>= 1;

				if (window < 0x40)

					return (0);

				continue;

			}

			p = buff + offset;

			while (p + 32 < buff + bytes_avail) {

				int step = check_7zip_header_in_sfx(p);

				if (step == 0)

					return (48);

				p += step;

			}

			offset = p - buff;

		}

	}

	return (0);

}

static int

check_7zip_header_in_sfx(const char *p)

{

	switch ((unsigned char)p[5]) {

	case 0x1C:

		if (memcmp(p, _7ZIP_SIGNATURE, 6) != 0)

			return (6);

		/*

		 * Test the CRC because its extraction code has 7-Zip

		 * Magic Code, so we should do this in order not to

		 * make a mis-detection.

		 */

		if (crc32(0, (const unsigned char *)p + 12, 20)

			!= archive_le32dec(p + 8))

			return (6);

		/* Hit the header! */

		return (0);

	case 0x37: return (5);

	case 0x7A: return (4);

	case 0xBC: return (3);

	case 0xAF: return (2);

	case 0x27: return (1);

	default: return (6);

	}

}

static int

skip_sfx(struct archive_read *a, ssize_t bytes_avail)

{

	const void *h;

	const char *p, *q;

	size_t skip, offset;

	ssize_t bytes, window;

	/*

	 * If bytes_avail > SFX_MIN_ADDR we do not have to call

	 * __archive_read_seek() at this time since we have

	 * already had enough data.

	 */

	if (bytes_avail > SFX_MIN_ADDR)

		__archive_read_consume(a, SFX_MIN_ADDR);

	else if (__archive_read_seek(a, SFX_MIN_ADDR, SEEK_SET) < 0)

		return (ARCHIVE_FATAL);

	offset = 0;

	window = 1;

	while (offset + window <= SFX_MAX_ADDR - SFX_MIN_ADDR) {

		h = __archive_read_ahead(a, window, &bytes);

		if (h == NULL) {

			/* Remaining bytes are less than window. */

			window >>= 1;

			if (window < 0x40)

				goto fatal;

			continue;

		}

		if (bytes < 6) {

			/* This case might happen when window == 1. */

			window = 4096;

			continue;

		}

		p = (const char *)h;

		q = p + bytes;

		/*

		 * Scan ahead until we find something that looks

		 * like the 7-Zip header.

		 */

		while (p + 32 < q) {

			int step = check_7zip_header_in_sfx(p);

			if (step == 0) {

				struct _7zip *zip =

				    (struct _7zip *)a->format->data;

				skip = p - (const char *)h;

				__archive_read_consume(a, skip);

				zip->seek_base = SFX_MIN_ADDR + offset + skip;

				return (ARCHIVE_OK);

			}

			p += step;

		}

		skip = p - (const char *)h;

		__archive_read_consume(a, skip);

		offset += skip;

		if (window == 1)

			window = 4096;

	}

fatal:

	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

	    "Couldn't find out 7-Zip header");

	return (ARCHIVE_FATAL);

}

static int

archive_read_format_7zip_read_header(struct archive_read *a,

	struct archive_entry *entry)

{

	struct _7zip *zip = (struct _7zip *)a->format->data;

	struct _7zip_entry *zip_entry;

	int r, ret = ARCHIVE_OK;

	struct _7z_folder *folder = 0;

	uint64_t fidx = 0;

	/*

	 * It should be sufficient to call archive_read_next_header() for

	 * a reader to determine if an entry is encrypted or not. If the

	 * encryption of an entry is only detectable when calling

	 * archive_read_data(), so be it. We'll do the same check there

	 * as well.

	 */

	if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {

		zip->has_encrypted_entries = 0;

	}

	a->archive.archive_format = ARCHIVE_FORMAT_7ZIP;

	if (a->archive.archive_format_name == NULL)

		a->archive.archive_format_name = "7-Zip";

	if (zip->entries == NULL) {

		struct _7z_header_info header;

		memset(&header, 0, sizeof(header));

		r = slurp_central_directory(a, zip, &header);

		free_Header(&header);

		if (r != ARCHIVE_OK)

			return (r);

		zip->entries_remaining = (size_t)zip->numFiles;

		zip->entry = zip->entries;

	} else {

		++zip->entry;

	}

	zip_entry = zip->entry;

	if (zip->entries_remaining <= 0 || zip_entry == NULL)

		return ARCHIVE_EOF;

	--zip->entries_remaining;

	zip->entry_offset = 0;

	zip->end_of_entry = 0;

	zip->entry_crc32 = crc32(0, NULL, 0);

	/* Setup a string conversion for a filename. */

	if (zip->sconv == NULL) {

		zip->sconv = archive_string_conversion_from_charset(

		    &a->archive, "UTF-16LE", 1);

		if (zip->sconv == NULL)

			return (ARCHIVE_FATAL);

	}

	/* Figure out if the entry is encrypted by looking at the folder

	   that is associated to the current 7zip entry. If the folder

	   has a coder with a _7Z_CRYPTO codec then the folder is encrypted.

	   Hence the entry must also be encrypted. */

	if (zip_entry && zip_entry->folderIndex < zip->si.ci.numFolders) {

		folder = &(zip->si.ci.folders[zip_entry->folderIndex]);

		for (fidx=0; folder && fidx<folder->numCoders; fidx++) {

			switch(folder->coders[fidx].codec) {

				case _7Z_CRYPTO_MAIN_ZIP:

				case _7Z_CRYPTO_RAR_29:

				case _7Z_CRYPTO_AES_256_SHA_256: {

					archive_entry_set_is_data_encrypted(entry, 1);

					zip->has_encrypted_entries = 1;

					break;

				}

			}

		}

	}

	/* Now that we've checked for encryption, if there were still no

	 * encrypted entries found we can say for sure that there are none.

	 */

	if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {

		zip->has_encrypted_entries = 0;

	}

	if (archive_entry_copy_pathname_l(entry,

	    (const char *)zip_entry->utf16name,

	    zip_entry->name_len, zip->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(zip->sconv));

		ret = ARCHIVE_WARN;

	}

	/* Populate some additional entry fields: */

	archive_entry_set_mode(entry, zip_entry->mode);

	if (zip_entry->flg & MTIME_IS_SET)

		archive_entry_set_mtime(entry, zip_entry->mtime,

			zip_entry->mtime_ns);

	if (zip_entry->flg & CTIME_IS_SET)

		archive_entry_set_ctime(entry, zip_entry->ctime,

		    zip_entry->ctime_ns);

	if (zip_entry->flg & ATIME_IS_SET)

		archive_entry_set_atime(entry, zip_entry->atime,

		    zip_entry->atime_ns);

	if (zip_entry->ssIndex != (uint32_t)-1) {

		zip->entry_bytes_remaining =

		    zip->si.ss.unpackSizes[zip_entry->ssIndex];

		archive_entry_set_size(entry, zip->entry_bytes_remaining);

	} else {

		zip->entry_bytes_remaining = 0;

		archive_entry_set_size(entry, 0);

	}

	/* If there's no body, force read_data() to return EOF immediately. */

	if (zip->entry_bytes_remaining < 1)

		zip->end_of_entry = 1;

	if ((zip_entry->mode & AE_IFMT) == AE_IFLNK) {

		unsigned char *symname = NULL;

		size_t symsize = 0;

		/*

		 * Symbolic-name is recorded as its contents. We have to

		 * read the contents at this time.

		 */

		while (zip->entry_bytes_remaining > 0) {

			const void *buff;

			unsigned char *mem;

			size_t size;

			int64_t offset;

			r = archive_read_format_7zip_read_data(a, &buff,

				&size, &offset);

			if (r < ARCHIVE_WARN) {

				free(symname);

				return (r);

			}

			mem = realloc(symname, symsize + size + 1);

			if (mem == NULL) {

				free(symname);

				archive_set_error(&a->archive, ENOMEM,

				    "Can't allocate memory for Symname");

				return (ARCHIVE_FATAL);

			}

			symname = mem;

			memcpy(symname+symsize, buff, size);

			symsize += size;

		}

		if (symsize == 0) {

			/* If there is no symname, handle it as a regular

			 * file. */

			zip_entry->mode &= ~AE_IFMT;

			zip_entry->mode |= AE_IFREG;

			archive_entry_set_mode(entry, zip_entry->mode);

		} else {

			symname[symsize] = '\0';

			archive_entry_copy_symlink(entry,

			    (const char *)symname);

		}

		free(symname);

		archive_entry_set_size(entry, 0);

	}

	/* Set up a more descriptive format name. */

	sprintf(zip->format_name, "7-Zip");

	a->archive.archive_format_name = zip->format_name;

	return (ret);

}

static int

archive_read_format_7zip_read_data(struct archive_read *a,

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

{

	struct _7zip *zip;

	ssize_t bytes;

	int ret = ARCHIVE_OK;

	zip = (struct _7zip *)(a->format->data);

	if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {

		zip->has_encrypted_entries = 0;

	}

	if (zip->pack_stream_bytes_unconsumed)

		read_consume(a);

	*offset = zip->entry_offset;

	*size = 0;

	*buff = NULL;

	/*

	 * If we hit end-of-entry last time, clean up and return

	 * ARCHIVE_EOF this time.

	 */

	if (zip->end_of_entry)

		return (ARCHIVE_EOF);

	bytes = read_stream(a, buff,

		(size_t)zip->entry_bytes_remaining, 0);

	if (bytes < 0)

		return ((int)bytes);

	if (bytes == 0) {

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_FILE_FORMAT,

		    "Truncated 7-Zip file body");

		return (ARCHIVE_FATAL);

	}

	zip->entry_bytes_remaining -= bytes;

	if (zip->entry_bytes_remaining == 0)

		zip->end_of_entry = 1;

	/* Update checksum */

	if ((zip->entry->flg & CRC32_IS_SET) && bytes)

		zip->entry_crc32 = crc32(zip->entry_crc32, *buff,

		    (unsigned)bytes);

	/* If we hit the end, swallow any end-of-data marker. */

	if (zip->end_of_entry) {

		/* Check computed CRC against file contents. */

		if ((zip->entry->flg & CRC32_IS_SET) &&

			zip->si.ss.digests[zip->entry->ssIndex] !=

		    zip->entry_crc32) {

			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

			    "7-Zip bad CRC: 0x%lx should be 0x%lx",

			    (unsigned long)zip->entry_crc32,

			    (unsigned long)zip->si.ss.digests[

			    		zip->entry->ssIndex]);

			ret = ARCHIVE_WARN;

		}

	}

	*size = bytes;

	*offset = zip->entry_offset;

	zip->entry_offset += bytes;

	return (ret);

}

static int

archive_read_format_7zip_read_data_skip(struct archive_read *a)

{

	struct _7zip *zip;

	int64_t bytes_skipped;

	zip = (struct _7zip *)(a->format->data);

	if (zip->pack_stream_bytes_unconsumed)

		read_consume(a);

	/* If we've already read to end of data, we're done. */

	if (zip->end_of_entry)

		return (ARCHIVE_OK);

	/*

	 * If the length is at the beginning, we can skip the

	 * compressed data much more quickly.

	 */

	bytes_skipped = skip_stream(a, (size_t)zip->entry_bytes_remaining);

	if (bytes_skipped < 0)

		return (ARCHIVE_FATAL);

	zip->entry_bytes_remaining = 0;

	/* This entry is finished and done. */

	zip->end_of_entry = 1;

	return (ARCHIVE_OK);

}