/*-

 * Copyright (c) 2004-2013 Tim Kientzle

 * Copyright (c) 2011-2012,2014 Michihiro NAKAJIMA

 * Copyright (c) 2013 Konrad Kleine

 * 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: head/lib/libarchive/archive_read_support_format_zip.c 201102 2009-12-28 03:11:36Z kientzle $");

/*

 * The definitive documentation of the Zip file format is:

 *   http://www.pkware.com/documents/casestudies/APPNOTE.TXT

 *

 * The Info-Zip project has pioneered various extensions to better

 * support Zip on Unix, including the 0x5455 "UT", 0x5855 "UX", 0x7855

 * "Ux", and 0x7875 "ux" extensions for time and ownership

 * information.

 *

 * History of this code: The streaming Zip reader was first added to

 * libarchive in January 2005.  Support for seekable input sources was

 * added in Nov 2011.  Zip64 support (including a significant code

 * refactoring) was added in 2014.

 */

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_ZLIB_H

#include <zlib.h>

#endif

#include "archive.h"

#include "archive_digest_private.h"

#include "archive_cryptor_private.h"

#include "archive_endian.h"

#include "archive_entry.h"

#include "archive_entry_locale.h"

#include "archive_hmac_private.h"

#include "archive_private.h"

#include "archive_rb.h"

#include "archive_read_private.h"

#ifndef HAVE_ZLIB_H

#include "archive_crc32.h"

#endif

struct zip_entry {

	struct archive_rb_node	node;

	struct zip_entry	*next;

	int64_t			local_header_offset;

	int64_t			compressed_size;

	int64_t			uncompressed_size;

	int64_t			gid;

	int64_t			uid;

	struct archive_string	rsrcname;

	time_t			mtime;

	time_t			atime;

	time_t			ctime;

	uint32_t		crc32;

	uint16_t		mode;

	uint16_t		zip_flags; /* From GP Flags Field */

	unsigned char		compression;

	unsigned char		system; /* From "version written by" */

	unsigned char		flags; /* Our extra markers. */

	unsigned char		decdat;/* Used for Decryption check */

	/* WinZip AES encryption extra field should be available

	 * when compression is 99. */

	struct {

		/* Vendor version: AE-1 - 0x0001, AE-2 - 0x0002 */

		unsigned	vendor;

#define AES_VENDOR_AE_1	0x0001

#define AES_VENDOR_AE_2	0x0002

		/* AES encryption strength:

		 * 1 - 128 bits, 2 - 192 bits, 2 - 256 bits. */

		unsigned	strength;

		/* Actual compression method. */

		unsigned char	compression;

	}			aes_extra;

};

struct trad_enc_ctx {

	uint32_t	keys[3];

};

/* Bits used in zip_flags. */

#define ZIP_ENCRYPTED	(1 << 0)

#define ZIP_LENGTH_AT_END	(1 << 3)

#define ZIP_STRONG_ENCRYPTED	(1 << 6)

#define ZIP_UTF8_NAME	(1 << 11)

/* See "7.2 Single Password Symmetric Encryption Method"

   in http://www.pkware.com/documents/casestudies/APPNOTE.TXT */

#define ZIP_CENTRAL_DIRECTORY_ENCRYPTED	(1 << 13)

/* Bits used in flags. */

#define LA_USED_ZIP64	(1 << 0)

#define LA_FROM_CENTRAL_DIRECTORY (1 << 1)

/*

 * See "WinZip - AES Encryption Information"

 *     http://www.winzip.com/aes_info.htm

 */

/* Value used in compression method. */

#define WINZIP_AES_ENCRYPTION	99

/* Authentication code size. */

#define AUTH_CODE_SIZE	10

/**/

#define MAX_DERIVED_KEY_BUF_SIZE	(AES_MAX_KEY_SIZE * 2 + 2)

struct zip {

	/* Structural information about the archive. */

	struct archive_string	format_name;

	int64_t			central_directory_offset;

	size_t			central_directory_entries_total;

	size_t			central_directory_entries_on_this_disk;

	int			has_encrypted_entries;

