/*-

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

__FBSDID("$FreeBSD$");

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_LIMITS_H

#include <limits.h>

#endif

#include <stdlib.h>

#if HAVE_LIBXML_XMLWRITER_H

#include <libxml/xmlwriter.h>

#endif

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

#include "archive_digest_private.h"

#include "archive_endian.h"

#include "archive_entry.h"

#include "archive_entry_locale.h"

#include "archive_private.h"

#include "archive_rb.h"

#include "archive_string.h"

#include "archive_write_private.h"

/*

 * Differences to xar utility.

 * - Subdocument is not supported yet.

 * - ACL is not supported yet.

 * - When writing an XML element <link type="<file-type>">, <file-type>

 *   which is a file type a symbolic link is referencing is always marked

 *   as "broken". Xar utility uses stat(2) to get the file type, but, in

 *   libarchive format writer, we should not use it; if it is needed, we

 *   should get about it at archive_read_disk.c.

 * - It is possible to appear both <flags> and <ext2> elements.

 *   Xar utility generates <flags> on BSD platform and <ext2> on Linux

 *   platform.

 *

 */

#if !(defined(HAVE_LIBXML_XMLWRITER_H) && defined(LIBXML_VERSION) &&\

	LIBXML_VERSION >= 20703) ||\

	!defined(HAVE_ZLIB_H) || \

	!defined(ARCHIVE_HAS_MD5) || !defined(ARCHIVE_HAS_SHA1)

/*

 * xar needs several external libraries.

 *   o libxml2

 *   o openssl or MD5/SHA1 hash function

 *   o zlib

 *   o bzlib2 (option)

 *   o liblzma (option)

 */

int

archive_write_set_format_xar(struct archive *_a)

{

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

	archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

	    "Xar not supported on this platform");

	return (ARCHIVE_WARN);

}

#else	/* Support xar format */

/*#define DEBUG_PRINT_TOC		1 */

#define BAD_CAST_CONST (const xmlChar *)

#define HEADER_MAGIC	0x78617221

#define HEADER_SIZE	28

#define HEADER_VERSION	1

enum sumalg {

	CKSUM_NONE = 0,

	CKSUM_SHA1 = 1,

	CKSUM_MD5 = 2

};

#define MD5_SIZE	16

#define SHA1_SIZE	20

#define MAX_SUM_SIZE	20

#define MD5_NAME	"md5"

#define SHA1_NAME	"sha1"

enum enctype {

	NONE,

	GZIP,

	BZIP2,

	LZMA,

	XZ,

};

struct chksumwork {

	enum sumalg		 alg;

#ifdef ARCHIVE_HAS_MD5

	archive_md5_ctx		 md5ctx;

#endif

#ifdef ARCHIVE_HAS_SHA1

	archive_sha1_ctx	 sha1ctx;

#endif

};

enum la_zaction {

	ARCHIVE_Z_FINISH,

	ARCHIVE_Z_RUN

};

/*

 * Universal zstream.

 */

struct la_zstream {

	const unsigned char	*next_in;

	size_t			 avail_in;

	uint64_t		 total_in;

	unsigned char		*next_out;

	size_t			 avail_out;

	uint64_t		 total_out;

	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);

};

struct chksumval {

	enum sumalg		 alg;

	size_t			 len;

	unsigned char		 val[MAX_SUM_SIZE];

};

struct heap_data {

	int			 id;

	struct heap_data	*next;

	uint64_t		 temp_offset;

	uint64_t		 length;	/* archived size.	*/

	uint64_t		 size;		/* extracted size.	*/

	enum enctype		 compression;

	struct chksumval	 a_sum;		/* archived checksum.	*/

	struct chksumval	 e_sum;		/* extracted checksum.	*/

};

struct file {

	struct archive_rb_node	 rbnode;

	int			 id;

	struct archive_entry	*entry;

	struct archive_rb_tree	 rbtree;

	struct file		*next;

	struct file		*chnext;

	struct file		*hlnext;

	/* For hardlinked files.

	 * Use only when archive_entry_nlink() > 1 */

	struct file		*hardlink_target;

	struct file		*parent;	/* parent directory entry */

	/*

	 * To manage sub directory files.

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

	 */

	struct {

		struct file	*first;

		struct file	**last;

	}			 children;

	/* For making a directory tree. */

        struct archive_string    parentdir;

        struct archive_string    basename;

        struct archive_string    symlink;

	int			 ea_idx;

	struct {

		struct heap_data *first;

		struct heap_data **last;

	}			 xattr;

	struct heap_data	 data;

        struct archive_string    script;

	int			 virtual:1;

