/*-

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

__FBSDID("$FreeBSD$");

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#include <stdlib.h>

#ifdef HAVE_BZLIB_H

#include <bzlib.h>

#endif

#if HAVE_LZMA_H

#include <lzma.h>

#endif

#ifdef HAVE_ZLIB_H

#include <zlib.h>

#endif

#include "archive.h"

#ifndef HAVE_ZLIB_H

#include "archive_crc32.h"

#endif

#include "archive_endian.h"

#include "archive_entry.h"

#include "archive_entry_locale.h"

#include "archive_ppmd7_private.h"

#include "archive_private.h"

#include "archive_rb.h"

#include "archive_string.h"

#include "archive_write_private.h"

/*

 * Codec ID

 */

#define _7Z_COPY	0

#define _7Z_LZMA1	0x030101

#define _7Z_LZMA2	0x21

#define _7Z_DEFLATE	0x040108

#define _7Z_BZIP2	0x040202

#define _7Z_PPMD	0x030401

/*

 * 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

enum la_zaction {

	ARCHIVE_Z_FINISH,

	ARCHIVE_Z_RUN

};

/*

 * A stream object of universal compressor.

 */

struct la_zstream {

	const uint8_t		*next_in;

	size_t			 avail_in;

	uint64_t		 total_in;

	uint8_t			*next_out;

	size_t			 avail_out;

	uint64_t		 total_out;

	uint32_t		 prop_size;

	uint8_t			*props;

	int			 valid;

	void			*real_stream;

	int			 (*code) (struct archive *a,

				    struct la_zstream *lastrm,

				    enum la_zaction action);

	int			 (*end)(struct archive *a,

				    struct la_zstream *lastrm);

};

#define PPMD7_DEFAULT_ORDER	6

#define PPMD7_DEFAULT_MEM_SIZE	(1 << 24)

struct ppmd_stream {

	int			 stat;

	CPpmd7			 ppmd7_context;

	CPpmd7z_RangeEnc	 range_enc;

	IByteOut		 byteout;

	uint8_t			*buff;

	uint8_t			*buff_ptr;

	uint8_t			*buff_end;

	size_t			 buff_bytes;

};

struct coder {

	unsigned		 codec;

	size_t			 prop_size;

	uint8_t			*props;

};

struct file {

	struct archive_rb_node	 rbnode;

	struct file		*next;

	unsigned		 name_len;

	uint8_t			*utf16name;/* UTF16-LE name. */

	uint64_t		 size;

	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)

	struct {

		time_t		 time;

		long		 time_ns;

	}			 times[3];

#define MTIME 0

#define ATIME 1

#define CTIME 2

	mode_t			 mode;

	uint32_t		 crc32;

	int			 dir:1;

};

struct _7zip {

	int			 temp_fd;

	uint64_t		 temp_offset;

	struct file		*cur_file;

	size_t			 total_number_entry;

	size_t			 total_number_nonempty_entry;

	size_t			 total_number_empty_entry;

	size_t			 total_number_dir_entry;

	size_t			 total_bytes_entry_name;

	size_t			 total_number_time_defined[3];

	uint64_t		 total_bytes_compressed;

	uint64_t		 total_bytes_uncompressed;

	uint64_t		 entry_bytes_remaining;

	uint32_t		 entry_crc32;

	uint32_t		 precode_crc32;

	uint32_t		 encoded_crc32;

	int			 crc32flg;

#define	PRECODE_CRC32	1

#define	ENCODED_CRC32	2

	unsigned		 opt_compression;

	int			 opt_compression_level;

	struct la_zstream	 stream;

	struct coder		 coder;

	struct archive_string_conv *sconv;

	/*

	 * Compressed data buffer.

	 */

	unsigned char		 wbuff[512 * 20 * 6];

	size_t			 wbuff_remaining;

	/*

	 * The list of the file entries which has its contents is used to

	 * manage struct file objects.

	 * We use 'next' (a member of struct file) to chain.

	 */

	struct {

		struct file	*first;

		struct file	**last;

	}			 file_list, empty_list;

	struct archive_rb_tree	 rbtree;/* for empty files */

};

static int	_7z_options(struct archive_write *,

		    const char *, const char *);

static int	_7z_write_header(struct archive_write *,

		    struct archive_entry *);

static ssize_t	_7z_write_data(struct archive_write *,

		    const void *, size_t);