	/* List of entries (seekable Zip only) */

	struct zip_entry	*zip_entries;

	struct archive_rb_tree	tree;

	struct archive_rb_tree	tree_rsrc;

	/* Bytes read but not yet consumed via __archive_read_consume() */

	size_t			unconsumed;

	/* Information about entry we're currently reading. */

	struct zip_entry	*entry;

	int64_t			entry_bytes_remaining;

	/* These count the number of bytes actually read for the entry. */

	int64_t			entry_compressed_bytes_read;

	int64_t			entry_uncompressed_bytes_read;

	/* Running CRC32 of the decompressed data */

	unsigned long		entry_crc32;

	unsigned long		(*crc32func)(unsigned long, const void *,

				    size_t);

	char			ignore_crc32;

	/* Flags to mark progress of decompression. */

	char			decompress_init;

	char			end_of_entry;

#ifdef HAVE_ZLIB_H

	unsigned char 		*uncompressed_buffer;

	size_t 			uncompressed_buffer_size;

	z_stream		stream;

	char			stream_valid;

#endif

	struct archive_string_conv *sconv;

	struct archive_string_conv *sconv_default;

	struct archive_string_conv *sconv_utf8;

	int			init_default_conversion;

	int			process_mac_extensions;

	char			init_decryption;

	/* Decryption buffer. */

	/*

	 * The decrypted data starts at decrypted_ptr and

	 * extends for decrypted_bytes_remaining.  Decryption

	 * adds new data to the end of this block, data is returned

	 * to clients from the beginning.  When the block hits the

	 * end of decrypted_buffer, it has to be shuffled back to

	 * the beginning of the buffer.

	 */

	unsigned char 		*decrypted_buffer;

	unsigned char 		*decrypted_ptr;

	size_t 			decrypted_buffer_size;

	size_t 			decrypted_bytes_remaining;

	size_t 			decrypted_unconsumed_bytes;

	/* Traditional PKWARE decryption. */

	struct trad_enc_ctx	tctx;

	char			tctx_valid;

	/* WinZip AES decryption. */

	/* Contexts used for AES decryption. */

	archive_crypto_ctx	cctx;

	char			cctx_valid;

	archive_hmac_sha1_ctx	hctx;

	char			hctx_valid;

	/* Strong encryption's decryption header information. */

	unsigned		iv_size;

	unsigned		alg_id;

	unsigned		bit_len;

	unsigned		flags;

	unsigned		erd_size;

	unsigned		v_size;

	unsigned		v_crc32;

	uint8_t			*iv;

	uint8_t			*erd;

	uint8_t			*v_data;

};

/* Many systems define min or MIN, but not all. */

#define	zipmin(a,b) ((a) < (b) ? (a) : (b))

/* ------------------------------------------------------------------------ */

/*

  Traditional PKWARE Decryption functions.

 */

static void

trad_enc_update_keys(struct trad_enc_ctx *ctx, uint8_t c)

{

	uint8_t t;

#define CRC32(c, b) (crc32(c ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL)

	ctx->keys[0] = CRC32(ctx->keys[0], c);

	ctx->keys[1] = (ctx->keys[1] + (ctx->keys[0] & 0xff)) * 134775813L + 1;

	t = (ctx->keys[1] >> 24) & 0xff;

	ctx->keys[2] = CRC32(ctx->keys[2], t);

#undef CRC32

}

static uint8_t

trad_enc_decrypt_byte(struct trad_enc_ctx *ctx)

{

	unsigned temp = ctx->keys[2] | 2;

	return (uint8_t)((temp * (temp ^ 1)) >> 8) & 0xff;

}

static void

trad_enc_decrypt_update(struct trad_enc_ctx *ctx, const uint8_t *in,

    size_t in_len, uint8_t *out, size_t out_len)

{

	unsigned i, max;

	max = (unsigned)((in_len < out_len)? in_len: out_len);

	for (i = 0; i < max; i++) {

		uint8_t t = in[i] ^ trad_enc_decrypt_byte(ctx);

		out[i] = t;

		trad_enc_update_keys(ctx, t);

	}

}

