/*-

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

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

#define MAXMATCH		256	/* Maximum match length. */

#define MINMATCH		3	/* Minimum match length. */

/*

 * Literal table format:

 * +0              +256                      +510

 * +---------------+-------------------------+

 * | literal code  |       match length      |

 * |   0 ... 255   |  MINMATCH ... MAXMATCH  |

 * +---------------+-------------------------+

 *  <---          LT_BITLEN_SIZE         --->

 */

/* Literal table size. */

#define LT_BITLEN_SIZE		(UCHAR_MAX + 1 + MAXMATCH - MINMATCH + 1)

/* Position table size.

 * Note: this used for both position table and pre literal table.*/

#define PT_BITLEN_SIZE		(3 + 16)

struct lzh_dec {

	/* Decoding status. */

	int     		 state;

	/*

	 * Window to see last 8Ki(lh5),32Ki(lh6),64Ki(lh7) bytes of decoded

	 * data.

	 */

	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;

	/*

	 * Bit stream reader.

	 */

	struct lzh_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;

	} br;

	/*

	 * Huffman coding.

	 */

	struct huffman {

		int		 len_size;

		int		 len_avail;

		int		 len_bits;

		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.

		 */

#define HTBL_BITS	10

		int		 max_bits;

		int		 shift_bits;

		int		 tbl_bits;

		int		 tree_used;

		int		 tree_avail;

		/* Direct access table. */

		uint16_t	*tbl;

		/* Binary tree table for extra bits over the direct access. */

		struct htree_t {

			uint16_t left;

			uint16_t right;

		}		*tree;

	}			 lt, pt;

	int			 blocks_avail;

	int			 pos_pt_len_size;

	int			 pos_pt_len_bits;

	int			 literal_pt_len_size;

	int			 literal_pt_len_bits;

	int			 reading_position;

	int			 loop;

	int			 error;

};

struct lzh_stream {

	const unsigned char	*next_in;

	int			 avail_in;

	int64_t			 total_in;

	const unsigned char	*ref_ptr;

	int			 avail_out;

	int64_t			 total_out;

	struct lzh_dec		*ds;

};

struct lha {

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

	int64_t                  entry_offset;

	int64_t                  entry_bytes_remaining;

	int64_t			 entry_unconsumed;

	uint16_t		 entry_crc_calculated;

	size_t			 header_size;	/* header size		    */

	unsigned char		 level;		/* header level		    */

	char			 method[3];	/* compress type	    */

	int64_t			 compsize;	/* compressed data size	    */

	int64_t			 origsize;	/* original file size	    */

	int			 setflag;

#define BIRTHTIME_IS_SET	1

#define ATIME_IS_SET		2

#define UNIX_MODE_IS_SET	4

#define CRC_IS_SET		8

	time_t			 birthtime;

	long			 birthtime_tv_nsec;

	time_t			 mtime;

	long			 mtime_tv_nsec;

	time_t			 atime;

	long			 atime_tv_nsec;

	mode_t			 mode;

	int64_t			 uid;

	int64_t			 gid;

	struct archive_string 	 uname;

	struct archive_string 	 gname;

	uint16_t		 header_crc;

	uint16_t		 crc;

	struct archive_string_conv *sconv;

	struct archive_string_conv *opt_sconv;

	struct archive_string 	 dirname;

	struct archive_string 	 filename;

	struct archive_wstring	 ws;

	unsigned char		 dos_attr;

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

	char			 found_first_header;

	/* Flag to mark that indicates an empty directory. */

	char			 directory;

	/* Flags to mark progress of decompression. */

	char			 decompress_init;

	char			 end_of_entry;

	char			 end_of_entry_cleanup;

	char			 entry_is_compressed;

	char			 format_name[64];

	struct lzh_stream	 strm;

};

/*

 * LHA header common member offset.

 */

#define H_METHOD_OFFSET	2	/* Compress type. */

#define H_ATTR_OFFSET	19	/* DOS attribute. */

#define H_LEVEL_OFFSET	20	/* Header Level.  */

#define H_SIZE		22	/* Minimum header size. */

static int      archive_read_format_lha_bid(struct archive_read *, int);

static int      archive_read_format_lha_options(struct archive_read *,

		    const char *, const char *);

