/*-

 * 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.

 * 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"

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_LIMITS_H

#include <limits.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#ifdef HAVE_ZLIB_H

#include <zlib.h>

#endif

#include "archive.h"

#include "archive_entry.h"

#include "archive_entry_locale.h"

#include "archive_private.h"

#include "archive_read_private.h"

#include "archive_endian.h"

struct lzx_dec {

	/* Decoding status. */

	int     		 state;

	/*

	 * Window to see last decoded data, from 32KBi to 2MBi.

	 */

	int			 w_size;

	int			 w_mask;

	/* Window buffer, which is a loop buffer. */

	unsigned char		*w_buff;

	/* The insert position to the window. */

	int			 w_pos;

	/* The position where we can copy decoded code from the window. */

	int     		 copy_pos;

	/* The length how many bytes we can copy decoded code from

	 * the window. */

	int     		 copy_len;

	/* Translation reversal for x86 processor CALL byte sequence(E8).

	 * This is used for LZX only. */

	uint32_t		 translation_size;

	char			 translation;

	char			 block_type;

#define VERBATIM_BLOCK		1

#define ALIGNED_OFFSET_BLOCK	2

#define UNCOMPRESSED_BLOCK	3

	size_t			 block_size;

	size_t			 block_bytes_avail;

	/* Repeated offset. */

	int			 r0, r1, r2;

	unsigned char		 rbytes[4];

	int			 rbytes_avail;

	int			 length_header;

	int			 position_slot;

	int			 offset_bits;

	struct lzx_pos_tbl {

		int		 base;

		int		 footer_bits;

	}			*pos_tbl;

	/*

	 * Bit stream reader.

	 */

	struct lzx_br {

#define CACHE_TYPE		uint64_t

#define CACHE_BITS		(8 * sizeof(CACHE_TYPE))

	 	/* Cache buffer. */

		CACHE_TYPE	 cache_buffer;

		/* Indicates how many bits avail in cache_buffer. */

		int		 cache_avail;

		unsigned char	 odd;

		char		 have_odd;

	} br;

	/*

	 * Huffman coding.

	 */

	struct huffman {

		int		 len_size;

		int		 freq[17];

		unsigned char	*bitlen;

		/*

		 * Use a index table. It's faster than searching a huffman

		 * coding tree, which is a binary tree. But a use of a large

		 * index table causes L1 cache read miss many times.

		 */

		int		 max_bits;

		int		 tbl_bits;

		int		 tree_used;

		/* Direct access table. */

		uint16_t	*tbl;

	}			 at, lt, mt, pt;

	int			 loop;

	int			 error;

};

static const int slots[] = {

	30, 32, 34, 36, 38, 42, 50, 66, 98, 162, 290

};

#define SLOT_BASE	15

#define SLOT_MAX	21/*->25*/

struct lzx_stream {

	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;

	struct lzx_dec		*ds;

};

/*

 * Cabinet file definitions.

 */

/* CFHEADER offset */

#define CFHEADER_signature	0

#define CFHEADER_cbCabinet	8

#define CFHEADER_coffFiles	16

#define CFHEADER_versionMinor	24

#define CFHEADER_versionMajor	25

#define CFHEADER_cFolders	26

#define CFHEADER_cFiles		28

#define CFHEADER_flags		30

#define CFHEADER_setID		32

#define CFHEADER_iCabinet	34

#define CFHEADER_cbCFHeader	36

#define CFHEADER_cbCFFolder	38

#define CFHEADER_cbCFData	39

/* CFFOLDER offset */

#define CFFOLDER_coffCabStart	0

#define CFFOLDER_cCFData	4

#define CFFOLDER_typeCompress	6

#define CFFOLDER_abReserve	8

/* CFFILE offset */

#define CFFILE_cbFile		0

#define CFFILE_uoffFolderStart	4

#define CFFILE_iFolder		8

#define CFFILE_date_time	10

#define CFFILE_attribs		14

/* CFDATA offset */

#define CFDATA_csum		0

#define CFDATA_cbData		4

#define CFDATA_cbUncomp		6

static const char * const compression_name[] = {

	"NONE",

	"MSZIP",

	"Quantum",

	"LZX",

};

struct cfdata {

	/* Sum value of this CFDATA. */

	uint32_t		 sum;

	uint16_t		 compressed_size;

	uint16_t		 compressed_bytes_remaining;

	uint16_t		 uncompressed_size;

	uint16_t		 uncompressed_bytes_remaining;