static int

trad_enc_init(struct trad_enc_ctx *ctx, const char *pw, size_t pw_len,

    const uint8_t *key, size_t key_len, uint8_t *crcchk)

{

	uint8_t header[12];

	if (key_len < 12) {

		*crcchk = 0xff;

		return -1;

	}

	ctx->keys[0] = 305419896L;

	ctx->keys[1] = 591751049L;

	ctx->keys[2] = 878082192L;

	for (;pw_len; --pw_len)

		trad_enc_update_keys(ctx, *pw++);

	trad_enc_decrypt_update(ctx, key, 12, header, 12);

	/* Return the last byte for CRC check. */

	*crcchk = header[11];

	return 0;

}

#if 0

static void

crypt_derive_key_sha1(const void *p, int size, unsigned char *key,

    int key_size)

{

#define MD_SIZE 20

	archive_sha1_ctx ctx;

	unsigned char md1[MD_SIZE];

	unsigned char md2[MD_SIZE * 2];

	unsigned char mkb[64];

	int i;

	archive_sha1_init(&ctx;;

	archive_sha1_update(&ctx, p, size);

	archive_sha1_final(&ctx, md1);

	memset(mkb, 0x36, sizeof(mkb));

	for (i = 0; i < MD_SIZE; i++)

		mkb[i] ^= md1[i];

	archive_sha1_init(&ctx;;

	archive_sha1_update(&ctx, mkb, sizeof(mkb));

	archive_sha1_final(&ctx, md2);

	memset(mkb, 0x5C, sizeof(mkb));

	for (i = 0; i < MD_SIZE; i++)

		mkb[i] ^= md1[i];

	archive_sha1_init(&ctx;;

	archive_sha1_update(&ctx, mkb, sizeof(mkb));

	archive_sha1_final(&ctx, md2 + MD_SIZE);

	if (key_size > 32)

		key_size = 32;

	memcpy(key, md2, key_size);

#undef MD_SIZE

}

#endif

/*

 * Common code for streaming or seeking modes.

 *

 * Includes code to read local file headers, decompress data

 * from entry bodies, and common API.

 */

static unsigned long

real_crc32(unsigned long crc, const void *buff, size_t len)

{

	return crc32(crc, buff, (unsigned int)len);

}

/* Used by "ignorecrc32" option to speed up tests. */

static unsigned long

fake_crc32(unsigned long crc, const void *buff, size_t len)

{

	(void)crc; /* UNUSED */

	(void)buff; /* UNUSED */

	(void)len; /* UNUSED */

	return 0;

}

static const struct {

	int id;

	const char * name;

} compression_methods[] = {

	{0, "uncompressed"}, /* The file is stored (no compression) */

	{1, "shrinking"}, /* The file is Shrunk */

	{2, "reduced-1"}, /* The file is Reduced with compression factor 1 */

	{3, "reduced-2"}, /* The file is Reduced with compression factor 2 */

	{4, "reduced-3"}, /* The file is Reduced with compression factor 3 */

	{5, "reduced-4"}, /* The file is Reduced with compression factor 4 */

	{6, "imploded"},  /* The file is Imploded */

	{7, "reserved"},  /* Reserved for Tokenizing compression algorithm */

	{8, "deflation"}, /* The file is Deflated */

	{9, "deflation-64-bit"}, /* Enhanced Deflating using Deflate64(tm) */

	{10, "ibm-terse"},/* PKWARE Data Compression Library Imploding

			   * (old IBM TERSE) */

	{11, "reserved"}, /* Reserved by PKWARE */

	{12, "bzip"},     /* File is compressed using BZIP2 algorithm */

	{13, "reserved"}, /* Reserved by PKWARE */

	{14, "lzma"},     /* LZMA (EFS) */

	{15, "reserved"}, /* Reserved by PKWARE */

	{16, "reserved"}, /* Reserved by PKWARE */

	{17, "reserved"}, /* Reserved by PKWARE */

	{18, "ibm-terse-new"}, /* File is compressed using IBM TERSE (new) */

	{19, "ibm-lz777"},/* IBM LZ77 z Architecture (PFS) */

	{97, "wav-pack"}, /* WavPack compressed data */

	{98, "ppmd-1"},   /* PPMd version I, Rev 1 */

	{99, "aes"}       /* WinZip AES encryption  */

};

static const char *

compression_name(const int compression)

{

	static const int num_compression_methods =

		sizeof(compression_methods)/sizeof(compression_methods[0]);

	int i=0;

	while(compression >= 0 && i < num_compression_methods) {

		if (compression_methods[i].id == compression)

			return compression_methods[i].name;

		i++;

	}

	return "??";

}

/* Convert an MSDOS-style date/time into Unix-style time. */

static time_t

zip_time(const char *p)

{

	int msTime, msDate;

	struct tm ts;

	msTime = (0xff & (unsigned)p[0]) + 256 * (0xff & (unsigned)p[1]);

	msDate = (0xff & (unsigned)p[2]) + 256 * (0xff & (unsigned)p[3]);

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

	ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */

	ts.tm_mon = ((msDate >> 5) & 0x0f) - 1; /* Month number. */

	ts.tm_mday = msDate & 0x1f; /* Day of month. */

	ts.tm_hour = (msTime >> 11) & 0x1f;

	ts.tm_min = (msTime >> 5) & 0x3f;

	ts.tm_sec = (msTime << 1) & 0x3e;

	ts.tm_isdst = -1;

	return mktime(&ts);

}

/*

 * The extra data is stored as a list of

 *	id1+size1+data1 + id2+size2+data2 ...

 *  triplets.  id and size are 2 bytes each.

 */

static int

process_extra(struct archive_read *a, const char *p, size_t extra_length, struct zip_entry* zip_entry)

{

	unsigned offset = 0;

	if (extra_length == 0) {

		return ARCHIVE_OK;

	}

	if (extra_length < 4) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Too-small extra data: Need at least 4 bytes, but only found %d bytes", (int)extra_length);

		return ARCHIVE_FAILED;

	}

	while (offset <= extra_length - 4) {

		unsigned short headerid = archive_le16dec(p + offset);

		unsigned short datasize = archive_le16dec(p + offset + 2);

		offset += 4;

		if (offset + datasize > extra_length) {

			archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

			    "Extra data overflow: Need %d bytes but only found %d bytes",

			    (int)datasize, (int)(extra_length - offset));

			return ARCHIVE_FAILED;

		}

#ifdef DEBUG

		fprintf(stderr, "Header id 0x%04x, length %d\n",

		    headerid, datasize);

#endif

		switch (headerid) {

		case 0x0001:

			/* Zip64 extended information extra field. */

			zip_entry->flags |= LA_USED_ZIP64;

			if (zip_entry->uncompressed_size == 0xffffffff) {

				uint64_t t = 0;

				if (datasize < 8

				    || (t = archive_le64dec(p + offset)) > INT64_MAX) {

					archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

					    "Malformed 64-bit uncompressed size");

					return ARCHIVE_FAILED;

				}

				zip_entry->uncompressed_size = t;

				offset += 8;

				datasize -= 8;

			}

			if (zip_entry->compressed_size == 0xffffffff) {

				uint64_t t = 0;

				if (datasize < 8

				    || (t = archive_le64dec(p + offset)) > INT64_MAX) {

					archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

					    "Malformed 64-bit compressed size");

					return ARCHIVE_FAILED;

				}

				zip_entry->compressed_size = t;

				offset += 8;

				datasize -= 8;

			}

			if (zip_entry->local_header_offset == 0xffffffff) {

				uint64_t t = 0;

				if (datasize < 8

				    || (t = archive_le64dec(p + offset)) > INT64_MAX) {

					archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

					    "Malformed 64-bit local header offset");

					return ARCHIVE_FAILED;

				}

				zip_entry->local_header_offset = t;

				offset += 8;

				datasize -= 8;

			}

			/* archive_le32dec(p + offset) gives disk

			 * on which file starts, but we don't handle

			 * multi-volume Zip files. */

			break;

#ifdef DEBUG

		case 0x0017:

		{

			/* Strong encryption field. */

			if (archive_le16dec(p + offset) == 2) {

				unsigned algId =

					archive_le16dec(p + offset + 2);

				unsigned bitLen =

					archive_le16dec(p + offset + 4);

				int	 flags =

					archive_le16dec(p + offset + 6);

				fprintf(stderr, "algId=0x%04x, bitLen=%u, "

				    "flgas=%d\n", algId, bitLen,flags);

			}

			break;

		}

#endif

		case 0x5455:

		{

			/* Extended time field "UT". */

			int flags = p[offset];

			offset++;

			datasize--;

			/* Flag bits indicate which dates are present. */

			if (flags & 0x01)

			{

#ifdef DEBUG

				fprintf(stderr, "mtime: %lld -> %d\n",

				    (long long)zip_entry->mtime,

				    archive_le32dec(p + offset));

#endif

				if (datasize < 4)

					break;

				zip_entry->mtime = archive_le32dec(p + offset);

				offset += 4;

				datasize -= 4;

			}

			if (flags & 0x02)

			{

				if (datasize < 4)

					break;

				zip_entry->atime = archive_le32dec(p + offset);

				offset += 4;

				datasize -= 4;

			}

			if (flags & 0x04)

			{

				if (datasize < 4)

					break;

				zip_entry->ctime = archive_le32dec(p + offset);

				offset += 4;

				datasize -= 4;

			}

			break;

		}

		case 0x5855:

		{

			/* Info-ZIP Unix Extra Field (old version) "UX". */

			if (datasize >= 8) {

				zip_entry->atime = archive_le32dec(p + offset);

				zip_entry->mtime =

				    archive_le32dec(p + offset + 4);

			}

			if (datasize >= 12) {

				zip_entry->uid =

				    archive_le16dec(p + offset + 8);

				zip_entry->gid =

				    archive_le16dec(p + offset + 10);

			}

			break;

		}

		case 0x6c78:

		{

			/* Experimental 'xl' field */

			/*

			 * Introduced Dec 2013 to provide a way to

			 * include external file attributes (and other

			 * fields that ordinarily appear only in

			 * central directory) in local file header.

			 * This provides file type and permission

			 * information necessary to support full

			 * streaming extraction.  Currently being

			 * discussed with other Zip developers

			 * ... subject to change.

			 *

			 * Format:

			 *  The field starts with a bitmap that specifies

			 *  which additional fields are included.  The

			 *  bitmap is variable length and can be extended in

			 *  the future.

			 *

			 *  n bytes - feature bitmap: first byte has low-order

			 *    7 bits.  If high-order bit is set, a subsequent

			 *    byte holds the next 7 bits, etc.

			 *

			 *  if bitmap & 1, 2 byte "version made by"

			 *  if bitmap & 2, 2 byte "internal file attributes"

			 *  if bitmap & 4, 4 byte "external file attributes"

			 *  if bitmap & 8, 2 byte comment length + n byte comment

			 */

			int bitmap, bitmap_last;

			if (datasize < 1)

				break;

			bitmap_last = bitmap = 0xff & p[offset];

			offset += 1;

			datasize -= 1;

			/* We only support first 7 bits of bitmap; skip rest. */

			while ((bitmap_last & 0x80) != 0

			    && datasize >= 1) {

				bitmap_last = p[offset];

				offset += 1;

				datasize -= 1;

			}

			if (bitmap & 1) {

				/* 2 byte "version made by" */

				if (datasize < 2)

					break;

				zip_entry->system

				    = archive_le16dec(p + offset) >> 8;

				offset += 2;

				datasize -= 2;

			}

			if (bitmap & 2) {

				/* 2 byte "internal file attributes" */

				uint32_t internal_attributes;

				if (datasize < 2)

					break;

				internal_attributes

				    = archive_le16dec(p + offset);

				/* Not used by libarchive at present. */

				(void)internal_attributes; /* UNUSED */

				offset += 2;

				datasize -= 2;

			}

			if (bitmap & 4) {

				/* 4 byte "external file attributes" */

				uint32_t external_attributes;

				if (datasize < 4)

					break;

				external_attributes

				    = archive_le32dec(p + offset);

				if (zip_entry->system == 3) {

					zip_entry->mode

					    = external_attributes >> 16;

				} else if (zip_entry->system == 0) {

					// Interpret MSDOS directory bit

					if (0x10 == (external_attributes & 0x10)) {

						zip_entry->mode = AE_IFDIR | 0775;

					} else {

						zip_entry->mode = AE_IFREG | 0664;

					}

					if (0x01 == (external_attributes & 0x01)) {

						// Read-only bit; strip write permissions

						zip_entry->mode &= 0555;

					}

				} else {

					zip_entry->mode = 0;

				}

				offset += 4;

				datasize -= 4;

			}

			if (bitmap & 8) {

				/* 2 byte comment length + comment */

				uint32_t comment_length;

				if (datasize < 2)

					break;

				comment_length

				    = archive_le16dec(p + offset);

				offset += 2;

				datasize -= 2;

				if (datasize < comment_length)

					break;

				/* Comment is not supported by libarchive */

				offset += comment_length;

				datasize -= comment_length;

			}

			break;

		}

		case 0x7855:

			/* Info-ZIP Unix Extra Field (type 2) "Ux". */

#ifdef DEBUG

			fprintf(stderr, "uid %d gid %d\n",

			    archive_le16dec(p + offset),

			    archive_le16dec(p + offset + 2));

#endif

			if (datasize >= 2)

				zip_entry->uid = archive_le16dec(p + offset);

			if (datasize >= 4)

				zip_entry->gid =

				    archive_le16dec(p + offset + 2);

			break;

		case 0x7875:

		{

			/* Info-Zip Unix Extra Field (type 3) "ux". */

			int uidsize = 0, gidsize = 0;

			/* TODO: support arbitrary uidsize/gidsize. */

			if (datasize >= 1 && p[offset] == 1) {/* version=1 */

				if (datasize >= 4) {

					/* get a uid size. */

					uidsize = 0xff & (int)p[offset+1];

					if (uidsize == 2)

						zip_entry->uid =

						    archive_le16dec(

						        p + offset + 2);

					else if (uidsize == 4 && datasize >= 6)

						zip_entry->uid =

						    archive_le32dec(

						        p + offset + 2);

				}

				if (datasize >= (2 + uidsize + 3)) {

					/* get a gid size. */

					gidsize = 0xff & (int)p[offset+2+uidsize];

					if (gidsize == 2)

						zip_entry->gid =

						    archive_le16dec(

						        p+offset+2+uidsize+1);

					else if (gidsize == 4 &&

					    datasize >= (2 + uidsize + 5))

						zip_entry->gid =

						    archive_le32dec(

						        p+offset+2+uidsize+1);

				}

			}

			break;

		}

		case 0x9901:

			/* WinZip AES extra data field. */

			if (p[offset + 2] == 'A' && p[offset + 3] == 'E') {

				/* Vendor version. */

				zip_entry->aes_extra.vendor =

				    archive_le16dec(p + offset);

				/* AES encryption strength. */

				zip_entry->aes_extra.strength = p[offset + 4];

				/* Actual compression method. */

				zip_entry->aes_extra.compression =

				    p[offset + 5];

			}

			break;

		default:

			break;

		}

		offset += datasize;

	}

	if (offset != extra_length) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Malformed extra data: Consumed %d bytes of %d bytes",

		    (int)offset, (int)extra_length);

		return ARCHIVE_FAILED;

	}

	return ARCHIVE_OK;

}