static int	archive_read_format_lha_read_header(struct archive_read *,

		    struct archive_entry *);

static int	archive_read_format_lha_read_data(struct archive_read *,

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

static int	archive_read_format_lha_read_data_skip(struct archive_read *);

static int	archive_read_format_lha_cleanup(struct archive_read *);

static void	lha_replace_path_separator(struct lha *,

		    struct archive_entry *);

static int	lha_read_file_header_0(struct archive_read *, struct lha *);

static int	lha_read_file_header_1(struct archive_read *, struct lha *);

static int	lha_read_file_header_2(struct archive_read *, struct lha *);

static int	lha_read_file_header_3(struct archive_read *, struct lha *);

static int	lha_read_file_extended_header(struct archive_read *,

		    struct lha *, uint16_t *, int, size_t, size_t *);

static size_t	lha_check_header_format(const void *);

static int	lha_skip_sfx(struct archive_read *);

static time_t	lha_dos_time(const unsigned char *);

static time_t	lha_win_time(uint64_t, long *);

static unsigned char	lha_calcsum(unsigned char, const void *,

		    int, size_t);

static int	lha_parse_linkname(struct archive_string *,

		    struct archive_string *);

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

		    size_t *, int64_t *);

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

		    size_t *, int64_t *);

static void	lha_crc16_init(void);

static uint16_t lha_crc16(uint16_t, const void *, size_t);

static int	lzh_decode_init(struct lzh_stream *, const char *);

static void	lzh_decode_free(struct lzh_stream *);

static int	lzh_decode(struct lzh_stream *, int);

static int	lzh_br_fillup(struct lzh_stream *, struct lzh_br *);

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

static void	lzh_huffman_free(struct huffman *);

static int	lzh_read_pt_bitlen(struct lzh_stream *, int start, int end);

static int	lzh_make_fake_table(struct huffman *, uint16_t);

static int	lzh_make_huffman_table(struct huffman *);

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

static int	lzh_decode_huffman_tree(struct huffman *, unsigned, int);

int

archive_read_support_format_lha(struct archive *_a)

{

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

	struct lha *lha;

	int r;

	archive_check_magic(_a, ARCHIVE_READ_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_read_support_format_lha");

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

	if (lha == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate lha data");

		return (ARCHIVE_FATAL);

	}

	archive_string_init(&lha->ws);

	r = __archive_read_register_format(a,

	    lha,

	    "lha",

	    archive_read_format_lha_bid,

	    archive_read_format_lha_options,

	    archive_read_format_lha_read_header,

	    archive_read_format_lha_read_data,

	    archive_read_format_lha_read_data_skip,

	    NULL,

	    archive_read_format_lha_cleanup,

	    NULL,

	    NULL);

	if (r != ARCHIVE_OK)

		free(lha);

	return (ARCHIVE_OK);

}

static size_t

lha_check_header_format(const void *h)

{

	const unsigned char *p = h;

	size_t next_skip_bytes;

	switch (p[H_METHOD_OFFSET+3]) {

	/*

	 * "-lh0-" ... "-lh7-" "-lhd-"

	 * "-lzs-" "-lz5-"

	 */

	case '0': case '1': case '2': case '3':

	case '4': case '5': case '6': case '7':

	case 'd':

	case 's':

		next_skip_bytes = 4;

		/* b0 == 0 means the end of an LHa archive file.	*/

		if (p[0] == 0)

			break;

		if (p[H_METHOD_OFFSET] != '-' || p[H_METHOD_OFFSET+1] != 'l'

		    ||  p[H_METHOD_OFFSET+4] != '-')

			break;

		if (p[H_METHOD_OFFSET+2] == 'h') {

			/* "-lh?-" */

			if (p[H_METHOD_OFFSET+3] == 's')

				break;

			if (p[H_LEVEL_OFFSET] == 0)

				return (0);

			if (p[H_LEVEL_OFFSET] <= 3 && p[H_ATTR_OFFSET] == 0x20)

				return (0);

		}

		if (p[H_METHOD_OFFSET+2] == 'z') {

			/* LArc extensions: -lzs-,-lz4- and -lz5- */

			if (p[H_LEVEL_OFFSET] != 0)

				break;

			if (p[H_METHOD_OFFSET+3] == 's'

			    || p[H_METHOD_OFFSET+3] == '4'

			    || p[H_METHOD_OFFSET+3] == '5')

				return (0);

		}

		break;

	case 'h': next_skip_bytes = 1; break;

	case 'z': next_skip_bytes = 1; break;

	case 'l': next_skip_bytes = 2; break;

	case '-': next_skip_bytes = 3; break;

	default : next_skip_bytes = 4; break;

	}

	return (next_skip_bytes);

}

static int

archive_read_format_lha_bid(struct archive_read *a, int best_bid)

{

	const char *p;

	const void *buff;

	ssize_t bytes_avail, offset, window;

	size_t next;

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

	   make, don't bother testing. */

	if (best_bid > 30)

		return (-1);

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

		return (-1);

	if (lha_check_header_format(p) == 0)

		return (30);

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

		/* PE file */

		offset = 0;

		window = 4096;

		while (offset < (1024 * 20)) {

			buff = __archive_read_ahead(a, offset + window,

			    &bytes_avail);

			if (buff == NULL) {

				/* Remaining bytes are less than window. */

				window >>= 1;

				if (window < (H_SIZE + 3))

					return (0);

				continue;

			}

			p = (const char *)buff + offset;

			while (p + H_SIZE < (const char *)buff + bytes_avail) {

				if ((next = lha_check_header_format(p)) == 0)

					return (30);

				p += next;

			}

			offset = p - (const char *)buff;

		}

	}

	return (0);

}

