/*-

 * Copyright (c) 2003-2007 Tim Kientzle

 * 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_entry.c 201096 2009-12-28 02:41:27Z kientzle $");

#ifdef HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#if MAJOR_IN_MKDEV

#include <sys/mkdev.h>

#define HAVE_MAJOR

#elif MAJOR_IN_SYSMACROS

#include <sys/sysmacros.h>

#define HAVE_MAJOR

#endif

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_LIMITS_H

#include <limits.h>

#endif

#ifdef HAVE_LINUX_FS_H

#include <linux/fs.h>	/* for Linux file flags */

#endif

/*

 * Some Linux distributions have both linux/ext2_fs.h and ext2fs/ext2_fs.h.

 * As the include guards don't agree, the order of include is important.

 */

#ifdef HAVE_LINUX_EXT2_FS_H

#include <linux/ext2_fs.h>	/* for Linux file flags */

#endif

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

#include <ext2fs/ext2_fs.h>	/* for Linux file flags */

#endif

#include <stddef.h>

#include <stdio.h>

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#ifdef HAVE_WCHAR_H

#include <wchar.h>

#endif

#include "archive.h"

#include "archive_acl_private.h"

#include "archive_entry.h"

#include "archive_entry_locale.h"

#include "archive_private.h"

#include "archive_entry_private.h"

#if !defined(HAVE_MAJOR) && !defined(major)

/* Replacement for major/minor/makedev. */

#define	major(x) ((int)(0x00ff & ((x) >> 8)))

#define	minor(x) ((int)(0xffff00ff & (x)))

#define	makedev(maj,min) ((0xff00 & ((maj)<<8)) | (0xffff00ff & (min)))

#endif

/* Play games to come up with a suitable makedev() definition. */

#ifdef __QNXNTO__

/* QNX.  <sigh> */

#include <sys/netmgr.h>

#define ae_makedev(maj, min) makedev(ND_LOCAL_NODE, (maj), (min))

#elif defined makedev

/* There's a "makedev" macro. */

#define ae_makedev(maj, min) makedev((maj), (min))

#elif defined mkdev || ((defined _WIN32 || defined __WIN32__) && !defined(__CYGWIN__))

/* Windows. <sigh> */

#define ae_makedev(maj, min) mkdev((maj), (min))

#else

/* There's a "makedev" function. */

#define ae_makedev(maj, min) makedev((maj), (min))

#endif

/*

 * This adjustment is needed to support the following idiom for adding

 * 1000ns to the stored time:

 * archive_entry_set_atime(archive_entry_atime(),

 *                         archive_entry_atime_nsec() + 1000)

 * The additional if() here compensates for ambiguity in the C standard,

 * which permits two possible interpretations of a % b when a is negative.

 */

#define FIX_NS(t,ns) \

	do {	\

		t += ns / 1000000000; \

		ns %= 1000000000; \

		if (ns < 0) { --t; ns += 1000000000; } \

	} while (0)

static char *	 ae_fflagstostr(unsigned long bitset, unsigned long bitclear);

static const wchar_t	*ae_wcstofflags(const wchar_t *stringp,

		    unsigned long *setp, unsigned long *clrp);

static const char	*ae_strtofflags(const char *stringp,

		    unsigned long *setp, unsigned long *clrp);

#ifndef HAVE_WCSCPY

static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2)

{

	wchar_t *dest = s1;

	while ((*s1 = *s2) != L'\0')

		++s1, ++s2;

	return dest;

}

#endif

#ifndef HAVE_WCSLEN

static size_t wcslen(const wchar_t *s)

{

	const wchar_t *p = s;

	while (*p != L'\0')

		++p;

	return p - s;

}

#endif

#ifndef HAVE_WMEMCMP

/* Good enough for simple equality testing, but not for sorting. */

#define wmemcmp(a,b,i)  memcmp((a), (b), (i) * sizeof(wchar_t))

#endif

/****************************************************************************

 *

 * Public Interface

 *

 ****************************************************************************/

struct archive_entry *

archive_entry_clear(struct archive_entry *entry)