	/* To know how many bytes we have decompressed. */

	uint16_t		 uncompressed_avail;

	/* Offset from the beginning of compressed data of this CFDATA */

	uint16_t		 read_offset;

	int64_t			 unconsumed;

	/* To keep memory image of this CFDATA to compute the sum. */

	size_t			 memimage_size;

	unsigned char		*memimage;

	/* Result of calculation of sum. */

	uint32_t		 sum_calculated;

	unsigned char		 sum_extra[4];

	int			 sum_extra_avail;

	const void		*sum_ptr;

};

struct cffolder {

	uint32_t		 cfdata_offset_in_cab;

	uint16_t		 cfdata_count;

	uint16_t		 comptype;

#define COMPTYPE_NONE		0x0000

#define COMPTYPE_MSZIP		0x0001

#define COMPTYPE_QUANTUM	0x0002

#define COMPTYPE_LZX		0x0003

	uint16_t		 compdata;

	const char		*compname;

	/* At the time reading CFDATA */

	struct cfdata		 cfdata;

	int			 cfdata_index;

	/* Flags to mark progress of decompression. */

	char			 decompress_init;

};

struct cffile {

	uint32_t		 uncompressed_size;

	uint32_t		 offset;

	time_t			 mtime;

	uint16_t	 	 folder;

#define iFoldCONTINUED_FROM_PREV	0xFFFD

#define iFoldCONTINUED_TO_NEXT		0xFFFE

#define iFoldCONTINUED_PREV_AND_NEXT	0xFFFF

	unsigned char		 attr;

#define ATTR_RDONLY		0x01

#define ATTR_NAME_IS_UTF	0x80

	struct archive_string 	 pathname;

};

struct cfheader {

	/* Total bytes of all file size in a Cabinet. */

	uint32_t		 total_bytes;

	uint32_t		 files_offset;

	uint16_t		 folder_count;

	uint16_t		 file_count;

	uint16_t		 flags;

#define PREV_CABINET	0x0001

#define NEXT_CABINET	0x0002

#define RESERVE_PRESENT	0x0004

	uint16_t		 setid;

	uint16_t		 cabinet;

	/* Version number. */

	unsigned char		 major;

	unsigned char		 minor;

	unsigned char		 cffolder;

	unsigned char		 cfdata;

	/* All folders in a cabinet. */

	struct cffolder		*folder_array;

	/* All files in a cabinet. */

	struct cffile		*file_array;

	int			 file_index;

};

struct cab {

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

	int64_t			 entry_offset;

	int64_t			 entry_bytes_remaining;

	int64_t			 entry_unconsumed;

	int64_t			 entry_compressed_bytes_read;

	int64_t			 entry_uncompressed_bytes_read;

	struct cffolder		*entry_cffolder;

	struct cffile		*entry_cffile;

	struct cfdata		*entry_cfdata;

	/* Offset from beginning of a cabinet file. */

	int64_t			 cab_offset;

	struct cfheader		 cfheader;

	struct archive_wstring	 ws;

	/* Flag to mark progress that an archive was read their first header.*/

	char			 found_header;

	char			 end_of_archive;

	char			 end_of_entry;

	char			 end_of_entry_cleanup;

	char			 read_data_invoked;

	int64_t			 bytes_skipped;

	unsigned char		*uncompressed_buffer;

	size_t			 uncompressed_buffer_size;

	int			 init_default_conversion;

	struct archive_string_conv *sconv;

	struct archive_string_conv *sconv_default;

	struct archive_string_conv *sconv_utf8;

	char			 format_name[64];

#ifdef HAVE_ZLIB_H

	z_stream		 stream;

	char			 stream_valid;

#endif

	struct lzx_stream	 xstrm;

};

static int	archive_read_format_cab_bid(struct archive_read *, int);

static int	archive_read_format_cab_options(struct archive_read *,

		    const char *, const char *);

static int	archive_read_format_cab_read_header(struct archive_read *,

		    struct archive_entry *);

static int	archive_read_format_cab_read_data(struct archive_read *,

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

static int	archive_read_format_cab_read_data_skip(struct archive_read *);

static int	archive_read_format_cab_cleanup(struct archive_read *);

static int	cab_skip_sfx(struct archive_read *);

static time_t	cab_dos_time(const unsigned char *);

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

		    size_t *, int64_t *);

static int	cab_read_header(struct archive_read *);

static uint32_t cab_checksum_cfdata_4(const void *, size_t bytes, uint32_t);

