/*-

 * Copyright (c) 2003-2007 Tim Kientzle

 * Copyright (c) 2010-2012 Michihiro NAKAJIMA

 * Copyright (c) 2016 Martin Matuska

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "archive_platform.h"

__FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_format_pax.c 201162 2009-12-29 05:47:46Z kientzle $");

#ifdef HAVE_ERRNO_H

#include <errno.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_write_private.h"

struct sparse_block {

	struct sparse_block	*next;

	int		is_hole;

	uint64_t	offset;

	uint64_t	remaining;

};

struct pax {

	uint64_t	entry_bytes_remaining;

	uint64_t	entry_padding;

	struct archive_string	l_url_encoded_name;

	struct archive_string	pax_header;

	struct archive_string	sparse_map;

	size_t			sparse_map_padding;

	struct sparse_block	*sparse_list;

	struct sparse_block	*sparse_tail;

	struct archive_string_conv *sconv_utf8;

	int			 opt_binary;

	unsigned flags;

#define WRITE_SCHILY_XATTR       (1 << 0)

#define WRITE_LIBARCHIVE_XATTR   (1 << 1)

};

static void		 add_pax_attr(struct archive_string *, const char *key,

			     const char *value);

static void		 add_pax_attr_binary(struct archive_string *,

			     const char *key,

			     const char *value, size_t value_len);

static void		 add_pax_attr_int(struct archive_string *,

			     const char *key, int64_t value);

static void		 add_pax_attr_time(struct archive_string *,

			     const char *key, int64_t sec,

			     unsigned long nanos);

static int		 add_pax_acl(struct archive_write *,

			    struct archive_entry *, struct pax *, int);

static ssize_t		 archive_write_pax_data(struct archive_write *,

			     const void *, size_t);

static int		 archive_write_pax_close(struct archive_write *);

static int		 archive_write_pax_free(struct archive_write *);

static int		 archive_write_pax_finish_entry(struct archive_write *);

static int		 archive_write_pax_header(struct archive_write *,

			     struct archive_entry *);

static int		 archive_write_pax_options(struct archive_write *,

			     const char *, const char *);

static char		*base64_encode(const char *src, size_t len);

static char		*build_gnu_sparse_name(char *dest, const char *src);

static char		*build_pax_attribute_name(char *dest, const char *src);

static char		*build_ustar_entry_name(char *dest, const char *src,

			     size_t src_length, const char *insert);

static char		*format_int(char *dest, int64_t);

static int		 has_non_ASCII(const char *);

static void		 sparse_list_clear(struct pax *);

static int		 sparse_list_add(struct pax *, int64_t, int64_t);

static char		*url_encode(const char *in);

/*

 * Set output format to 'restricted pax' format.

 *

 * This is the same as normal 'pax', but tries to suppress

 * the pax header whenever possible.  This is the default for

 * bsdtar, for instance.

 */

int

archive_write_set_format_pax_restricted(struct archive *_a)

{

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

	int r;

	archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_write_set_format_pax_restricted");

	r = archive_write_set_format_pax(&a->archive);

	a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_RESTRICTED;

	a->archive.archive_format_name = "restricted POSIX pax interchange";

	return (r);

}

/*

 * Set output format to 'pax' format.

 */

int

archive_write_set_format_pax(struct archive *_a)

{

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

	struct pax *pax;

	archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_write_set_format_pax");

	if (a->format_free != NULL)

		(a->format_free)(a);

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

	if (pax == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate pax data");

		return (ARCHIVE_FATAL);

	}

	pax->flags = WRITE_LIBARCHIVE_XATTR | WRITE_SCHILY_XATTR;

	a->format_data = pax;

	a->format_name = "pax";

	a->format_options = archive_write_pax_options;

	a->format_write_header = archive_write_pax_header;

	a->format_write_data = archive_write_pax_data;

	a->format_close = archive_write_pax_close;

	a->format_free = archive_write_pax_free;

	a->format_finish_entry = archive_write_pax_finish_entry;

	a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;

	a->archive.archive_format_name = "POSIX pax interchange";

	return (ARCHIVE_OK);

}

static int

archive_write_pax_options(struct archive_write *a, const char *key,

    const char *val)