static int

archive_read_format_lha_options(struct archive_read *a,

    const char *key, const char *val)

{

	struct lha *lha;

	int ret = ARCHIVE_FAILED;

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

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

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

			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

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

		else {

			lha->opt_sconv =

			    archive_string_conversion_from_charset(

				&a->archive, val, 0);

			if (lha->opt_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

lha_skip_sfx(struct archive_read *a)

{

	const void *h;

	const char *p, *q;

	size_t next, skip;

	ssize_t bytes, window;

	window = 4096;

	for (;;) {

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

		if (h == NULL) {

			/* Remaining bytes are less than window. */

			window >>= 1;

			if (window < (H_SIZE + 3))

				goto fatal;

			continue;

		}

		if (bytes < H_SIZE)

			goto fatal;

		p = h;

		q = p + bytes;

		/*

		 * Scan ahead until we find something that looks

		 * like the lha header.

		 */

		while (p + H_SIZE < q) {

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

				skip = p - (const char *)h;

				__archive_read_consume(a, skip);

				return (ARCHIVE_OK);

			}

			p += next;

		}

		skip = p - (const char *)h;

		__archive_read_consume(a, skip);

	}

fatal:

	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

	    "Couldn't find out LHa header");

	return (ARCHIVE_FATAL);

}

static int

truncated_error(struct archive_read *a)

{

	archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

	    "Truncated LHa header");

	return (ARCHIVE_FATAL);

}

static int

archive_read_format_lha_read_header(struct archive_read *a,

    struct archive_entry *entry)

{

	struct archive_string linkname;

	struct archive_string pathname;

	struct lha *lha;

	const unsigned char *p;

	const char *signature;

	int err;

	lha_crc16_init();

	a->archive.archive_format = ARCHIVE_FORMAT_LHA;

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

		a->archive.archive_format_name = "lha";

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

	lha->decompress_init = 0;

	lha->end_of_entry = 0;

	lha->end_of_entry_cleanup = 0;

	lha->entry_unconsumed = 0;

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

		/*

		 * LHa archiver added 0 to the tail of its archive file as

		 * the mark of the end of the archive.

		 */

		signature = __archive_read_ahead(a, sizeof(signature[0]), NULL);

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

			return (ARCHIVE_EOF);