static uint32_t cab_checksum_cfdata(const void *, size_t bytes, uint32_t);

static void	cab_checksum_update(struct archive_read *, size_t);

static int	cab_checksum_finish(struct archive_read *);

static int	cab_next_cfdata(struct archive_read *);

static const void *cab_read_ahead_cfdata(struct archive_read *, ssize_t *);

static const void *cab_read_ahead_cfdata_none(struct archive_read *, ssize_t *);

static const void *cab_read_ahead_cfdata_deflate(struct archive_read *,

		    ssize_t *);

static const void *cab_read_ahead_cfdata_lzx(struct archive_read *,

		    ssize_t *);

static int64_t	cab_consume_cfdata(struct archive_read *, int64_t);

static int64_t	cab_minimum_consume_cfdata(struct archive_read *, int64_t);

static int	lzx_decode_init(struct lzx_stream *, int);

static int	lzx_read_blocks(struct lzx_stream *, int);

static int	lzx_decode_blocks(struct lzx_stream *, int);

static void	lzx_decode_free(struct lzx_stream *);

static void	lzx_translation(struct lzx_stream *, void *, size_t, uint32_t);

static void	lzx_cleanup_bitstream(struct lzx_stream *);

static int	lzx_decode(struct lzx_stream *, int);

static int	lzx_read_pre_tree(struct lzx_stream *);

static int	lzx_read_bitlen(struct lzx_stream *, struct huffman *, int);

static int	lzx_huffman_init(struct huffman *, size_t, int);

static void	lzx_huffman_free(struct huffman *);

static int	lzx_make_huffman_table(struct huffman *);

static inline int lzx_decode_huffman(struct huffman *, unsigned);

int

archive_read_support_format_cab(struct archive *_a)

{

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

	struct cab *cab;

	int r;

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_read_support_format_cab");

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

	if (cab == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate CAB data");

		return (ARCHIVE_FATAL);

	}

	archive_string_init(&cab->ws);

	archive_wstring_ensure(&cab->ws, 256);

	r = __archive_read_register_format(a,

	    cab,

	    "cab",

	    archive_read_format_cab_bid,

	    archive_read_format_cab_options,

	    archive_read_format_cab_read_header,

	    archive_read_format_cab_read_data,

	    archive_read_format_cab_read_data_skip,

	    NULL,

	    archive_read_format_cab_cleanup,

	    NULL,

	    NULL);

	if (r != ARCHIVE_OK)

		free(cab);

	return (ARCHIVE_OK);

}

static int

find_cab_magic(const char *p)

{

	switch (p[4]) {

	case 0:

		/*

		 * Note: Self-Extraction program has 'MSCF' string in their

		 * program. If we were finding 'MSCF' string only, we got

		 * wrong place for Cabinet header, thus, we have to check

		 * following four bytes which are reserved and must be set

		 * to zero.

		 */

		if (memcmp(p, "MSCF\0\0\0\0", 8) == 0)

			return 0;

		return 5;

	case 'F': return 1;

	case 'C': return 2;

	case 'S': return 3;

	case 'M': return 4;

	default:  return 5;

	}

}

static int

archive_read_format_cab_bid(struct archive_read *a, int best_bid)

{

	const char *p;

	ssize_t bytes_avail, offset, window;

	/* If there's already a better bid than we can ever

	   make, don't bother testing. */

	if (best_bid > 64)

		return (-1);

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

		return (-1);

	if (memcmp(p, "MSCF\0\0\0\0", 8) == 0)

		return (64);

	/*

	 * Attempt to handle self-extracting archives

	 * by noting a PE header and searching forward

	 * up to 128k for a 'MSCF' marker.

	 */

	if (p[0] == 'M' && p[1] == 'Z') {

		offset = 0;

		window = 4096;

		while (offset < (1024 * 128)) {

			const char *h = __archive_read_ahead(a, offset + window,

			    &bytes_avail);

			if (h == NULL) {

				/* Remaining bytes are less than window. */

				window >>= 1;

				if (window < 128)

					return (0);

				continue;

			}

			p = h + offset;

			while (p + 8 < h + bytes_avail) {

				int next;

				if ((next = find_cab_magic(p)) == 0)

					return (64);

				p += next;

			}

			offset = p - h;

		}

	}

	return (0);

}

static int

archive_read_format_cab_options(struct archive_read *a,

    const char *key, const char *val)