{

	if (entry == NULL)

		return (NULL);

	archive_mstring_clean(&entry->ae_fflags_text);

	archive_mstring_clean(&entry->ae_gname);

	archive_mstring_clean(&entry->ae_hardlink);

	archive_mstring_clean(&entry->ae_pathname);

	archive_mstring_clean(&entry->ae_sourcepath);

	archive_mstring_clean(&entry->ae_symlink);

	archive_mstring_clean(&entry->ae_uname);

	archive_entry_copy_mac_metadata(entry, NULL, 0);

	archive_acl_clear(&entry->acl);

	archive_entry_xattr_clear(entry);

	archive_entry_sparse_clear(entry);

	free(entry->stat);

	memset(entry, 0, sizeof(*entry));

	return entry;

}

struct archive_entry *

archive_entry_clone(struct archive_entry *entry)

{

	struct archive_entry *entry2;

	struct ae_xattr *xp;

	struct ae_sparse *sp;

	size_t s;

	const void *p;

	/* Allocate new structure and copy over all of the fields. */

	/* TODO: Should we copy the archive over?  Or require a new archive

	 * as an argument? */

	entry2 = archive_entry_new2(entry->archive);

	if (entry2 == NULL)

		return (NULL);

	entry2->ae_stat = entry->ae_stat;

	entry2->ae_fflags_set = entry->ae_fflags_set;

	entry2->ae_fflags_clear = entry->ae_fflags_clear;

	/* TODO: XXX If clone can have a different archive, what do we do here if

	 * character sets are different? XXX */

	archive_mstring_copy(&entry2->ae_fflags_text, &entry->ae_fflags_text);

	archive_mstring_copy(&entry2->ae_gname, &entry->ae_gname);

	archive_mstring_copy(&entry2->ae_hardlink, &entry->ae_hardlink);

	archive_mstring_copy(&entry2->ae_pathname, &entry->ae_pathname);

	archive_mstring_copy(&entry2->ae_sourcepath, &entry->ae_sourcepath);

	archive_mstring_copy(&entry2->ae_symlink, &entry->ae_symlink);

	entry2->ae_set = entry->ae_set;

	archive_mstring_copy(&entry2->ae_uname, &entry->ae_uname);

	/* Copy encryption status */

	entry2->encryption = entry->encryption;

	/* Copy ACL data over. */

	archive_acl_copy(&entry2->acl, &entry->acl);

	/* Copy Mac OS metadata. */

	p = archive_entry_mac_metadata(entry, &s);

	archive_entry_copy_mac_metadata(entry2, p, s);

	/* Copy xattr data over. */

	xp = entry->xattr_head;

	while (xp != NULL) {

		archive_entry_xattr_add_entry(entry2,

		    xp->name, xp->value, xp->size);

		xp = xp->next;

	}

	/* Copy sparse data over. */

	sp = entry->sparse_head;

	while (sp != NULL) {

		archive_entry_sparse_add_entry(entry2,

		    sp->offset, sp->length);

		sp = sp->next;

	}

	return (entry2);

}

void

archive_entry_free(struct archive_entry *entry)

{

	archive_entry_clear(entry);

	free(entry);

}

struct archive_entry *

archive_entry_new(void)

{

	return archive_entry_new2(NULL);

}

struct archive_entry *

archive_entry_new2(struct archive *a)

{

	struct archive_entry *entry;

	entry = (struct archive_entry *)calloc(1, sizeof(*entry));

	if (entry == NULL)

		return (NULL);

	entry->archive = a;

	return (entry);

}

/*

 * Functions for reading fields from an archive_entry.

 */

time_t

archive_entry_atime(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_atime);

}

long

archive_entry_atime_nsec(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_atime_nsec);

}

int

archive_entry_atime_is_set(struct archive_entry *entry)

{

	return (entry->ae_set & AE_SET_ATIME);

}

time_t

archive_entry_birthtime(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_birthtime);

}

long

archive_entry_birthtime_nsec(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_birthtime_nsec);

}

int

archive_entry_birthtime_is_set(struct archive_entry *entry)

{

	return (entry->ae_set & AE_SET_BIRTHTIME);

}

time_t

archive_entry_ctime(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_ctime);

}

int

archive_entry_ctime_is_set(struct archive_entry *entry)

{

	return (entry->ae_set & AE_SET_CTIME);

}

long

archive_entry_ctime_nsec(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_ctime_nsec);

}

dev_t

archive_entry_dev(struct archive_entry *entry)

{

	if (entry->ae_stat.aest_dev_is_broken_down)

		return ae_makedev(entry->ae_stat.aest_devmajor,

		    entry->ae_stat.aest_devminor);

	else

		return (entry->ae_stat.aest_dev);

}