		return (truncated_error(a));

	}

	signature = (const char *)p;

	if (lha->found_first_header == 0 &&

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

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

		err = lha_skip_sfx(a);

		if (err < ARCHIVE_WARN)

			return (err);

		if ((p = __archive_read_ahead(a, sizeof(*p), NULL)) == NULL)

			return (truncated_error(a));

		signature = (const char *)p;

	}

	/* signature[0] == 0 means the end of an LHa archive file. */

	if (signature[0] == 0)

		return (ARCHIVE_EOF);

	/*

	 * Check the header format and method type.

	 */

	if (lha_check_header_format(p) != 0) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Bad LHa file");

		return (ARCHIVE_FATAL);

	}

	/* We've found the first header. */

	lha->found_first_header = 1;

	/* Set a default value and common data */

	lha->header_size = 0;

	lha->level = p[H_LEVEL_OFFSET];

	lha->method[0] = p[H_METHOD_OFFSET+1];

	lha->method[1] = p[H_METHOD_OFFSET+2];

	lha->method[2] = p[H_METHOD_OFFSET+3];

	if (memcmp(lha->method, "lhd", 3) == 0)

		lha->directory = 1;

	else

		lha->directory = 0;

	if (memcmp(lha->method, "lh0", 3) == 0 ||

	    memcmp(lha->method, "lz4", 3) == 0)

		lha->entry_is_compressed = 0;

	else

		lha->entry_is_compressed = 1;

	lha->compsize = 0;

	lha->origsize = 0;

	lha->setflag = 0;

	lha->birthtime = 0;

	lha->birthtime_tv_nsec = 0;

	lha->mtime = 0;

	lha->mtime_tv_nsec = 0;

	lha->atime = 0;

	lha->atime_tv_nsec = 0;

	lha->mode = (lha->directory)? 0777 : 0666;

	lha->uid = 0;

	lha->gid = 0;

	archive_string_empty(&lha->dirname);

	archive_string_empty(&lha->filename);

	lha->dos_attr = 0;

	if (lha->opt_sconv != NULL)

		lha->sconv = lha->opt_sconv;

	else

		lha->sconv = NULL;

	switch (p[H_LEVEL_OFFSET]) {

	case 0:

		err = lha_read_file_header_0(a, lha);

		break;

	case 1:

		err = lha_read_file_header_1(a, lha);

		break;

	case 2:

		err = lha_read_file_header_2(a, lha);

		break;

	case 3:

		err = lha_read_file_header_3(a, lha);

		break;

	default:

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Unsupported LHa header level %d", p[H_LEVEL_OFFSET]);

		err = ARCHIVE_FATAL;

		break;

	}

	if (err < ARCHIVE_WARN)

		return (err);

	if (!lha->directory && archive_strlen(&lha->filename) == 0)

		/* The filename has not been set */

		return (truncated_error(a));

	/*

	 * Make a pathname from a dirname and a filename.

	 */

	archive_string_concat(&lha->dirname, &lha->filename);

	archive_string_init(&pathname);

	archive_string_init(&linkname);

	archive_string_copy(&pathname, &lha->dirname);

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

		/*

	 	 * Extract the symlink-name if it's included in the pathname.

	 	 */

		if (!lha_parse_linkname(&linkname, &pathname)) {

			/* We couldn't get the symlink-name. */

			archive_set_error(&a->archive,

		    	    ARCHIVE_ERRNO_FILE_FORMAT,

			    "Unknown symlink-name");

			archive_string_free(&pathname);

			archive_string_free(&linkname);

			return (ARCHIVE_FAILED);

		}

	} else {

		/*

		 * Make sure a file-type is set.

		 * The mode has been overridden if it is in the extended data.

		 */

		lha->mode = (lha->mode & ~AE_IFMT) |

		    ((lha->directory)? AE_IFDIR: AE_IFREG);

	}

	if ((lha->setflag & UNIX_MODE_IS_SET) == 0 &&

	    (lha->dos_attr & 1) != 0)

		lha->mode &= ~(0222);/* read only. */

	/*

	 * Set basic file parameters.

	 */

	if (archive_entry_copy_pathname_l(entry, pathname.s,

	    pathname.length, lha->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(lha->sconv));

		err = ARCHIVE_WARN;

	}

	archive_string_free(&pathname);

	if (archive_strlen(&linkname) > 0) {

		if (archive_entry_copy_symlink_l(entry, linkname.s,

		    linkname.length, lha->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(lha->sconv));

			err = ARCHIVE_WARN;

		}

	} else

		archive_entry_set_symlink(entry, NULL);

	archive_string_free(&linkname);

	/*

	 * When a header level is 0, there is a possibility that

	 * a pathname and a symlink has '\' character, a directory

	 * separator in DOS/Windows. So we should convert it to '/'.

	 */

	if (p[H_LEVEL_OFFSET] == 0)

		lha_replace_path_separator(lha, entry);

	archive_entry_set_mode(entry, lha->mode);

	archive_entry_set_uid(entry, lha->uid);

	archive_entry_set_gid(entry, lha->gid);

	if (archive_strlen(&lha->uname) > 0)

		archive_entry_set_uname(entry, lha->uname.s);

	if (archive_strlen(&lha->gname) > 0)

		archive_entry_set_gname(entry, lha->gname.s);

	if (lha->setflag & BIRTHTIME_IS_SET) {

		archive_entry_set_birthtime(entry, lha->birthtime,

		    lha->birthtime_tv_nsec);

		archive_entry_set_ctime(entry, lha->birthtime,

		    lha->birthtime_tv_nsec);

	} else {

		archive_entry_unset_birthtime(entry);

		archive_entry_unset_ctime(entry);

	}

	archive_entry_set_mtime(entry, lha->mtime, lha->mtime_tv_nsec);

	if (lha->setflag & ATIME_IS_SET)

		archive_entry_set_atime(entry, lha->atime,

		    lha->atime_tv_nsec);

	else

		archive_entry_unset_atime(entry);

	if (lha->directory || archive_entry_symlink(entry) != NULL)

		archive_entry_unset_size(entry);

	else

		archive_entry_set_size(entry, lha->origsize);

	/*

	 * Prepare variables used to read a file content.

	 */

	lha->entry_bytes_remaining = lha->compsize;

	lha->entry_offset = 0;

	lha->entry_crc_calculated = 0;

	/*

	 * This file does not have a content.

	 */

	if (lha->directory || lha->compsize == 0)

		lha->end_of_entry = 1;

	sprintf(lha->format_name, "lha -%c%c%c-",

	    lha->method[0], lha->method[1], lha->method[2]);

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

	return (err);

}