	int			 dir:1;

};

struct hardlink {

	struct archive_rb_node	 rbnode;

	int			 nlink;

	struct {

		struct file	*first;

		struct file	**last;

	}			 file_list;

};

struct xar {

	int			 temp_fd;

	uint64_t		 temp_offset;

	int			 file_idx;

	struct file		*root;

	struct file		*cur_dirent;

	struct archive_string	 cur_dirstr;

	struct file		*cur_file;

	uint64_t		 bytes_remaining;

	struct archive_string	 tstr;

	struct archive_string	 vstr;

	enum sumalg		 opt_toc_sumalg;

	enum sumalg		 opt_sumalg;

	enum enctype		 opt_compression;

	int			 opt_compression_level;

	uint32_t		 opt_threads;

	struct chksumwork	 a_sumwrk;	/* archived checksum.	*/

	struct chksumwork	 e_sumwrk;	/* extracted checksum.	*/

	struct la_zstream	 stream;

	struct archive_string_conv *sconv;

	/*

	 * Compressed data buffer.

	 */

	unsigned char		 wbuff[1024 * 64];

	size_t			 wbuff_remaining;

	struct heap_data	 toc;

	/*

	 * The list of all file entries 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;

	/*

	 * The list of hard-linked file entries.

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

	 */

	struct archive_rb_tree	 hardlink_rbtree;

};

static int	xar_options(struct archive_write *,

		    const char *, const char *);

static int	xar_write_header(struct archive_write *,

		    struct archive_entry *);

static ssize_t	xar_write_data(struct archive_write *,

		    const void *, size_t);

static int	xar_finish_entry(struct archive_write *);

static int	xar_close(struct archive_write *);

static int	xar_free(struct archive_write *);

static struct file *file_new(struct archive_write *a, struct archive_entry *);

static void	file_free(struct file *);

static struct file *file_create_virtual_dir(struct archive_write *a, struct xar *,

		    const char *);

static int	file_add_child_tail(struct file *, struct file *);

static struct file *file_find_child(struct file *, const char *);

static int	file_gen_utility_names(struct archive_write *,

		    struct file *);

static int	get_path_component(char *, int, const char *);

static int	file_tree(struct archive_write *, struct file **);

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

static void	file_init_register(struct xar *);

static void	file_free_register(struct xar *);

static int	file_register_hardlink(struct archive_write *,

		    struct file *);

static void	file_connect_hardlink_files(struct xar *);

static void	file_init_hardlinks(struct xar *);

static void	file_free_hardlinks(struct xar *);

static void	checksum_init(struct chksumwork *, enum sumalg);

static void	checksum_update(struct chksumwork *, const void *, size_t);

static void	checksum_final(struct chksumwork *, struct chksumval *);

static int	compression_init_encoder_gzip(struct archive *,

		    struct la_zstream *, int, int);

static int	compression_code_gzip(struct archive *,

		    struct la_zstream *, enum la_zaction);

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

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_lzma(struct archive *,

		    struct la_zstream *, int);