static int	_7z_finish_entry(struct archive_write *);

static int	_7z_close(struct archive_write *);

static int	_7z_free(struct archive_write *);

static int	file_cmp_node(const struct archive_rb_node *,

		    const struct archive_rb_node *);

static int	file_cmp_key(const struct archive_rb_node *, const void *);

static int	file_new(struct archive_write *a, struct archive_entry *,

		    struct file **);

static void	file_free(struct file *);

static void	file_register(struct _7zip *, struct file *);

static void	file_register_empty(struct _7zip *, struct file *);

static void	file_init_register(struct _7zip *);

static void	file_init_register_empty(struct _7zip *);

static void	file_free_register(struct _7zip *);

static ssize_t	compress_out(struct archive_write *, const void *, size_t ,

		    enum la_zaction);

static int	compression_init_encoder_copy(struct archive *,

		    struct la_zstream *);

static int	compression_code_copy(struct archive *,

		    struct la_zstream *, enum la_zaction);

static int	compression_end_copy(struct archive *, struct la_zstream *);

static int	compression_init_encoder_deflate(struct archive *,

		    struct la_zstream *, int, int);

#ifdef HAVE_ZLIB_H

static int	compression_code_deflate(struct archive *,

		    struct la_zstream *, enum la_zaction);

static int	compression_end_deflate(struct archive *, struct la_zstream *);

#endif

static int	compression_init_encoder_bzip2(struct archive *,

		    struct la_zstream *, int);

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

static int	compression_code_bzip2(struct archive *,

		    struct la_zstream *, enum la_zaction);

static int	compression_end_bzip2(struct archive *, struct la_zstream *);

#endif

static int	compression_init_encoder_lzma1(struct archive *,

		    struct la_zstream *, int);

static int	compression_init_encoder_lzma2(struct archive *,

		    struct la_zstream *, int);

#if defined(HAVE_LZMA_H)

static int	compression_code_lzma(struct archive *,

		    struct la_zstream *, enum la_zaction);

static int	compression_end_lzma(struct archive *, struct la_zstream *);

#endif

static int	compression_init_encoder_ppmd(struct archive *,

		    struct la_zstream *, unsigned, uint32_t);

static int	compression_code_ppmd(struct archive *,

		    struct la_zstream *, enum la_zaction);

static int	compression_end_ppmd(struct archive *, struct la_zstream *);

static int	_7z_compression_init_encoder(struct archive_write *, unsigned,

		    int);

static int	compression_code(struct archive *,

		    struct la_zstream *, enum la_zaction);

static int	compression_end(struct archive *,

		    struct la_zstream *);

static int	enc_uint64(struct archive_write *, uint64_t);

static int	make_header(struct archive_write *, uint64_t, uint64_t,

		    uint64_t, int, struct coder *);

static int	make_streamsInfo(struct archive_write *, uint64_t, uint64_t,

		    	uint64_t, int, struct coder *, int, uint32_t);

int

archive_write_set_format_7zip(struct archive *_a)

{

	static const struct archive_rb_tree_ops rb_ops = {

		file_cmp_node, file_cmp_key

	};

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

	struct _7zip *zip;

	archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_write_set_format_7zip");

	/* If another format was already registered, unregister it. */

	if (a->format_free != NULL)

		(a->format_free)(a);

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

	if (zip == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate 7-Zip data");

		return (ARCHIVE_FATAL);

	}

	zip->temp_fd = -1;

	__archive_rb_tree_init(&(zip->rbtree), &rb_ops);

	file_init_register(zip);

	file_init_register_empty(zip);

	/* Set default compression type and its level. */

#if HAVE_LZMA_H

	zip->opt_compression = _7Z_LZMA1;

#elif defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)

	zip->opt_compression = _7Z_BZIP2;

#elif defined(HAVE_ZLIB_H)

	zip->opt_compression = _7Z_DEFLATE;

#else

	zip->opt_compression = _7Z_COPY;

#endif

	zip->opt_compression_level = 6;

	a->format_data = zip;

	a->format_name = "7zip";

	a->format_options = _7z_options;

	a->format_write_header = _7z_write_header;

	a->format_write_data = _7z_write_data;

	a->format_finish_entry = _7z_finish_entry;

	a->format_close = _7z_close;

	a->format_free = _7z_free;

	a->archive.archive_format = ARCHIVE_FORMAT_7ZIP;

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

	return (ARCHIVE_OK);

}