int

archive_entry_dev_is_set(struct archive_entry *entry)

{

	return (entry->ae_set & AE_SET_DEV);

}

dev_t

archive_entry_devmajor(struct archive_entry *entry)

{

	if (entry->ae_stat.aest_dev_is_broken_down)

		return (entry->ae_stat.aest_devmajor);

	else

		return major(entry->ae_stat.aest_dev);

}

dev_t

archive_entry_devminor(struct archive_entry *entry)

{

	if (entry->ae_stat.aest_dev_is_broken_down)

		return (entry->ae_stat.aest_devminor);

	else

		return minor(entry->ae_stat.aest_dev);

}

mode_t

archive_entry_filetype(struct archive_entry *entry)

{

	return (AE_IFMT & entry->acl.mode);

}

void

archive_entry_fflags(struct archive_entry *entry,

    unsigned long *set, unsigned long *clear)

{

	*set = entry->ae_fflags_set;

	*clear = entry->ae_fflags_clear;

}

/*

 * Note: if text was provided, this just returns that text.  If you

 * really need the text to be rebuilt in a canonical form, set the

 * text, ask for the bitmaps, then set the bitmaps.  (Setting the

 * bitmaps clears any stored text.)  This design is deliberate: if

 * we're editing archives, we don't want to discard flags just because

 * they aren't supported on the current system.  The bitmap<->text

 * conversions are platform-specific (see below).

 */

const char *

archive_entry_fflags_text(struct archive_entry *entry)

{

	const char *f;

	char *p;

	if (archive_mstring_get_mbs(entry->archive,

	    &entry->ae_fflags_text, &f) == 0) {

		if (f != NULL)

			return (f);

	} else if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	if (entry->ae_fflags_set == 0  &&  entry->ae_fflags_clear == 0)

		return (NULL);

	p = ae_fflagstostr(entry->ae_fflags_set, entry->ae_fflags_clear);

	if (p == NULL)

		return (NULL);

	archive_mstring_copy_mbs(&entry->ae_fflags_text, p);

	free(p);

	if (archive_mstring_get_mbs(entry->archive,

	    &entry->ae_fflags_text, &f) == 0)

		return (f);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

la_int64_t

archive_entry_gid(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_gid);

}

const char *

archive_entry_gname(struct archive_entry *entry)