/*

 * Replace a DOS path separator '\' by a character '/'.

 * Some multi-byte character set have  a character '\' in its second byte.

 */

static void

lha_replace_path_separator(struct lha *lha, struct archive_entry *entry)

{

	const wchar_t *wp;

	size_t i;

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

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

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

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

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

		}

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

	}

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

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

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

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

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

		}

		archive_entry_copy_symlink_w(entry, lha->ws.s);

	}

}

/*

 * Header 0 format

 *

 * +0              +1         +2               +7                  +11

 * +---------------+----------+----------------+-------------------+

 * |header size(*1)|header sum|compression type|compressed size(*2)|

 * +---------------+----------+----------------+-------------------+

 *                             <---------------------(*1)----------*

 *

 * +11               +15       +17       +19            +20              +21

 * +-----------------+---------+---------+--------------+----------------+

 * |uncompressed size|time(DOS)|date(DOS)|attribute(DOS)|header level(=0)|

 * +-----------------+---------+---------+--------------+----------------+

 * *--------------------------------(*1)---------------------------------*

 *

 * +21             +22       +22+(*3)   +22+(*3)+2       +22+(*3)+2+(*4)

 * +---------------+---------+----------+----------------+------------------+

 * |name length(*3)|file name|file CRC16|extra header(*4)|  compressed data |

 * +---------------+---------+----------+----------------+------------------+

 *                  <--(*3)->                             <------(*2)------>

 * *----------------------(*1)-------------------------->

 *

 */

#define H0_HEADER_SIZE_OFFSET	0

#define H0_HEADER_SUM_OFFSET	1

#define H0_COMP_SIZE_OFFSET	7

#define H0_ORIG_SIZE_OFFSET	11

#define H0_DOS_TIME_OFFSET	15

#define H0_NAME_LEN_OFFSET	21

#define H0_FILE_NAME_OFFSET	22

#define H0_FIXED_SIZE		24

static int

lha_read_file_header_0(struct archive_read *a, struct lha *lha)