static int

_7z_options(struct archive_write *a, const char *key, const char *value)

{

	struct _7zip *zip;

	zip = (struct _7zip *)a->format_data;

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

		const char *name = NULL;

		if (value == NULL || strcmp(value, "copy") == 0 ||

		    strcmp(value, "COPY") == 0 ||

		    strcmp(value, "store") == 0 ||

		    strcmp(value, "STORE") == 0)

			zip->opt_compression = _7Z_COPY;

		else if (strcmp(value, "deflate") == 0 ||

		    strcmp(value, "DEFLATE") == 0)

#if HAVE_ZLIB_H

			zip->opt_compression = _7Z_DEFLATE;

#else

			name = "deflate";

#endif

		else if (strcmp(value, "bzip2") == 0 ||

		    strcmp(value, "BZIP2") == 0)

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

			zip->opt_compression = _7Z_BZIP2;

#else

			name = "bzip2";

#endif

		else if (strcmp(value, "lzma1") == 0 ||

		    strcmp(value, "LZMA1") == 0)

#if HAVE_LZMA_H

			zip->opt_compression = _7Z_LZMA1;

#else

			name = "lzma1";

#endif

		else if (strcmp(value, "lzma2") == 0 ||

		    strcmp(value, "LZMA2") == 0)

#if HAVE_LZMA_H

			zip->opt_compression = _7Z_LZMA2;

#else

			name = "lzma2";

#endif

		else if (strcmp(value, "ppmd") == 0 ||

		    strcmp(value, "PPMD") == 0 ||

		    strcmp(value, "PPMd") == 0)

			zip->opt_compression = _7Z_PPMD;

		else {

			archive_set_error(&(a->archive),

			    ARCHIVE_ERRNO_MISC,

			    "Unknown compression name: `%s'",

			    value);

			return (ARCHIVE_FAILED);

		}

		if (name != NULL) {

			archive_set_error(&(a->archive),

			    ARCHIVE_ERRNO_MISC,

			    "`%s' compression not supported "

			    "on this platform",

			    name);

			return (ARCHIVE_FAILED);

		}

		return (ARCHIVE_OK);

	}

	if (strcmp(key, "compression-level") == 0) {

		if (value == NULL ||

		    !(value[0] >= '0' && value[0] <= '9') ||

		    value[1] != '\0') {

			archive_set_error(&(a->archive),

			    ARCHIVE_ERRNO_MISC,

			    "Illegal value `%s'",

			    value);

			return (ARCHIVE_FAILED);

		}

		zip->opt_compression_level = value[0] - '0';

		return (ARCHIVE_OK);

	}

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

_7z_write_header(struct archive_write *a, struct archive_entry *entry)