{

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

	int ret = ARCHIVE_FAILED;

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

		/*

		 * The character-set we can use are defined in

		 * IEEE Std 1003.1-2001

		 */

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

			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

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

		else if (strcmp(val, "BINARY") == 0 ||

		    strcmp(val, "binary") == 0) {

			/*

			 * Specify binary mode. We will not convert

			 * filenames, uname and gname to any charsets.

			 */

			pax->opt_binary = 1;

			ret = ARCHIVE_OK;

		} else if (strcmp(val, "UTF-8") == 0) {

			/*

			 * Specify UTF-8 character-set to be used for

			 * filenames. This is almost the test that

			 * running platform supports the string conversion.

			 * Especially libarchive_test needs this trick for

			 * its test.

			 */

			pax->sconv_utf8 = archive_string_conversion_to_charset(

			    &(a->archive), "UTF-8", 0);

			if (pax->sconv_utf8 == NULL)

				ret = ARCHIVE_FATAL;

			else

				ret = ARCHIVE_OK;

		} else

			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

			    "pax: invalid charset name");

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

}

/*

 * Note: This code assumes that 'nanos' has the same sign as 'sec',

 * which implies that sec=-1, nanos=200000000 represents -1.2 seconds

 * and not -0.8 seconds.  This is a pretty pedantic point, as we're

 * unlikely to encounter many real files created before Jan 1, 1970,

 * much less ones with timestamps recorded to sub-second resolution.

 */

static void

add_pax_attr_time(struct archive_string *as, const char *key,

    int64_t sec, unsigned long nanos)

{

	int digit, i;

	char *t;

	/*

	 * Note that each byte contributes fewer than 3 base-10

	 * digits, so this will always be big enough.

	 */

	char tmp[1 + 3*sizeof(sec) + 1 + 3*sizeof(nanos)];

	tmp[sizeof(tmp) - 1] = 0;

	t = tmp + sizeof(tmp) - 1;

	/* Skip trailing zeros in the fractional part. */

	for (digit = 0, i = 10; i > 0 && digit == 0; i--) {

		digit = nanos % 10;

		nanos /= 10;

	}

	/* Only format the fraction if it's non-zero. */

	if (i > 0) {

		while (i > 0) {

			*--t = "0123456789"[digit];

			digit = nanos % 10;

			nanos /= 10;

			i--;

		}

		*--t = '.';

	}

	t = format_int(t, sec);

	add_pax_attr(as, key, t);

}

static char *

format_int(char *t, int64_t i)

{

	uint64_t ui;

	if (i < 0) 

		ui = (i == INT64_MIN) ? (uint64_t)(INT64_MAX) + 1 : (uint64_t)(-i);

	else

		ui = i;

	do {

		*--t = "0123456789"[ui % 10];

	} while (ui /= 10);

	if (i < 0)

		*--t = '-';

	return (t);

}

static void

add_pax_attr_int(struct archive_string *as, const char *key, int64_t value)

{

	char tmp[1 + 3 * sizeof(value)];

	tmp[sizeof(tmp) - 1] = 0;

	add_pax_attr(as, key, format_int(tmp + sizeof(tmp) - 1, value));

}

/*

 * Add a key/value attribute to the pax header.  This function handles

 * the length field and various other syntactic requirements.

 */

static void

add_pax_attr(struct archive_string *as, const char *key, const char *value)

{

	add_pax_attr_binary(as, key, value, strlen(value));

}

/*

 * Add a key/value attribute to the pax header.  This function handles

 * binary values.

 */

static void

add_pax_attr_binary(struct archive_string *as, const char *key,

		    const char *value, size_t value_len)

{

	int digits, i, len, next_ten;

	char tmp[1 + 3 * sizeof(int)];	/* < 3 base-10 digits per byte */

	/*-

	 * PAX attributes have the following layout:

	 *     <len> <space> <key> <=> <value> <nl>

	 */

	len = 1 + (int)strlen(key) + 1 + (int)value_len + 1;

	/*

	 * The <len> field includes the length of the <len> field, so

	 * computing the correct length is tricky.  I start by

	 * counting the number of base-10 digits in 'len' and

	 * computing the next higher power of 10.

	 */

	next_ten = 1;

	digits = 0;

	i = len;

	while (i > 0) {

		i = i / 10;

		digits++;

		next_ten = next_ten * 10;

	}

	/*

	 * For example, if string without the length field is 99

	 * chars, then adding the 2 digit length "99" will force the

	 * total length past 100, requiring an extra digit.  The next

	 * statement adjusts for this effect.

	 */

	if (len + digits >= next_ten)

		digits++;

	/* Now, we have the right length so we can build the line. */

	tmp[sizeof(tmp) - 1] = 0;	/* Null-terminate the work area. */

	archive_strcat(as, format_int(tmp + sizeof(tmp) - 1, len + digits));

	archive_strappend_char(as, ' ');

	archive_strcat(as, key);

	archive_strappend_char(as, '=');

	archive_array_append(as, value, value_len);

	archive_strappend_char(as, '\n');

}