static int	compression_init_encoder_xz(struct archive *,

		    struct la_zstream *, int, 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	xar_compression_init_encoder(struct archive_write *);

static int	compression_code(struct archive *,

		    struct la_zstream *, enum la_zaction);

static int	compression_end(struct archive *,

		    struct la_zstream *);

static int	save_xattrs(struct archive_write *, struct file *);

static int	getalgsize(enum sumalg);

static const char *getalgname(enum sumalg);

int

archive_write_set_format_xar(struct archive *_a)

{

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

	struct xar *xar;

	archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_write_set_format_xar");

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

	if (a->format_free != NULL)

		(a->format_free)(a);

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

	if (xar == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate xar data");

		return (ARCHIVE_FATAL);

	}

	xar->temp_fd = -1;

	file_init_register(xar);

	file_init_hardlinks(xar);

	archive_string_init(&(xar->tstr));

	archive_string_init(&(xar->vstr));

	/*

	 * Create the root directory.

	 */

	xar->root = file_create_virtual_dir(a, xar, "");

	if (xar->root == NULL) {

		free(xar);

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate xar data");

		return (ARCHIVE_FATAL);

	}

	xar->root->parent = xar->root;

	file_register(xar, xar->root);

	xar->cur_dirent = xar->root;

	archive_string_init(&(xar->cur_dirstr));

	archive_string_ensure(&(xar->cur_dirstr), 1);

	xar->cur_dirstr.s[0] = 0;

	/*

	 * Initialize option.

	 */

	/* Set default checksum type. */

	xar->opt_toc_sumalg = CKSUM_SHA1;

	xar->opt_sumalg = CKSUM_SHA1;

	/* Set default compression type, level, and number of threads. */

	xar->opt_compression = GZIP;

	xar->opt_compression_level = 6;

	xar->opt_threads = 1;

	a->format_data = xar;

	a->format_name = "xar";

	a->format_options = xar_options;

	a->format_write_header = xar_write_header;

	a->format_write_data = xar_write_data;

	a->format_finish_entry = xar_finish_entry;

	a->format_close = xar_close;

	a->format_free = xar_free;

	a->archive.archive_format = ARCHIVE_FORMAT_XAR;

	a->archive.archive_format_name = "xar";

	return (ARCHIVE_OK);

}

static int

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

{

	struct xar *xar;

	xar = (struct xar *)a->format_data;

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

		if (value == NULL)

			xar->opt_sumalg = CKSUM_NONE;

		else if (strcmp(value, "sha1") == 0)

			xar->opt_sumalg = CKSUM_SHA1;

		else if (strcmp(value, "md5") == 0)

			xar->opt_sumalg = CKSUM_MD5;

		else {

			archive_set_error(&(a->archive),

			    ARCHIVE_ERRNO_MISC,

			    "Unknown checksum name: `%s'",

			    value);

			return (ARCHIVE_FAILED);

		}

		return (ARCHIVE_OK);

	}

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

		const char *name = NULL;

		if (value == NULL)

			xar->opt_compression = NONE;

		else if (strcmp(value, "gzip") == 0)

			xar->opt_compression = GZIP;

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

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

			xar->opt_compression = BZIP2;

#else

			name = "bzip2";

#endif

		else if (strcmp(value, "lzma") == 0)

#if HAVE_LZMA_H

			xar->opt_compression = LZMA;

#else

			name = "lzma";

#endif

		else if (strcmp(value, "xz") == 0)

#if HAVE_LZMA_H

			xar->opt_compression = XZ;

#else

			name = "xz";

#endif

		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);

		}

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

		return (ARCHIVE_OK);

	}

	if (strcmp(key, "toc-checksum") == 0) {

		if (value == NULL)

			xar->opt_toc_sumalg = CKSUM_NONE;

		else if (strcmp(value, "sha1") == 0)

			xar->opt_toc_sumalg = CKSUM_SHA1;

		else if (strcmp(value, "md5") == 0)

			xar->opt_toc_sumalg = CKSUM_MD5;

		else {

			archive_set_error(&(a->archive),

			    ARCHIVE_ERRNO_MISC,

			    "Unknown checksum name: `%s'",

			    value);

			return (ARCHIVE_FAILED);

		}

		return (ARCHIVE_OK);

	}

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

		if (value == NULL)

			return (ARCHIVE_FAILED);

		xar->opt_threads = (int)strtoul(value, NULL, 10);

		if (xar->opt_threads == 0 && errno != 0) {

			xar->opt_threads = 1;

			archive_set_error(&(a->archive),

			    ARCHIVE_ERRNO_MISC,

			    "Illegal value `%s'",

			    value);

			return (ARCHIVE_FAILED);

		}

		if (xar->opt_threads == 0) {

#ifdef HAVE_LZMA_STREAM_ENCODER_MT

			xar->opt_threads = lzma_cputhreads();

#else

			xar->opt_threads = 1;

#endif

		}

	}

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

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