{

	struct _7zip *zip;

	struct file *file;

	int r;

	zip = (struct _7zip *)a->format_data;

	zip->cur_file = NULL;

	zip->entry_bytes_remaining = 0;

	if (zip->sconv == NULL) {

		zip->sconv = archive_string_conversion_to_charset(

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

		if (zip->sconv == NULL)

			return (ARCHIVE_FATAL);

	}

	r = file_new(a, entry, &file;;

	if (r < ARCHIVE_WARN) {

		file_free(file);

		return (r);

	}

	if (file->size == 0 && file->dir) {

		if (!__archive_rb_tree_insert_node(&(zip->rbtree),

		    (struct archive_rb_node *)file)) {

			/* We have already had the same file. */

			file_free(file);

			return (ARCHIVE_OK);

		}

	}

	if (file->flg & MTIME_IS_SET)

		zip->total_number_time_defined[MTIME]++;

	if (file->flg & CTIME_IS_SET)

		zip->total_number_time_defined[CTIME]++;

	if (file->flg & ATIME_IS_SET)

		zip->total_number_time_defined[ATIME]++;

	zip->total_number_entry++;

	zip->total_bytes_entry_name += file->name_len + 2;

	if (file->size == 0) {

		/* Count up the number of empty files. */

		zip->total_number_empty_entry++;

		if (file->dir)

			zip->total_number_dir_entry++;

		else

			file_register_empty(zip, file);

		return (r);

	}

	/*

	 * Init compression.

	 */

	if ((zip->total_number_entry - zip->total_number_empty_entry) == 1) {

		r = _7z_compression_init_encoder(a, zip->opt_compression,

			zip->opt_compression_level);

		if (r < 0) {

			file_free(file);

			return (ARCHIVE_FATAL);

		}

	}

	/* Register a non-empty file. */

	file_register(zip, file);

	/*

	 * Set the current file to cur_file to read its contents.

	 */

	zip->cur_file = file;

	/* Save a offset of current file in temporary file. */

	zip->entry_bytes_remaining = file->size;

	zip->entry_crc32 = 0;

	/*

	 * Store a symbolic link name as file contents.

	 */

	if (archive_entry_filetype(entry) == AE_IFLNK) {

		ssize_t bytes;

		const void *p = (const void *)archive_entry_symlink(entry);

		bytes = compress_out(a, p, (size_t)file->size, ARCHIVE_Z_RUN);

		if (bytes < 0)

			return ((int)bytes);

		zip->entry_crc32 = crc32(zip->entry_crc32, p, (unsigned)bytes);

		zip->entry_bytes_remaining -= bytes;

	}

	return (r);

}

/*

 * Write data to a temporary file.

 */

static int

write_to_temp(struct archive_write *a, const void *buff, size_t s)

{

	struct _7zip *zip;

	const unsigned char *p;

	ssize_t ws;

	zip = (struct _7zip *)a->format_data;

	/*

	 * Open a temporary file.

	 */

	if (zip->temp_fd == -1) {

		zip->temp_offset = 0;

		zip->temp_fd = __archive_mktemp(NULL);

		if (zip->temp_fd < 0) {

			archive_set_error(&a->archive, errno,

			    "Couldn't create temporary file");

			return (ARCHIVE_FATAL);

		}

	}

	p = (const unsigned char *)buff;

	while (s) {

		ws = write(zip->temp_fd, p, s);

		if (ws < 0) {

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

			    "fwrite function failed");

			return (ARCHIVE_FATAL);

		}

		s -= ws;

		p += ws;

		zip->temp_offset += ws;

	}

	return (ARCHIVE_OK);

}

static ssize_t

compress_out(struct archive_write *a, const void *buff, size_t s,

    enum la_zaction run)

{

	struct _7zip *zip = (struct _7zip *)a->format_data;

	int r;

	if (run == ARCHIVE_Z_FINISH && zip->stream.total_in == 0 && s == 0)

		return (0);

	if ((zip->crc32flg & PRECODE_CRC32) && s)

		zip->precode_crc32 = crc32(zip->precode_crc32, buff,

		    (unsigned)s);

	zip->stream.next_in = (const unsigned char *)buff;

	zip->stream.avail_in = s;

	for (;;) {

		/* Compress file data. */

		r = compression_code(&(a->archive), &(zip->stream), run);

		if (r != ARCHIVE_OK && r != ARCHIVE_EOF)

			return (ARCHIVE_FATAL);

		if (zip->stream.avail_out == 0) {

			if (write_to_temp(a, zip->wbuff, sizeof(zip->wbuff))

			    != ARCHIVE_OK)

				return (ARCHIVE_FATAL);

			zip->stream.next_out = zip->wbuff;

			zip->stream.avail_out = sizeof(zip->wbuff);

			if (zip->crc32flg & ENCODED_CRC32)

				zip->encoded_crc32 = crc32(zip->encoded_crc32,

				    zip->wbuff, sizeof(zip->wbuff));

			if (run == ARCHIVE_Z_FINISH && r != ARCHIVE_EOF)

				continue;

		}

		if (zip->stream.avail_in == 0)

			break;

	}

	if (run == ARCHIVE_Z_FINISH) {

		uint64_t bytes = sizeof(zip->wbuff) - zip->stream.avail_out;

		if (write_to_temp(a, zip->wbuff, (size_t)bytes) != ARCHIVE_OK)

			return (ARCHIVE_FATAL);

		if ((zip->crc32flg & ENCODED_CRC32) && bytes)

			zip->encoded_crc32 = crc32(zip->encoded_crc32,

			    zip->wbuff, (unsigned)bytes);

	}

	return (s);

}

static ssize_t

_7z_write_data(struct archive_write *a, const void *buff, size_t s)

{

	struct _7zip *zip;

	ssize_t bytes;

	zip = (struct _7zip *)a->format_data;

	if (s > zip->entry_bytes_remaining)

		s = (size_t)zip->entry_bytes_remaining;

	if (s == 0 || zip->cur_file == NULL)

		return (0);

	bytes = compress_out(a, buff, s, ARCHIVE_Z_RUN);

	if (bytes < 0)

		return (bytes);

	zip->entry_crc32 = crc32(zip->entry_crc32, buff, (unsigned)bytes);

	zip->entry_bytes_remaining -= bytes;

	return (bytes);

}

static int

_7z_finish_entry(struct archive_write *a)

{

	struct _7zip *zip;

	size_t s;

	ssize_t r;

	zip = (struct _7zip *)a->format_data;

	if (zip->cur_file == NULL)

		return (ARCHIVE_OK);

	while (zip->entry_bytes_remaining > 0) {

		s = (size_t)zip->entry_bytes_remaining;

		if (s > a->null_length)

			s = a->null_length;

		r = _7z_write_data(a, a->nulls, s);

		if (r < 0)

			return ((int)r);

	}

	zip->total_bytes_compressed += zip->stream.total_in;

	zip->total_bytes_uncompressed += zip->stream.total_out;

	zip->cur_file->crc32 = zip->entry_crc32;

	zip->cur_file = NULL;

	return (ARCHIVE_OK);

}

static int

flush_wbuff(struct archive_write *a)

{

	struct _7zip *zip;

	int r;

	size_t s;

	zip = (struct _7zip *)a->format_data;

	s = sizeof(zip->wbuff) - zip->wbuff_remaining;

	r = __archive_write_output(a, zip->wbuff, s);

	if (r != ARCHIVE_OK)

		return (r);

	zip->wbuff_remaining = sizeof(zip->wbuff);

	return (r);

}

static int

copy_out(struct archive_write *a, uint64_t offset, uint64_t length)

{

	struct _7zip *zip;

	int r;

	zip = (struct _7zip *)a->format_data;

	if (zip->temp_offset > 0 &&

	    lseek(zip->temp_fd, offset, SEEK_SET) < 0) {

		archive_set_error(&(a->archive), errno, "lseek failed");

		return (ARCHIVE_FATAL);

	}

	while (length) {

		size_t rsize;

		ssize_t rs;

		unsigned char *wb;

		if (length > zip->wbuff_remaining)

			rsize = zip->wbuff_remaining;

		else

			rsize = (size_t)length;

		wb = zip->wbuff + (sizeof(zip->wbuff) - zip->wbuff_remaining);

		rs = read(zip->temp_fd, wb, rsize);

		if (rs < 0) {

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

			    "Can't read temporary file(%jd)",

			    (intmax_t)rs);

			return (ARCHIVE_FATAL);

		}

		if (rs == 0) {

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

			    "Truncated 7-Zip archive");

			return (ARCHIVE_FATAL);

		}

		zip->wbuff_remaining -= rs;

		length -= rs;

		if (zip->wbuff_remaining == 0) {

			r = flush_wbuff(a);

			if (r != ARCHIVE_OK)

				return (r);

		}

	}

	return (ARCHIVE_OK);

}