static void

archive_write_pax_header_xattr(struct pax *pax, const char *encoded_name,

    const void *value, size_t value_len)

{

	struct archive_string s;

	char *encoded_value;

	if (pax->flags & WRITE_LIBARCHIVE_XATTR) {

		encoded_value = base64_encode((const char *)value, value_len);

		if (encoded_name != NULL && encoded_value != NULL) {

			archive_string_init(&s);

			archive_strcpy(&s, "LIBARCHIVE.xattr.");

			archive_strcat(&s, encoded_name);

			add_pax_attr(&(pax->pax_header), s.s, encoded_value);

			archive_string_free(&s);

		}

		free(encoded_value);

	}

	if (pax->flags & WRITE_SCHILY_XATTR) {

		archive_string_init(&s);

		archive_strcpy(&s, "SCHILY.xattr.");

		archive_strcat(&s, encoded_name);

		add_pax_attr_binary(&(pax->pax_header), s.s, value, value_len);

		archive_string_free(&s);

	}

}

static int

archive_write_pax_header_xattrs(struct archive_write *a,

    struct pax *pax, struct archive_entry *entry)

{

	int i = archive_entry_xattr_reset(entry);

	while (i--) {

		const char *name;

		const void *value;

		char *url_encoded_name = NULL, *encoded_name = NULL;

		size_t size;

		int r;

		archive_entry_xattr_next(entry, &name, &value, &size);

		url_encoded_name = url_encode(name);

		if (url_encoded_name != NULL) {

			/* Convert narrow-character to UTF-8. */

			r = archive_strcpy_l(&(pax->l_url_encoded_name),

			    url_encoded_name, pax->sconv_utf8);

			free(url_encoded_name); /* Done with this. */

			if (r == 0)

				encoded_name = pax->l_url_encoded_name.s;

			else if (errno == ENOMEM) {

				archive_set_error(&a->archive, ENOMEM,

				    "Can't allocate memory for Linkname");

				return (ARCHIVE_FATAL);

			}

		}

		archive_write_pax_header_xattr(pax, encoded_name,

		    value, size);

	}

	return (ARCHIVE_OK);

}

static int

get_entry_hardlink(struct archive_write *a, struct archive_entry *entry,

    const char **name, size_t *length, struct archive_string_conv *sc)

{

	int r;

	r = archive_entry_hardlink_l(entry, name, length, sc);

	if (r != 0) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM,

			    "Can't allocate memory for Linkname");

			return (ARCHIVE_FATAL);

		}

		return (ARCHIVE_WARN);

	}

	return (ARCHIVE_OK);

}

static int

get_entry_pathname(struct archive_write *a, struct archive_entry *entry,

    const char **name, size_t *length, struct archive_string_conv *sc)

{

	int r;

	r = archive_entry_pathname_l(entry, name, length, sc);

	if (r != 0) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM,

			    "Can't allocate memory for Pathname");

			return (ARCHIVE_FATAL);

		}

		return (ARCHIVE_WARN);

	}

	return (ARCHIVE_OK);

}

static int

get_entry_uname(struct archive_write *a, struct archive_entry *entry,

    const char **name, size_t *length, struct archive_string_conv *sc)

{

	int r;

	r = archive_entry_uname_l(entry, name, length, sc);

	if (r != 0) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM,

			    "Can't allocate memory for Uname");

			return (ARCHIVE_FATAL);

		}

		return (ARCHIVE_WARN);

	}

	return (ARCHIVE_OK);

}

static int

get_entry_gname(struct archive_write *a, struct archive_entry *entry,

    const char **name, size_t *length, struct archive_string_conv *sc)

{

	int r;

	r = archive_entry_gname_l(entry, name, length, sc);

	if (r != 0) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM,

			    "Can't allocate memory for Gname");

			return (ARCHIVE_FATAL);

		}

		return (ARCHIVE_WARN);

	}

	return (ARCHIVE_OK);

}

static int

get_entry_symlink(struct archive_write *a, struct archive_entry *entry,

    const char **name, size_t *length, struct archive_string_conv *sc)