{

	struct xar *xar;

	struct file *file;

	struct archive_entry *file_entry;

	int r, r2;

	xar = (struct xar *)a->format_data;

	xar->cur_file = NULL;

	xar->bytes_remaining = 0;

	if (xar->sconv == NULL) {

		xar->sconv = archive_string_conversion_to_charset(

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

		if (xar->sconv == NULL)

			return (ARCHIVE_FATAL);

	}

	file = file_new(a, entry);

	if (file == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate data");

		return (ARCHIVE_FATAL);

	}

	r2 = file_gen_utility_names(a, file);

	if (r2 < ARCHIVE_WARN)

		return (r2);

	/*

	 * Ignore a path which looks like the top of directory name

	 * since we have already made the root directory of an Xar archive.

	 */

	if (archive_strlen(&(file->parentdir)) == 0 &&

	    archive_strlen(&(file->basename)) == 0) {

		file_free(file);

		return (r2);

	}

	/* Add entry into tree */

	file_entry = file->entry;

	r = file_tree(a, &file;;

	if (r != ARCHIVE_OK)

		return (r);

	/* There is the same file in tree and

	 * the current file is older than the file in tree.

	 * So we don't need the current file data anymore. */

	if (file->entry != file_entry)

		return (r2);

	if (file->id == 0)

		file_register(xar, file);

	/* A virtual file, which is a directory, does not have

	 * any contents and we won't store it into a archive

	 * file other than its name. */

	if (file->virtual)

		return (r2);

	/*

	 * Prepare to save the contents of the file.

	 */

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

		int algsize;

		xar->temp_offset = 0;

		xar->temp_fd = __archive_mktemp(NULL);

		if (xar->temp_fd < 0) {

			archive_set_error(&a->archive, errno,

			    "Couldn't create temporary file");

			return (ARCHIVE_FATAL);

		}

		algsize = getalgsize(xar->opt_toc_sumalg);

		if (algsize > 0) {

			if (lseek(xar->temp_fd, algsize, SEEK_SET) < 0) {

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

				    "lseek failed");

				return (ARCHIVE_FATAL);

			}

			xar->temp_offset = algsize;

		}

	}

	if (archive_entry_hardlink(file->entry) == NULL) {

		r = save_xattrs(a, file);

		if (r != ARCHIVE_OK)

			return (ARCHIVE_FATAL);

	}

	/* Non regular files contents are unneeded to be saved to

	 * a temporary file. */

	if (archive_entry_filetype(file->entry) != AE_IFREG)

		return (r2);

	/*

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

	 */

	xar->cur_file = file;

	if (archive_entry_nlink(file->entry) > 1) {

		r = file_register_hardlink(a, file);

		if (r != ARCHIVE_OK)

			return (r);

		if (archive_entry_hardlink(file->entry) != NULL) {

			archive_entry_unset_size(file->entry);

			return (r2);

		}

	}

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

	file->data.temp_offset = xar->temp_offset;

	file->data.size = archive_entry_size(file->entry);

	file->data.compression = xar->opt_compression;

	xar->bytes_remaining = archive_entry_size(file->entry);

	checksum_init(&(xar->a_sumwrk), xar->opt_sumalg);

	checksum_init(&(xar->e_sumwrk), xar->opt_sumalg);

	r = xar_compression_init_encoder(a);

	if (r != ARCHIVE_OK)

		return (r);

	else

		return (r2);

}

static int

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

{

	struct xar *xar;

	const unsigned char *p;

	ssize_t ws;

	xar = (struct xar *)a->format_data;

	p = (const unsigned char *)buff;

	while (s) {

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

		if (ws < 0) {

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

			    "fwrite function failed");

			return (ARCHIVE_FATAL);

		}

		s -= ws;

		p += ws;

		xar->temp_offset += ws;

	}

	return (ARCHIVE_OK);

}

static ssize_t

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

{

	struct xar *xar;

	enum la_zaction run;

	size_t size, rsize;

	int r;

	xar = (struct xar *)a->format_data;

	if (s > xar->bytes_remaining)

		s = (size_t)xar->bytes_remaining;

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

		return (0);

	if (xar->cur_file->data.compression == NONE) {

		checksum_update(&(xar->e_sumwrk), buff, s);

		checksum_update(&(xar->a_sumwrk), buff, s);

		size = rsize = s;

	} else {

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

		xar->stream.avail_in = s;

		if (xar->bytes_remaining > s)

			run = ARCHIVE_Z_RUN;

		else

			run = ARCHIVE_Z_FINISH;

		/* Compress file data. */

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

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

			return (ARCHIVE_FATAL);

		rsize = s - xar->stream.avail_in;

		checksum_update(&(xar->e_sumwrk), buff, rsize);

		size = sizeof(xar->wbuff) - xar->stream.avail_out;

		checksum_update(&(xar->a_sumwrk), xar->wbuff, size);

	}

#if !defined(_WIN32) || defined(__CYGWIN__)

	if (xar->bytes_remaining ==

	    (uint64_t)archive_entry_size(xar->cur_file->entry)) {

		/*

		 * Get the path of a shell script if so.

		 */

		const unsigned char *b = (const unsigned char *)buff;

		archive_string_empty(&(xar->cur_file->script));

		if (rsize > 2 && b[0] == '#' && b[1] == '!') {

			size_t i, end, off;

			off = 2;

			if (b[off] == ' ')

				off++;

#ifdef PATH_MAX

			if ((rsize - off) > PATH_MAX)

				end = off + PATH_MAX;

			else

#endif

				end = rsize;

			/* Find the end of a script path. */

			for (i = off; i < end && b[i] != '\0' &&

			    b[i] != '\n' && b[i] != '\r' &&

			    b[i] != ' ' && b[i] != '\t'; i++)

				;

			archive_strncpy(&(xar->cur_file->script), b + off,

			    i - off);

		}

	}

#endif

	if (xar->cur_file->data.compression == NONE) {

		if (write_to_temp(a, buff, size) != ARCHIVE_OK)

			return (ARCHIVE_FATAL);

	} else {

		if (write_to_temp(a, xar->wbuff, size) != ARCHIVE_OK)

			return (ARCHIVE_FATAL);

	}

	xar->bytes_remaining -= rsize;

	xar->cur_file->data.length += size;

	return (rsize);

}