static int

_7z_close(struct archive_write *a)

{

	struct _7zip *zip;

	unsigned char *wb;

	uint64_t header_offset, header_size, header_unpacksize;

	uint64_t length;

	uint32_t header_crc32;

	int r;

	zip = (struct _7zip *)a->format_data;

	if (zip->total_number_entry > 0) {

		struct archive_rb_node *n;

		uint64_t data_offset, data_size, data_unpacksize;

		unsigned header_compression;

		r = (int)compress_out(a, NULL, 0, ARCHIVE_Z_FINISH);

		if (r < 0)

			return (r);

		data_offset = 0;

		data_size = zip->stream.total_out;

		data_unpacksize = zip->stream.total_in;

		zip->coder.codec = zip->opt_compression;

		zip->coder.prop_size = zip->stream.prop_size;

		zip->coder.props = zip->stream.props;

		zip->stream.prop_size = 0;

		zip->stream.props = NULL;

		zip->total_number_nonempty_entry =

		    zip->total_number_entry - zip->total_number_empty_entry;

		/* Connect an empty file list. */

		if (zip->empty_list.first != NULL) {

			*zip->file_list.last = zip->empty_list.first;

			zip->file_list.last = zip->empty_list.last;

		}

		/* Connect a directory file list. */

		ARCHIVE_RB_TREE_FOREACH(n, &(zip->rbtree)) {

			file_register(zip, (struct file *)n);

		}

		/*

		 * NOTE: 7z command supports just LZMA1, LZMA2 and COPY for

		 * the compression type for encoding the header.

		 */

#if HAVE_LZMA_H

		header_compression = _7Z_LZMA1;

		/* If the stored file is only one, do not encode the header.

		 * This is the same way 7z command does. */

		if (zip->total_number_entry == 1)

			header_compression = _7Z_COPY;

#else

		header_compression = _7Z_COPY;

#endif

		r = _7z_compression_init_encoder(a, header_compression, 6);

		if (r < 0)

			return (r);

		zip->crc32flg = PRECODE_CRC32;

		zip->precode_crc32 = 0;

		r = make_header(a, data_offset, data_size, data_unpacksize,

			1, &(zip->coder));

		if (r < 0)

			return (r);

		r = (int)compress_out(a, NULL, 0, ARCHIVE_Z_FINISH);

		if (r < 0)

			return (r);

		header_offset = data_offset + data_size;

		header_size = zip->stream.total_out;

		header_crc32 = zip->precode_crc32;

		header_unpacksize = zip->stream.total_in;

		if (header_compression != _7Z_COPY) {

			/*

			 * Encode the header in order to reduce the size

			 * of the archive.

			 */

			free(zip->coder.props);

			zip->coder.codec = header_compression;

			zip->coder.prop_size = zip->stream.prop_size;

			zip->coder.props = zip->stream.props;

			zip->stream.prop_size = 0;

			zip->stream.props = NULL;

			r = _7z_compression_init_encoder(a, _7Z_COPY, 0);

			if (r < 0)

				return (r);

			zip->crc32flg = ENCODED_CRC32;

			zip->encoded_crc32 = 0;

			/*

			 * Make EncodedHeader.

			 */

			r = enc_uint64(a, kEncodedHeader);

			if (r < 0)

				return (r);

			r = make_streamsInfo(a, header_offset, header_size,

			      header_unpacksize, 1, &(zip->coder), 0,

			      header_crc32);

			if (r < 0)

				return (r);

			r = (int)compress_out(a, NULL, 0, ARCHIVE_Z_FINISH);

			if (r < 0)

				return (r);

			header_offset = header_offset + header_size;

			header_size = zip->stream.total_out;

			header_crc32 = zip->encoded_crc32;

		}

		zip->crc32flg = 0;

	} else {

		header_offset = header_size = 0;

		header_crc32 = 0;

	}

	length = zip->temp_offset;

	/*

	 * Make the zip header on wbuff(write buffer).

	 */

	wb = zip->wbuff;

	zip->wbuff_remaining = sizeof(zip->wbuff);

	memcpy(&wb[0], "7z\xBC\xAF\x27\x1C", 6);

	wb[6] = 0;/* Major version. */

	wb[7] = 3;/* Minor version. */

	archive_le64enc(&wb[12], header_offset);/* Next Header Offset */

	archive_le64enc(&wb[20], header_size);/* Next Header Size */

	archive_le32enc(&wb[28], header_crc32);/* Next Header CRC */

	archive_le32enc(&wb[8], crc32(0, &wb[12], 20));/* Start Header CRC */

	zip->wbuff_remaining -= 32;

	/*

	 * Read all file contents and an encoded header from the temporary

	 * file and write out it.

	 */

	r = copy_out(a, 0, length);

	if (r != ARCHIVE_OK)

		return (r);

	r = flush_wbuff(a);

	return (r);

}

/*

 * Encode 64 bits value into 7-Zip's encoded UINT64 value.

 */

static int

enc_uint64(struct archive_write *a, uint64_t val)

{

	unsigned mask = 0x80;

	uint8_t numdata[9];

	int i;

	numdata[0] = 0;

	for (i = 1; i < (int)sizeof(numdata); i++) {

		if (val < mask) {

			numdata[0] |= (uint8_t)val;

			break;

		}

		numdata[i] = (uint8_t)val;

		val >>= 8;

		numdata[0] |= mask;

		mask >>= 1;

	}

	return ((int)compress_out(a, numdata, i, ARCHIVE_Z_RUN));

}

static int

make_substreamsInfo(struct archive_write *a, struct coder *coders)

{

	struct _7zip *zip = (struct _7zip *)a->format_data;

	struct file *file;

	int r;

	/*