{

	int r;

	r = archive_entry_symlink_l(entry, name, length, sc);

	if (r != 0) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM,

			    "Can't allocate memory for Linkname");

			return (ARCHIVE_FATAL);

		}

		return (ARCHIVE_WARN);

	}

	return (ARCHIVE_OK);

}

/* Add ACL to pax header */

static int

add_pax_acl(struct archive_write *a,

    struct archive_entry *entry, struct pax *pax, int flags)

{

	char *p;

	const char *attr;

	int acl_types;

	acl_types = archive_entry_acl_types(entry);

	if ((acl_types & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0)

		attr = "SCHILY.acl.ace";

	else if ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)

		attr = "SCHILY.acl.access";

	else if ((flags & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0)

		attr = "SCHILY.acl.default";

	else

		return (ARCHIVE_FATAL);

	p = archive_entry_acl_to_text_l(entry, NULL, flags, pax->sconv_utf8);

	if (p == NULL) {

		if (errno == ENOMEM) {

			archive_set_error(&a->archive, ENOMEM, "%s %s",

			    "Can't allocate memory for ", attr);

			return (ARCHIVE_FATAL);

		}

		archive_set_error(&a->archive,

		    ARCHIVE_ERRNO_FILE_FORMAT, "%s %s %s",

		    "Can't translate ", attr, " to UTF-8");

		return(ARCHIVE_WARN);

	} else if (*p != '\0') {

		add_pax_attr(&(pax->pax_header),

		    attr, p);

		free(p);

	}

	return(ARCHIVE_OK);

}

/*

 * TODO: Consider adding 'comment' and 'charset' fields to

 * archive_entry so that clients can specify them.  Also, consider

 * adding generic key/value tags so clients can add arbitrary

 * key/value data.

 *

 * TODO: Break up this 700-line function!!!!  Yowza!

 */

static int

archive_write_pax_header(struct archive_write *a,

    struct archive_entry *entry_original)

{

	struct archive_entry *entry_main;

	const char *p;

	const char *suffix;

	int need_extension, r, ret;

	int acl_types;

	int sparse_count;

	uint64_t sparse_total, real_size;

	struct pax *pax;

	const char *hardlink;

	const char *path = NULL, *linkpath = NULL;

	const char *uname = NULL, *gname = NULL;

	const void *mac_metadata;

	size_t mac_metadata_size;

	struct archive_string_conv *sconv;

	size_t hardlink_length, path_length, linkpath_length;

	size_t uname_length, gname_length;

	char paxbuff[512];

	char ustarbuff[512];

	char ustar_entry_name[256];

	char pax_entry_name[256];

	char gnu_sparse_name[256];

	struct archive_string entry_name;

	ret = ARCHIVE_OK;

	need_extension = 0;

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

	/* Sanity check. */

	if (archive_entry_pathname(entry_original) == NULL) {

		archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,

			  "Can't record entry in tar file without pathname");

		return (ARCHIVE_FAILED);

	}

	/*

	 * Choose a header encoding.

	 */

	if (pax->opt_binary)

		sconv = NULL;/* Binary mode. */

	else {

		/* Header encoding is UTF-8. */

		if (pax->sconv_utf8 == NULL) {

			/* Initialize the string conversion object

			 * we must need */

			pax->sconv_utf8 = archive_string_conversion_to_charset(

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

			if (pax->sconv_utf8 == NULL)

				/* Couldn't allocate memory */

				return (ARCHIVE_FAILED);

		}

		sconv = pax->sconv_utf8;

	}

	r = get_entry_hardlink(a, entry_original, &hardlink,

	    &hardlink_length, sconv);

	if (r == ARCHIVE_FATAL)

		return (r);

	else if (r != ARCHIVE_OK) {

		r = get_entry_hardlink(a, entry_original, &hardlink,

		    &hardlink_length, NULL);

		if (r == ARCHIVE_FATAL)

			return (r);

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Can't translate linkname '%s' to %s", hardlink,

		    archive_string_conversion_charset_name(sconv));

		ret = ARCHIVE_WARN;

		sconv = NULL;/* The header charset switches to binary mode. */

	}

	/* Make sure this is a type of entry that we can handle here */