{

	struct cab *cab;

	int ret = ARCHIVE_FAILED;

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

	if (strcmp(key, "hdrcharset")  == 0) {

		if (val == NULL || val[0] == 0)

			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

			    "cab: hdrcharset option needs a character-set name");

		else {

			cab->sconv = archive_string_conversion_from_charset(

			    &a->archive, val, 0);

			if (cab->sconv != NULL)

				ret = ARCHIVE_OK;

			else

				ret = ARCHIVE_FATAL;

		}

		return (ret);

	}

	/* Note: The "warn" return is just to inform the options

	 * supervisor that we didn't handle it.  It will generate

	 * a suitable error if no one used this option. */

	return (ARCHIVE_WARN);

}

static int

cab_skip_sfx(struct archive_read *a)

{

	const char *p, *q;

	size_t skip;

	ssize_t bytes, window;

	window = 4096;

	for (;;) {

		const char *h = __archive_read_ahead(a, window, &bytes);

		if (h == NULL) {

			/* Remaining size are less than window. */

			window >>= 1;

			if (window < 128) {

				archive_set_error(&a->archive,

				    ARCHIVE_ERRNO_FILE_FORMAT,

				    "Couldn't find out CAB header");

				return (ARCHIVE_FATAL);

			}

			continue;

		}

		p = h;

		q = p + bytes;

		/*

		 * Scan ahead until we find something that looks

		 * like the cab header.

		 */

		while (p + 8 < q) {

			int next;

			if ((next = find_cab_magic(p)) == 0) {

				skip = p - h;

				__archive_read_consume(a, skip);

				return (ARCHIVE_OK);

			}

			p += next;

		}

		skip = p - h;

		__archive_read_consume(a, skip);

	}

}

static int

truncated_error(struct archive_read *a)

{

	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

	    "Truncated CAB header");

	return (ARCHIVE_FATAL);

}

static ssize_t

cab_strnlen(const unsigned char *p, size_t maxlen)

{

	size_t i;

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

		if (p[i] == 0)

			break;

	}

	if (i > maxlen)

		return (-1);/* invalid */

	return ((ssize_t)i);

}

/* Read bytes as much as remaining. */

static const void *

cab_read_ahead_remaining(struct archive_read *a, size_t min, ssize_t *avail)

{

	const void *p;

	while (min > 0) {

		p = __archive_read_ahead(a, min, avail);

		if (p != NULL)

			return (p);

		min--;

	}

	return (NULL);

}

/* Convert a path separator '\' -> '/' */

static int

cab_convert_path_separator_1(struct archive_string *fn, unsigned char attr)

{

	size_t i;

	int mb;

	/* Easy check if we have '\' in multi-byte string. */

	mb = 0;

	for (i = 0; i < archive_strlen(fn); i++) {

		if (fn->s[i] == '\\') {

			if (mb) {

				/* This may be second byte of multi-byte

				 * character. */

				break;

			}

			fn->s[i] = '/';

			mb = 0;

		} else if ((fn->s[i] & 0x80) && !(attr & ATTR_NAME_IS_UTF))

			mb = 1;

		else

			mb = 0;

	}

	if (i == archive_strlen(fn))

		return (0);

	return (-1);

}

/*

 * Replace a character '\' with '/' in wide character.

 */

static void

cab_convert_path_separator_2(struct cab *cab, struct archive_entry *entry)

{

	const wchar_t *wp;

	size_t i;

	/* If a conversion to wide character failed, force the replacement. */

	if ((wp = archive_entry_pathname_w(entry)) != NULL) {

		archive_wstrcpy(&(cab->ws), wp);

		for (i = 0; i < archive_strlen(&(cab->ws)); i++) {

			if (cab->ws.s[i] == L'\\')

				cab->ws.s[i] = L'/';

		}

		archive_entry_copy_pathname_w(entry, cab->ws.s);

	}

}

/*

 * Read CFHEADER, CFFOLDER and CFFILE.

 */

static int

cab_read_header(struct archive_read *a)