{

	const unsigned char *p;

	int extdsize, namelen;

	unsigned char headersum, sum_calculated;

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

		return (truncated_error(a));

	lha->header_size = p[H0_HEADER_SIZE_OFFSET] + 2;

	headersum = p[H0_HEADER_SUM_OFFSET];

	lha->compsize = archive_le32dec(p + H0_COMP_SIZE_OFFSET);

	lha->origsize = archive_le32dec(p + H0_ORIG_SIZE_OFFSET);

	lha->mtime = lha_dos_time(p + H0_DOS_TIME_OFFSET);

	namelen = p[H0_NAME_LEN_OFFSET];

	extdsize = (int)lha->header_size - H0_FIXED_SIZE - namelen;

	if ((namelen > 221 || extdsize < 0) && extdsize != -2) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Invalid LHa header");

		return (ARCHIVE_FATAL);

	}

	if ((p = __archive_read_ahead(a, lha->header_size, NULL)) == NULL)

		return (truncated_error(a));

	archive_strncpy(&lha->filename, p + H0_FILE_NAME_OFFSET, namelen);

	/* When extdsize == -2, A CRC16 value is not present in the header. */

	if (extdsize >= 0) {

		lha->crc = archive_le16dec(p + H0_FILE_NAME_OFFSET + namelen);

		lha->setflag |= CRC_IS_SET;

	}

	sum_calculated = lha_calcsum(0, p, 2, lha->header_size - 2);

	/* Read an extended header */

	if (extdsize > 0) {

		/* This extended data is set by 'LHa for UNIX' only.

		 * Maybe fixed size.

		 */

		p += H0_FILE_NAME_OFFSET + namelen + 2;

		if (p[0] == 'U' && extdsize == 12) {

			/* p[1] is a minor version. */

			lha->mtime = archive_le32dec(&p[2]);

			lha->mode = archive_le16dec(&p[6]);

			lha->uid = archive_le16dec(&p[8]);

			lha->gid = archive_le16dec(&p[10]);

			lha->setflag |= UNIX_MODE_IS_SET;

		}

	}

	__archive_read_consume(a, lha->header_size);

	if (sum_calculated != headersum) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

		    "LHa header sum error");

		return (ARCHIVE_FATAL);

	}

	return (ARCHIVE_OK);

}

/*

 * Header 1 format

 *

 * +0              +1         +2               +7            +11

 * +---------------+----------+----------------+-------------+

 * |header size(*1)|header sum|compression type|skip size(*2)|

 * +---------------+----------+----------------+-------------+

 *                             <---------------(*1)----------*

 *

 * +11               +15       +17       +19            +20              +21

 * +-----------------+---------+---------+--------------+----------------+

 * |uncompressed size|time(DOS)|date(DOS)|attribute(DOS)|header level(=1)|

 * +-----------------+---------+---------+--------------+----------------+

 * *-------------------------------(*1)----------------------------------*

 *

 * +21             +22       +22+(*3)   +22+(*3)+2  +22+(*3)+3  +22+(*3)+3+(*4)

 * +---------------+---------+----------+-----------+-----------+

 * |name length(*3)|file name|file CRC16|  creator  |padding(*4)|

 * +---------------+---------+----------+-----------+-----------+

 *                  <--(*3)->

 * *----------------------------(*1)----------------------------*

 *

 * +22+(*3)+3+(*4)  +22+(*3)+3+(*4)+2     +22+(*3)+3+(*4)+2+(*5)

 * +----------------+---------------------+------------------------+

 * |next header size| extended header(*5) |     compressed data    |

 * +----------------+---------------------+------------------------+

 * *------(*1)-----> <--------------------(*2)-------------------->

 */

#define H1_HEADER_SIZE_OFFSET	0

#define H1_HEADER_SUM_OFFSET	1

#define H1_COMP_SIZE_OFFSET	7

#define H1_ORIG_SIZE_OFFSET	11

#define H1_DOS_TIME_OFFSET	15

#define H1_NAME_LEN_OFFSET	21

#define H1_FILE_NAME_OFFSET	22

#define H1_FIXED_SIZE		27

static int

lha_read_file_header_1(struct archive_read *a, struct lha *lha)

{

	const unsigned char *p;

	size_t extdsize;

	int i, err, err2;

	int namelen, padding;