	if (hardlink == NULL) {

		switch (archive_entry_filetype(entry_original)) {

		case AE_IFBLK:

		case AE_IFCHR:

		case AE_IFIFO:

		case AE_IFLNK:

		case AE_IFREG:

			break;

		case AE_IFDIR:

		{

			/*

			 * Ensure a trailing '/'.  Modify the original

			 * entry so the client sees the change.

			 */

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

			const wchar_t *wp;

			wp = archive_entry_pathname_w(entry_original);

			if (wp != NULL && wp[wcslen(wp) -1] != L'/') {

				struct archive_wstring ws;

				archive_string_init(&ws);

				path_length = wcslen(wp);

				if (archive_wstring_ensure(&ws,

				    path_length + 2) == NULL) {

					archive_set_error(&a->archive, ENOMEM,

					    "Can't allocate pax data");

					archive_wstring_free(&ws);

					return(ARCHIVE_FATAL);

				}

				/* Should we keep '\' ? */

				if (wp[path_length -1] == L'\\')

					path_length--;

				archive_wstrncpy(&ws, wp, path_length);

				archive_wstrappend_wchar(&ws, L'/');

				archive_entry_copy_pathname_w(

				    entry_original, ws.s);

				archive_wstring_free(&ws);

				p = NULL;

			} else

#endif

				p = archive_entry_pathname(entry_original);

			/*

			 * On Windows, this is a backup operation just in

			 * case getting WCS failed. On POSIX, this is a

			 * normal operation.

			 */

			if (p != NULL && p[strlen(p) - 1] != '/') {

				struct archive_string as;

				archive_string_init(&as);

				path_length = strlen(p);

				if (archive_string_ensure(&as,

				    path_length + 2) == NULL) {

					archive_set_error(&a->archive, ENOMEM,

					    "Can't allocate pax data");

					archive_string_free(&as);

					return(ARCHIVE_FATAL);

				}

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

				/* NOTE: This might break the pathname

				 * if the current code page is CP932 and

				 * the pathname includes a character '\'

				 * as a part of its multibyte pathname. */

				if (p[strlen(p) -1] == '\\')

					path_length--;

				else

#endif

				archive_strncpy(&as, p, path_length);

				archive_strappend_char(&as, '/');

				archive_entry_copy_pathname(

				    entry_original, as.s);

				archive_string_free(&as);

			}

			break;

		}

		case AE_IFSOCK:

			archive_set_error(&a->archive,

			    ARCHIVE_ERRNO_FILE_FORMAT,

			    "tar format cannot archive socket");

			return (ARCHIVE_FAILED);

		default:

			archive_set_error(&a->archive,

			    ARCHIVE_ERRNO_FILE_FORMAT,

			    "tar format cannot archive this (type=0%lo)",

			    (unsigned long)

			    archive_entry_filetype(entry_original));

			return (ARCHIVE_FAILED);

		}

	}

	/*

	 * If Mac OS metadata blob is here, recurse to write that

	 * as a separate entry.  This is really a pretty poor design:

	 * In particular, it doubles the overhead for long filenames.

	 * TODO: Help Apple folks design something better and figure

	 * out how to transition from this legacy format.

	 *

	 * Note that this code is present on every platform; clients

	 * on non-Mac are unlikely to ever provide this data, but

	 * applications that copy entries from one archive to another

	 * should not lose data just because the local filesystem

	 * can't store it.

	 */

	mac_metadata =

	    archive_entry_mac_metadata(entry_original, &mac_metadata_size);

	if (mac_metadata != NULL) {

		const char *oname;

		char *name, *bname;

		size_t name_length;

		struct archive_entry *extra = archive_entry_new2(&a->archive);

		oname = archive_entry_pathname(entry_original);

		name_length = strlen(oname);

		name = malloc(name_length + 3);

		if (name == NULL || extra == NULL) {

			/* XXX error message */

			archive_entry_free(extra);

			free(name);

			return (ARCHIVE_FAILED);

		}

		strcpy(name, oname);

		/* Find last '/'; strip trailing '/' characters */

		bname = strrchr(name, '/');

		while (bname != NULL && bname[1] == '\0') {

			*bname = '\0';

			bname = strrchr(name, '/');

		}

		if (bname == NULL) {

			memmove(name + 2, name, name_length + 1);

			memmove(name, "._", 2);

		} else {

			bname += 1;

			memmove(bname + 2, bname, strlen(bname) + 1);

			memmove(bname, "._", 2);

		}

		archive_entry_copy_pathname(extra, name);

		free(name);

		archive_entry_set_size(extra, mac_metadata_size);

		archive_entry_set_filetype(extra, AE_IFREG);

		archive_entry_set_perm(extra,

		    archive_entry_perm(entry_original));

		archive_entry_set_mtime(extra,

		    archive_entry_mtime(entry_original),

		    archive_entry_mtime_nsec(entry_original));

		archive_entry_set_gid(extra,

		    archive_entry_gid(entry_original));

		archive_entry_set_gname(extra,

		    archive_entry_gname(entry_original));

		archive_entry_set_uid(extra,

		    archive_entry_uid(entry_original));

		archive_entry_set_uname(extra,

		    archive_entry_uname(entry_original));

		/* Recurse to write the special copyfile entry. */

		r = archive_write_pax_header(a, extra);

		archive_entry_free(extra);

		if (r < ARCHIVE_WARN)

			return (r);

		if (r < ret)

			ret = r;

		r = (int)archive_write_pax_data(a, mac_metadata,

		    mac_metadata_size);

		if (r < ARCHIVE_WARN)

			return (r);

		if (r < ret)

			ret = r;

		r = archive_write_pax_finish_entry(a);

		if (r < ARCHIVE_WARN)

			return (r);

		if (r < ret)

			ret = r;

	}