{

	const unsigned char *p;

	struct cab *cab;

	struct cfheader *hd;

	size_t bytes, used;

	ssize_t len;

	int64_t skip;

	int err, i;

	int cur_folder, prev_folder;

	uint32_t offset32;

	a->archive.archive_format = ARCHIVE_FORMAT_CAB;

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

		a->archive.archive_format_name = "CAB";

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

		return (truncated_error(a));

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

	if (cab->found_header == 0 &&

	    p[0] == 'M' && p[1] == 'Z') {

		/* This is an executable?  Must be self-extracting... */

		err = cab_skip_sfx(a);

		if (err < ARCHIVE_WARN)

			return (err);

		/* Re-read header after processing the SFX. */

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

			return (truncated_error(a));

	}

	cab->cab_offset = 0;

	/*

	 * Read CFHEADER.

	 */

	hd = &cab->cfheader;

	if (p[CFHEADER_signature+0] != 'M' || p[CFHEADER_signature+1] != 'S' ||

	    p[CFHEADER_signature+2] != 'C' || p[CFHEADER_signature+3] != 'F') {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Couldn't find out CAB header");

		return (ARCHIVE_FATAL);

	}

	hd->total_bytes = archive_le32dec(p + CFHEADER_cbCabinet);

	hd->files_offset = archive_le32dec(p + CFHEADER_coffFiles);

	hd->minor = p[CFHEADER_versionMinor];

	hd->major = p[CFHEADER_versionMajor];

	hd->folder_count = archive_le16dec(p + CFHEADER_cFolders);

	if (hd->folder_count == 0)

		goto invalid;

	hd->file_count = archive_le16dec(p + CFHEADER_cFiles);

	if (hd->file_count == 0)

		goto invalid;

	hd->flags = archive_le16dec(p + CFHEADER_flags);

	hd->setid = archive_le16dec(p + CFHEADER_setID);

	hd->cabinet = archive_le16dec(p + CFHEADER_iCabinet);

	used = CFHEADER_iCabinet + 2;

	if (hd->flags & RESERVE_PRESENT) {

		uint16_t cfheader;

		cfheader = archive_le16dec(p + CFHEADER_cbCFHeader);

		if (cfheader > 60000U)

			goto invalid;

		hd->cffolder = p[CFHEADER_cbCFFolder];

		hd->cfdata = p[CFHEADER_cbCFData];

		used += 4;/* cbCFHeader, cbCFFolder and cbCFData */

		used += cfheader;/* abReserve */

	} else

		hd->cffolder = 0;/* Avoid compiling warning. */

	if (hd->flags & PREV_CABINET) {

		/* How many bytes are used for szCabinetPrev. */

		if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)

			return (truncated_error(a));

		if ((len = cab_strnlen(p + used, 255)) <= 0)

			goto invalid;

		used += len + 1;

		/* How many bytes are used for szDiskPrev. */

		if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)

			return (truncated_error(a));

		if ((len = cab_strnlen(p + used, 255)) <= 0)

			goto invalid;

		used += len + 1;

	}

	if (hd->flags & NEXT_CABINET) {

		/* How many bytes are used for szCabinetNext. */

		if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)

			return (truncated_error(a));

		if ((len = cab_strnlen(p + used, 255)) <= 0)

			goto invalid;

		used += len + 1;

		/* How many bytes are used for szDiskNext. */

		if ((p = __archive_read_ahead(a, used+256, NULL)) == NULL)

			return (truncated_error(a));

		if ((len = cab_strnlen(p + used, 255)) <= 0)

			goto invalid;

		used += len + 1;

	}

	__archive_read_consume(a, used);

	cab->cab_offset += used;

	used = 0;

	/*

	 * Read CFFOLDER.

	 */

	hd->folder_array = (struct cffolder *)calloc(

	    hd->folder_count, sizeof(struct cffolder));

	if (hd->folder_array == NULL)

		goto nomem;

	bytes = 8;

	if (hd->flags & RESERVE_PRESENT)

		bytes += hd->cffolder;

	bytes *= hd->folder_count;

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

		return (truncated_error(a));

	offset32 = 0;

	for (i = 0; i < hd->folder_count; i++) {

		struct cffolder *folder = &(hd->folder_array[i]);

		folder->cfdata_offset_in_cab =

		    archive_le32dec(p + CFFOLDER_coffCabStart);

		folder->cfdata_count = archive_le16dec(p+CFFOLDER_cCFData);

		folder->comptype =

		    archive_le16dec(p+CFFOLDER_typeCompress) & 0x0F;

		folder->compdata =

		    archive_le16dec(p+CFFOLDER_typeCompress) >> 8;

		/* Get a compression name. */

		if (folder->comptype <

		    sizeof(compression_name) / sizeof(compression_name[0]))

			folder->compname = compression_name[folder->comptype];

		else

			folder->compname = "UNKNOWN";

		p += 8;

		used += 8;

		if (hd->flags & RESERVE_PRESENT) {

			p += hd->cffolder;/* abReserve */

			used += hd->cffolder;

		}

		/*

		 * Sanity check if each data is acceptable.

		 */

		if (offset32 >= folder->cfdata_offset_in_cab)

			goto invalid;

		offset32 = folder->cfdata_offset_in_cab;

		/* Set a request to initialize zlib for the CFDATA of

		 * this folder. */

		folder->decompress_init = 0;

	}

	__archive_read_consume(a, used);

	cab->cab_offset += used;

	/*

	 * Read CFFILE.

	 */

	/* Seek read pointer to the offset of CFFILE if needed. */

	skip = (int64_t)hd->files_offset - cab->cab_offset;

	if (skip <  0) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

		    "Invalid offset of CFFILE %jd < %jd",

		    (intmax_t)hd->files_offset, (intmax_t)cab->cab_offset);

		return (ARCHIVE_FATAL);

	}

	if (skip) {

		__archive_read_consume(a, skip);

		cab->cab_offset += skip;

	}

	/* Allocate memory for CFDATA */

	hd->file_array = (struct cffile *)calloc(

	    hd->file_count, sizeof(struct cffile));

	if (hd->file_array == NULL)

		goto nomem;

	prev_folder = -1;

	for (i = 0; i < hd->file_count; i++) {

		struct cffile *file = &(hd->file_array[i]);

		ssize_t avail;

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

			return (truncated_error(a));

		file->uncompressed_size = archive_le32dec(p + CFFILE_cbFile);

		file->offset = archive_le32dec(p + CFFILE_uoffFolderStart);

		file->folder = archive_le16dec(p + CFFILE_iFolder);

		file->mtime = cab_dos_time(p + CFFILE_date_time);

		file->attr = (uint8_t)archive_le16dec(p + CFFILE_attribs);

		__archive_read_consume(a, 16);

		cab->cab_offset += 16;

		if ((p = cab_read_ahead_remaining(a, 256, &avail)) == NULL)

			return (truncated_error(a));

		if ((len = cab_strnlen(p, avail-1)) <= 0)

			goto invalid;

		/* Copy a pathname.  */

		archive_string_init(&(file->pathname));

		archive_strncpy(&(file->pathname), p, len);

		__archive_read_consume(a, len + 1);

		cab->cab_offset += len + 1;

		/*

		 * Sanity check if each data is acceptable.

		 */

		if (file->uncompressed_size > 0x7FFF8000)

			goto invalid;/* Too large */

		if ((int64_t)file->offset + (int64_t)file->uncompressed_size

		    > ARCHIVE_LITERAL_LL(0x7FFF8000))

			goto invalid;/* Too large */

		switch (file->folder) {

		case iFoldCONTINUED_TO_NEXT:

			/* This must be last file in a folder. */

			if (i != hd->file_count -1)

				goto invalid;

			cur_folder = hd->folder_count -1;

			break;

		case iFoldCONTINUED_PREV_AND_NEXT:

			/* This must be only one file in a folder. */

			if (hd->file_count != 1)

				goto invalid;

			/* FALL THROUGH */

		case iFoldCONTINUED_FROM_PREV:

			/* This must be first file in a folder. */

			if (i != 0)

				goto invalid;

			prev_folder = cur_folder = 0;

			offset32 = file->offset;

			break;

		default:

			if (file->folder >= hd->folder_count)

				goto invalid;

			cur_folder = file->folder;

			break;

		}

		/* Dot not back track. */

		if (cur_folder < prev_folder)

			goto invalid;

		if (cur_folder != prev_folder)

			offset32 = 0;

		prev_folder = cur_folder;

		/* Make sure there are not any blanks from last file

		 * contents. */

		if (offset32 != file->offset)

			goto invalid;

		offset32 += file->uncompressed_size;

		/* CFDATA is available for file contents. */

		if (file->uncompressed_size > 0 &&

		    hd->folder_array[cur_folder].cfdata_count == 0)

			goto invalid;

	}

	if (hd->cabinet != 0 || hd->flags & (PREV_CABINET | NEXT_CABINET)) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Multivolume cabinet file is unsupported");

		return (ARCHIVE_WARN);

	}

	return (ARCHIVE_OK);

invalid:

	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

	    "Invalid CAB header");

	return (ARCHIVE_FATAL);

nomem:

	archive_set_error(&a->archive, ENOMEM,

	    "Can't allocate memory for CAB data");

	return (ARCHIVE_FATAL);

}