{

	const char *p;

	if (archive_mstring_get_mbs(entry->archive, &entry->ae_gname, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const char *

archive_entry_gname_utf8(struct archive_entry *entry)

{

	const char *p;

	if (archive_mstring_get_utf8(entry->archive, &entry->ae_gname, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const wchar_t *

archive_entry_gname_w(struct archive_entry *entry)

{

	const wchar_t *p;

	if (archive_mstring_get_wcs(entry->archive, &entry->ae_gname, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

int

_archive_entry_gname_l(struct archive_entry *entry,

    const char **p, size_t *len, struct archive_string_conv *sc)

{

	return (archive_mstring_get_mbs_l(&entry->ae_gname, p, len, sc));

}

const char *

archive_entry_hardlink(struct archive_entry *entry)

{

	const char *p;

	if ((entry->ae_set & AE_SET_HARDLINK) == 0)

		return (NULL);

	if (archive_mstring_get_mbs(

	    entry->archive, &entry->ae_hardlink, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const char *

archive_entry_hardlink_utf8(struct archive_entry *entry)

{

	const char *p;

	if ((entry->ae_set & AE_SET_HARDLINK) == 0)

		return (NULL);

	if (archive_mstring_get_utf8(

	    entry->archive, &entry->ae_hardlink, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const wchar_t *

archive_entry_hardlink_w(struct archive_entry *entry)

{

	const wchar_t *p;

	if ((entry->ae_set & AE_SET_HARDLINK) == 0)

		return (NULL);

	if (archive_mstring_get_wcs(

	    entry->archive, &entry->ae_hardlink, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

int

_archive_entry_hardlink_l(struct archive_entry *entry,

    const char **p, size_t *len, struct archive_string_conv *sc)

{

	if ((entry->ae_set & AE_SET_HARDLINK) == 0) {

		*p = NULL;

		*len = 0;

		return (0);

	}

	return (archive_mstring_get_mbs_l(&entry->ae_hardlink, p, len, sc));

}

la_int64_t

archive_entry_ino(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_ino);

}

int

archive_entry_ino_is_set(struct archive_entry *entry)

{

	return (entry->ae_set & AE_SET_INO);

}

la_int64_t

archive_entry_ino64(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_ino);

}

mode_t

archive_entry_mode(struct archive_entry *entry)

{

	return (entry->acl.mode);

}

time_t

archive_entry_mtime(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_mtime);

}

long

archive_entry_mtime_nsec(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_mtime_nsec);

}

int

archive_entry_mtime_is_set(struct archive_entry *entry)

{

	return (entry->ae_set & AE_SET_MTIME);

}

unsigned int

archive_entry_nlink(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_nlink);

}

const char *

archive_entry_pathname(struct archive_entry *entry)

{

	const char *p;

	if (archive_mstring_get_mbs(

	    entry->archive, &entry->ae_pathname, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const char *

archive_entry_pathname_utf8(struct archive_entry *entry)

{

	const char *p;

	if (archive_mstring_get_utf8(

	    entry->archive, &entry->ae_pathname, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const wchar_t *

archive_entry_pathname_w(struct archive_entry *entry)

{

	const wchar_t *p;

	if (archive_mstring_get_wcs(

	    entry->archive, &entry->ae_pathname, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

int

_archive_entry_pathname_l(struct archive_entry *entry,

    const char **p, size_t *len, struct archive_string_conv *sc)

{

	return (archive_mstring_get_mbs_l(&entry->ae_pathname, p, len, sc));

}

mode_t

archive_entry_perm(struct archive_entry *entry)

{

	return (~AE_IFMT & entry->acl.mode);

}

dev_t

archive_entry_rdev(struct archive_entry *entry)

{

	if (entry->ae_stat.aest_rdev_is_broken_down)

		return ae_makedev(entry->ae_stat.aest_rdevmajor,

		    entry->ae_stat.aest_rdevminor);

	else

		return (entry->ae_stat.aest_rdev);

}

dev_t

archive_entry_rdevmajor(struct archive_entry *entry)

{

	if (entry->ae_stat.aest_rdev_is_broken_down)

		return (entry->ae_stat.aest_rdevmajor);

	else

		return major(entry->ae_stat.aest_rdev);

}

dev_t

archive_entry_rdevminor(struct archive_entry *entry)

{

	if (entry->ae_stat.aest_rdev_is_broken_down)

		return (entry->ae_stat.aest_rdevminor);

	else

		return minor(entry->ae_stat.aest_rdev);

}

la_int64_t

archive_entry_size(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_size);

}

int

archive_entry_size_is_set(struct archive_entry *entry)

{

	return (entry->ae_set & AE_SET_SIZE);

}

const char *

archive_entry_sourcepath(struct archive_entry *entry)

{

	const char *p;

	if (archive_mstring_get_mbs(

	    entry->archive, &entry->ae_sourcepath, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const wchar_t *

archive_entry_sourcepath_w(struct archive_entry *entry)

{

	const wchar_t *p;

	if (archive_mstring_get_wcs(

	    entry->archive, &entry->ae_sourcepath, &p) == 0)

		return (p);

	return (NULL);

}

const char *

archive_entry_symlink(struct archive_entry *entry)

{

	const char *p;

	if ((entry->ae_set & AE_SET_SYMLINK) == 0)

		return (NULL);

	if (archive_mstring_get_mbs(

	    entry->archive, &entry->ae_symlink, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const char *

archive_entry_symlink_utf8(struct archive_entry *entry)

{

	const char *p;

	if ((entry->ae_set & AE_SET_SYMLINK) == 0)

		return (NULL);

	if (archive_mstring_get_utf8(

	    entry->archive, &entry->ae_symlink, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const wchar_t *

archive_entry_symlink_w(struct archive_entry *entry)

{

	const wchar_t *p;

	if ((entry->ae_set & AE_SET_SYMLINK) == 0)

		return (NULL);

	if (archive_mstring_get_wcs(

	    entry->archive, &entry->ae_symlink, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

int

_archive_entry_symlink_l(struct archive_entry *entry,

    const char **p, size_t *len, struct archive_string_conv *sc)

{

	if ((entry->ae_set & AE_SET_SYMLINK) == 0) {

		*p = NULL;

		*len = 0;

		return (0);

	}

	return (archive_mstring_get_mbs_l( &entry->ae_symlink, p, len, sc));

}

la_int64_t

archive_entry_uid(struct archive_entry *entry)

{

	return (entry->ae_stat.aest_uid);

}

const char *

archive_entry_uname(struct archive_entry *entry)

{

	const char *p;

	if (archive_mstring_get_mbs(entry->archive, &entry->ae_uname, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const char *

archive_entry_uname_utf8(struct archive_entry *entry)

{

	const char *p;

	if (archive_mstring_get_utf8(entry->archive, &entry->ae_uname, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

const wchar_t *

archive_entry_uname_w(struct archive_entry *entry)

{

	const wchar_t *p;

	if (archive_mstring_get_wcs(entry->archive, &entry->ae_uname, &p) == 0)

		return (p);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (NULL);

}

int

_archive_entry_uname_l(struct archive_entry *entry,

    const char **p, size_t *len, struct archive_string_conv *sc)

{

	return (archive_mstring_get_mbs_l(&entry->ae_uname, p, len, sc));

}

int

archive_entry_is_data_encrypted(struct archive_entry *entry)

{

	return ((entry->encryption & AE_ENCRYPTION_DATA) == AE_ENCRYPTION_DATA);

}

int

archive_entry_is_metadata_encrypted(struct archive_entry *entry)

{

	return ((entry->encryption & AE_ENCRYPTION_METADATA) == AE_ENCRYPTION_METADATA);

}

int

archive_entry_is_encrypted(struct archive_entry *entry)

{

	return (entry->encryption & (AE_ENCRYPTION_DATA|AE_ENCRYPTION_METADATA));

}

/*

 * Functions to set archive_entry properties.

 */

void

archive_entry_set_filetype(struct archive_entry *entry, unsigned int type)

{

	entry->stat_valid = 0;

	entry->acl.mode &= ~AE_IFMT;

	entry->acl.mode |= AE_IFMT & type;

}

void

archive_entry_set_fflags(struct archive_entry *entry,

    unsigned long set, unsigned long clear)

{

	archive_mstring_clean(&entry->ae_fflags_text);

	entry->ae_fflags_set = set;

	entry->ae_fflags_clear = clear;

}

const char *

archive_entry_copy_fflags_text(struct archive_entry *entry,

    const char *flags)

{

	archive_mstring_copy_mbs(&entry->ae_fflags_text, flags);

	return (ae_strtofflags(flags,

		    &entry->ae_fflags_set, &entry->ae_fflags_clear));

}

const wchar_t *

archive_entry_copy_fflags_text_w(struct archive_entry *entry,

    const wchar_t *flags)

{

	archive_mstring_copy_wcs(&entry->ae_fflags_text, flags);

	return (ae_wcstofflags(flags,

		    &entry->ae_fflags_set, &entry->ae_fflags_clear));

}

void

archive_entry_set_gid(struct archive_entry *entry, la_int64_t g)

{

	entry->stat_valid = 0;

	entry->ae_stat.aest_gid = g;

}

void

archive_entry_set_gname(struct archive_entry *entry, const char *name)

{

	archive_mstring_copy_mbs(&entry->ae_gname, name);

}

void

archive_entry_set_gname_utf8(struct archive_entry *entry, const char *name)

{

	archive_mstring_copy_utf8(&entry->ae_gname, name);

}

void

archive_entry_copy_gname(struct archive_entry *entry, const char *name)

{

	archive_mstring_copy_mbs(&entry->ae_gname, name);

}

void

archive_entry_copy_gname_w(struct archive_entry *entry, const wchar_t *name)

{

	archive_mstring_copy_wcs(&entry->ae_gname, name);

}

int

archive_entry_update_gname_utf8(struct archive_entry *entry, const char *name)

{

	if (archive_mstring_update_utf8(entry->archive,

	    &entry->ae_gname, name) == 0)

		return (1);

	if (errno == ENOMEM)

		__archive_errx(1, "No memory");

	return (0);

}

int

_archive_entry_copy_gname_l(struct archive_entry *entry,

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

{

	return (archive_mstring_copy_mbs_len_l(&entry->ae_gname, name, len, sc));

}

void

archive_entry_set_ino(struct archive_entry *entry, la_int64_t ino)

{

	entry->stat_valid = 0;

	entry->ae_set |= AE_SET_INO;

	entry->ae_stat.aest_ino = ino;

}

void

archive_entry_set_ino64(struct archive_entry *entry, la_int64_t ino)

{