	/* Copy entry so we can modify it as needed. */

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

	/* Make sure the path separators in pathname, hardlink and symlink

	 * are all slash '/', not the Windows path separator '\'. */

	entry_main = __la_win_entry_in_posix_pathseparator(entry_original);

	if (entry_main == entry_original)

		entry_main = archive_entry_clone(entry_original);

#else

	entry_main = archive_entry_clone(entry_original);

#endif

	if (entry_main == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate pax data");

		return(ARCHIVE_FATAL);

	}

	archive_string_empty(&(pax->pax_header)); /* Blank our work area. */

	archive_string_empty(&(pax->sparse_map));

	sparse_total = 0;

	sparse_list_clear(pax);

	if (hardlink == NULL &&

	    archive_entry_filetype(entry_main) == AE_IFREG)

		sparse_count = archive_entry_sparse_reset(entry_main);

	else

		sparse_count = 0;

	if (sparse_count) {

		int64_t offset, length, last_offset = 0;

		/* Get the last entry of sparse block. */

		while (archive_entry_sparse_next(

		    entry_main, &offset, &length) == ARCHIVE_OK)

			last_offset = offset + length;

		/* If the last sparse block does not reach the end of file,

		 * We have to add a empty sparse block as the last entry to

		 * manage storing file data. */

		if (last_offset < archive_entry_size(entry_main))

			archive_entry_sparse_add_entry(entry_main,

			    archive_entry_size(entry_main), 0);

		sparse_count = archive_entry_sparse_reset(entry_main);

	}

	/*

	 * First, check the name fields and see if any of them

	 * require binary coding.  If any of them does, then all of

	 * them do.

	 */

	r = get_entry_pathname(a, entry_main, &path, &path_length, sconv);

	if (r == ARCHIVE_FATAL)

		return (r);

	else if (r != ARCHIVE_OK) {

		r = get_entry_pathname(a, entry_main, &path,

		    &path_length, NULL);

		if (r == ARCHIVE_FATAL)

			return (r);

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Can't translate pathname '%s' to %s", path,

		    archive_string_conversion_charset_name(sconv));

		ret = ARCHIVE_WARN;

		sconv = NULL;/* The header charset switches to binary mode. */

	}

	r = get_entry_uname(a, entry_main, &uname, &uname_length, sconv);

	if (r == ARCHIVE_FATAL)

		return (r);

	else if (r != ARCHIVE_OK) {

		r = get_entry_uname(a, entry_main, &uname, &uname_length, NULL);

		if (r == ARCHIVE_FATAL)

			return (r);

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Can't translate uname '%s' to %s", uname,

		    archive_string_conversion_charset_name(sconv));

		ret = ARCHIVE_WARN;

		sconv = NULL;/* The header charset switches to binary mode. */

	}

	r = get_entry_gname(a, entry_main, &gname, &gname_length, sconv);

	if (r == ARCHIVE_FATAL)

		return (r);

	else if (r != ARCHIVE_OK) {

		r = get_entry_gname(a, entry_main, &gname, &gname_length, NULL);

		if (r == ARCHIVE_FATAL)

			return (r);

		archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,

		    "Can't translate gname '%s' to %s", gname,

		    archive_string_conversion_charset_name(sconv));

		ret = ARCHIVE_WARN;

		sconv = NULL;/* The header charset switches to binary mode. */

	}

	linkpath = hardlink;

	linkpath_length = hardlink_length;

	if (linkpath == NULL) {

		r = get_entry_symlink(a, entry_main, &linkpath,