static int

xar_finish_entry(struct archive_write *a)

{

	struct xar *xar;

	struct file *file;

	size_t s;

	ssize_t w;

	xar = (struct xar *)a->format_data;

	if (xar->cur_file == NULL)

		return (ARCHIVE_OK);

	while (xar->bytes_remaining > 0) {

		s = (size_t)xar->bytes_remaining;

		if (s > a->null_length)

			s = a->null_length;

		w = xar_write_data(a, a->nulls, s);

		if (w > 0)

			xar->bytes_remaining -= w;

		else

			return (w);

	}

	file = xar->cur_file;

	checksum_final(&(xar->e_sumwrk), &(file->data.e_sum));

	checksum_final(&(xar->a_sumwrk), &(file->data.a_sum));

	xar->cur_file = NULL;

	return (ARCHIVE_OK);

}

static int

xmlwrite_string_attr(struct archive_write *a, xmlTextWriterPtr writer,

	const char *key, const char *value,

	const char *attrkey, const char *attrvalue)

{

	int r;

	r = xmlTextWriterStartElement(writer, BAD_CAST_CONST(key));

	if (r < 0) {

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_MISC,

		    "xmlTextWriterStartElement() failed: %d", r);

		return (ARCHIVE_FATAL);

	}

	if (attrkey != NULL && attrvalue != NULL) {

		r = xmlTextWriterWriteAttribute(writer,

		    BAD_CAST_CONST(attrkey), BAD_CAST_CONST(attrvalue));

		if (r < 0) {

			archive_set_error(&a->archive,

			    ARCHIVE_ERRNO_MISC,

			    "xmlTextWriterWriteAttribute() failed: %d", r);

			return (ARCHIVE_FATAL);

		}

	}

	if (value != NULL) {

		r = xmlTextWriterWriteString(writer, BAD_CAST_CONST(value));

		if (r < 0) {

			archive_set_error(&a->archive,

			    ARCHIVE_ERRNO_MISC,

			    "xmlTextWriterWriteString() failed: %d", r);

			return (ARCHIVE_FATAL);

		}

	}

	r = xmlTextWriterEndElement(writer);

	if (r < 0) {

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_MISC,

		    "xmlTextWriterEndElement() failed: %d", r);

		return (ARCHIVE_FATAL);

	}

	return (ARCHIVE_OK);

}

static int

xmlwrite_string(struct archive_write *a, xmlTextWriterPtr writer,

	const char *key, const char *value)

{

	int r;

	if (value == NULL)

		return (ARCHIVE_OK);

	r = xmlTextWriterStartElement(writer, BAD_CAST_CONST(key));

	if (r < 0) {

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_MISC,

		    "xmlTextWriterStartElement() failed: %d", r);

		return (ARCHIVE_FATAL);

	}

	if (value != NULL) {

		r = xmlTextWriterWriteString(writer, BAD_CAST_CONST(value));

		if (r < 0) {

			archive_set_error(&a->archive,

			    ARCHIVE_ERRNO_MISC,

			    "xmlTextWriterWriteString() failed: %d", r);

			return (ARCHIVE_FATAL);

		}

	}

	r = xmlTextWriterEndElement(writer);

	if (r < 0) {

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_MISC,

		    "xmlTextWriterEndElement() failed: %d", r);

		return (ARCHIVE_FATAL);

	}

	return (ARCHIVE_OK);

}

static int

xmlwrite_fstring(struct archive_write *a, xmlTextWriterPtr writer,

	const char *key, const char *fmt, ...)

{

	struct xar *xar;

	va_list ap;

	xar = (struct xar *)a->format_data;

	va_start(ap, fmt);

	archive_string_empty(&xar->vstr);

	archive_string_vsprintf(&xar->vstr, fmt, ap);

	va_end(ap);

	return (xmlwrite_string(a, writer, key, xar->vstr.s));

}

static int

xmlwrite_time(struct archive_write *a, xmlTextWriterPtr writer,

	const char *key, time_t t, int z)

{

	char timestr[100];

	struct tm tm;

#if defined(HAVE_GMTIME_R)

	gmtime_r(&t, &tm;;