/*

 * Assumes file pointer is at beginning of local file header.

 */

static int

zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry,

    struct zip *zip)

{

	const char *p;

	const void *h;

	const wchar_t *wp;

	const char *cp;

	size_t len, filename_length, extra_length;

	struct archive_string_conv *sconv;

	struct zip_entry *zip_entry = zip->entry;

	struct zip_entry zip_entry_central_dir;

	int ret = ARCHIVE_OK;

	char version;

	/* Save a copy of the original for consistency checks. */

	zip_entry_central_dir = *zip_entry;

	zip->decompress_init = 0;

	zip->end_of_entry = 0;

	zip->entry_uncompressed_bytes_read = 0;

	zip->entry_compressed_bytes_read = 0;

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

	/* Setup default conversion. */

	if (zip->sconv == NULL && !zip->init_default_conversion) {

		zip->sconv_default =

		    archive_string_default_conversion_for_read(&(a->archive));

		zip->init_default_conversion = 1;

	}

	if ((p = __archive_read_ahead(a, 30, NULL)) == NULL) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Truncated ZIP file header");

		return (ARCHIVE_FATAL);

	}

	if (memcmp(p, "PK\003\004", 4) != 0) {

		archive_set_error(&a->archive, -1, "Damaged Zip archive");

		return ARCHIVE_FATAL;

	}

	version = p[4];

	zip_entry->system = p[5];

	zip_entry->zip_flags = archive_le16dec(p + 6);

	if (zip_entry->zip_flags & (ZIP_ENCRYPTED | ZIP_STRONG_ENCRYPTED)) {

		zip->has_encrypted_entries = 1;

		archive_entry_set_is_data_encrypted(entry, 1);

		if (zip_entry->zip_flags & ZIP_CENTRAL_DIRECTORY_ENCRYPTED &&

			zip_entry->zip_flags & ZIP_ENCRYPTED &&

			zip_entry->zip_flags & ZIP_STRONG_ENCRYPTED) {

			archive_entry_set_is_metadata_encrypted(entry, 1);

			return ARCHIVE_FATAL;

		}

	}

	zip->init_decryption = (zip_entry->zip_flags & ZIP_ENCRYPTED);

	zip_entry->compression = (char)archive_le16dec(p + 8);

	zip_entry->mtime = zip_time(p + 10);

	zip_entry->crc32 = archive_le32dec(p + 14);

	if (zip_entry->zip_flags & ZIP_LENGTH_AT_END)

		zip_entry->decdat = p[11];

	else

		zip_entry->decdat = p[17];

	zip_entry->compressed_size = archive_le32dec(p + 18);

	zip_entry->uncompressed_size = archive_le32dec(p + 22);

	filename_length = archive_le16dec(p + 26);

	extra_length = archive_le16dec(p + 28);

	__archive_read_consume(a, 30);

	/* Read the filename. */

	if ((h = __archive_read_ahead(a, filename_length, NULL)) == NULL) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Truncated ZIP file header");

		return (ARCHIVE_FATAL);

	}

	if (zip_entry->zip_flags & ZIP_UTF8_NAME) {

		/* The filename is stored to be UTF-8. */

		if (zip->sconv_utf8 == NULL) {

			zip->sconv_utf8 =

			    archive_string_conversion_from_charset(

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

			if (zip->sconv_utf8 == NULL)

				return (ARCHIVE_FATAL);

		}

		sconv = zip->sconv_utf8;

	} else if (zip->sconv != NULL)

		sconv = zip->sconv;

	else

		sconv = zip->sconv_default;

	if (archive_entry_copy_pathname_l(entry,

	    h, filename_length, 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(sconv));

		ret = ARCHIVE_WARN;

	}

	__archive_read_consume(a, filename_length);

	/* Read the extra data. */

	if ((h = __archive_read_ahead(a, extra_length, NULL)) == NULL) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Truncated ZIP file header");

		return (ARCHIVE_FATAL);

	}

	if (ARCHIVE_OK != process_extra(a, h, extra_length, zip_entry)) {

		return ARCHIVE_FATAL;

	}

	__archive_read_consume(a, extra_length);

	/* Work around a bug in Info-Zip: When reading from a pipe, it

	 * stats the pipe instead of synthesizing a file entry. */

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

		zip_entry->mode &= ~ AE_IFMT;

		zip_entry->mode |= AE_IFREG;

	}

	/* If the mode is totally empty, set some sane default. */

	if (zip_entry->mode == 0) {