const char *
archive_version_details(void)
{
static struct archive_string str;
static int init = 0;
if (!init) {
archive_string_init(&str);
archive_strcat(&str, ARCHIVE_VERSION_STRING);
#ifdef HAVE_ZLIB_H
archive_strcat(&str, " zlib/");
archive_strcat(&str, ZLIB_VERSION);
#endif
#ifdef HAVE_LZMA_H
archive_strcat(&str, " liblzma/");
archive_strcat(&str, LZMA_VERSION_STRING);
#endif
#ifdef HAVE_BZLIB_H
{
const char *p = BZ2_bzlibVersion();
const char *sep = strchr(p, ',');
if (sep == NULL)
sep = p + strlen(p);
archive_strcat(&str, " bz2lib/");
archive_strncat(&str, p, sep - p);
}
#endif
#if defined(HAVE_LZ4_H) && defined(HAVE_LIBLZ4)
archive_string_sprintf(&str, " liblz4/%d.%d.%d",
LZ4_VERSION_MAJOR, LZ4_VERSION_MINOR, LZ4_VERSION_RELEASE);
#endif
}
return str.s;
}
static void
test_archive_string_sprintf(void)
{
struct archive_string s;
#define S16 "0123456789abcdef"
#define S32 S16 S16
#define S64 S32 S32
#define S128 S64 S64
const char *s32 = S32;
const char *s33 = S32 "0";
const char *s64 = S64;
const char *s65 = S64 "0";
const char *s128 = S128;
const char *s129 = S128 "0";
#undef S16
#undef S32
#undef S64
#undef S128
archive_string_init(&s);
assertExactString(0, 0, NULL, s);
archive_string_sprintf(&s, "%s", "");
assertExactString(0, 2 * EXTENT, "", s);
archive_string_empty(&s);
archive_string_sprintf(&s, "%s", s32);
assertExactString(32, 2 * EXTENT, s32, s);
archive_string_empty(&s);
archive_string_sprintf(&s, "%s", s33);
assertExactString(33, 2 * EXTENT, s33, s);
archive_string_empty(&s);
archive_string_sprintf(&s, "%s", s64);
assertExactString(64, 4 * EXTENT, s64, s);
archive_string_empty(&s);
archive_string_sprintf(&s, "%s", s65);
assertExactString(65, 4 * EXTENT, s65, s);
archive_string_empty(&s);
archive_string_sprintf(&s, "%s", s128);
assertExactString(128, 8 * EXTENT, s128, s);
archive_string_empty(&s);
archive_string_sprintf(&s, "%s", s129);
assertExactString(129, 8 * EXTENT, s129, s);
archive_string_empty(&s);
archive_string_sprintf(&s, "%d", 1234567890);
assertExactString(10, 8 * EXTENT, "1234567890", s);
}
static ssize_t
_popul_ehdr(struct archive_string *tgt, size_t tsz, warc_essential_hdr_t hdr)
{
static const char _ver[] = "WARC/1.0\r\n";
static const char * const _typ[LAST_WT] = {
NULL, "warcinfo", "metadata", "resource", NULL
};
char std_uuid[48U];
if (hdr.type == WT_NONE || hdr.type > WT_RSRC) {
/* brilliant, how exactly did we get here? */
return -1;
}
archive_strcpy(tgt, _ver);
archive_string_sprintf(tgt, "WARC-Type: %s\r\n", _typ[hdr.type]);
if (hdr.tgturi != NULL) {
/* check if there's a xyz:// */
static const char _uri[] = "";
static const char _fil[] = "file://";
const char *u;
char *chk = strchr(hdr.tgturi, ':');
if (chk != NULL && chk[1U] == '/' && chk[2U] == '/') {
/* yep, it's definitely a URI */
u = _uri;
} else {
/* hm, best to prepend file:// then */
u = _fil;
}
archive_string_sprintf(tgt,
"WARC-Target-URI: %s%s\r\n", u, hdr.tgturi);
}
/* record time is usually when the http is sent off,
* just treat the archive writing as such for a moment */
xstrftime(tgt, "WARC-Date: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.rtime);
/* while we're at it, record the mtime */
xstrftime(tgt, "Last-Modified: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.mtime);
if (hdr.recid == NULL) {
/* generate one, grrrr */
warc_uuid_t u;
_gen_uuid(&u);
/* Unfortunately, archive_string_sprintf does not
* handle the minimum number following '%'.
* So we have to use snprintf function here instead
* of archive_string_snprintf function. */
#if defined(_WIN32) && !defined(__CYGWIN__) && !( defined(_MSC_VER) && _MSC_VER >= 1900)
#define snprintf _snprintf
#endif
snprintf(
std_uuid, sizeof(std_uuid),
"<urn:uuid:%08x-%04x-%04x-%04x-%04x%08x>",
u.u[0U],
u.u[1U] >> 16U, u.u[1U] & 0xffffU,
u.u[2U] >> 16U, u.u[2U] & 0xffffU,
u.u[3U]);
hdr.recid = std_uuid;
}
static int
archive_write_shar_finish_entry(struct archive_write *a)
{
const char *g, *p, *u;
struct shar *shar;
int ret;
shar = (struct shar *)a->format_data;
if (shar->entry == NULL)
return (0);
if (shar->dump) {
/* Finish uuencoded data. */
if (shar->has_data) {
if (shar->outpos > 0)
uuencode_line(a, shar, shar->outbuff,
shar->outpos);
archive_strcat(&shar->work, "`\nend\n");
archive_strcat(&shar->work, "SHAR_END\n");
}
/* Restore file mode, owner, flags. */
/*
* TODO: Don't immediately restore mode for
* directories; defer that to end of script.
*/
archive_string_sprintf(&shar->work, "chmod %o ",
(unsigned int)(archive_entry_mode(shar->entry) & 07777));
shar_quote(&shar->work, archive_entry_pathname(shar->entry), 1);
archive_strcat(&shar->work, "\n");
u = archive_entry_uname(shar->entry);
g = archive_entry_gname(shar->entry);
if (u != NULL || g != NULL) {
archive_strcat(&shar->work, "chown ");
if (u != NULL)
shar_quote(&shar->work, u, 1);
if (g != NULL) {
archive_strcat(&shar->work, ":");
shar_quote(&shar->work, g, 1);
}
archive_strcat(&shar->work, " ");
shar_quote(&shar->work,
archive_entry_pathname(shar->entry), 1);
archive_strcat(&shar->work, "\n");
}
if ((p = archive_entry_fflags_text(shar->entry)) != NULL) {
archive_string_sprintf(&shar->work, "chflags %s ", p);
shar_quote(&shar->work,
archive_entry_pathname(shar->entry), 1);
archive_strcat(&shar->work, "\n");
}
/* TODO: restore ACLs */
} else {
if (shar->has_data) {
/* Finish sed-encoded data: ensure last line ends. */
if (!shar->end_of_line)
archive_strappend_char(&shar->work, '\n');
archive_strcat(&shar->work, "SHAR_END\n");
}
}
archive_entry_free(shar->entry);
shar->entry = NULL;
if (shar->work.length < 65536)
return (ARCHIVE_OK);
ret = __archive_write_output(a, shar->work.s, shar->work.length);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
archive_string_empty(&shar->work);
return (ARCHIVE_OK);
}
static int
archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
{
const char *linkname;
const char *name;
char *p, *pp;
struct shar *shar;
shar = (struct shar *)a->format_data;
if (!shar->wrote_header) {
archive_strcat(&shar->work, "#!/bin/sh\n");
archive_strcat(&shar->work, "# This is a shell archive\n");
shar->wrote_header = 1;
}
/* Save the entry for the closing. */
if (shar->entry)
archive_entry_free(shar->entry);
shar->entry = archive_entry_clone(entry);
name = archive_entry_pathname(entry);
/* Handle some preparatory issues. */
switch(archive_entry_filetype(entry)) {
case AE_IFREG:
/* Only regular files have non-zero size. */
break;
case AE_IFDIR:
archive_entry_set_size(entry, 0);
/* Don't bother trying to recreate '.' */
if (strcmp(name, ".") == 0 || strcmp(name, "./") == 0)
return (ARCHIVE_OK);
break;
case AE_IFIFO:
case AE_IFCHR:
case AE_IFBLK:
/* All other file types have zero size in the archive. */
archive_entry_set_size(entry, 0);
break;
default:
archive_entry_set_size(entry, 0);
if (archive_entry_hardlink(entry) == NULL &&
archive_entry_symlink(entry) == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"shar format cannot archive this");
return (ARCHIVE_WARN);
}
}
archive_string_empty(&shar->quoted_name);
shar_quote(&shar->quoted_name, name, 1);
/* Stock preparation for all file types. */
archive_string_sprintf(&shar->work, "echo x %s\n", shar->quoted_name.s);
if (archive_entry_filetype(entry) != AE_IFDIR) {
/* Try to create the dir. */
p = strdup(name);
pp = strrchr(p, '/');
/* If there is a / character, try to create the dir. */
if (pp != NULL) {
*pp = '\0';
/* Try to avoid a lot of redundant mkdir commands. */
if (strcmp(p, ".") == 0) {
/* Don't try to "mkdir ." */
free(p);
} else if (shar->last_dir == NULL) {
archive_strcat(&shar->work, "mkdir -p ");
shar_quote(&shar->work, p, 1);
archive_strcat(&shar->work,
" > /dev/null 2>&1\n");
shar->last_dir = p;
} else if (strcmp(p, shar->last_dir) == 0) {
/* We've already created this exact dir. */
free(p);
} else if (strlen(p) < strlen(shar->last_dir) &&
strncmp(p, shar->last_dir, strlen(p)) == 0) {
/* We've already created a subdir. */
free(p);
} else {
archive_strcat(&shar->work, "mkdir -p ");
shar_quote(&shar->work, p, 1);
archive_strcat(&shar->work,
" > /dev/null 2>&1\n");
shar->last_dir = p;
}
} else {
free(p);
}
}
/* Handle file-type specific issues. */
shar->has_data = 0;
if ((linkname = archive_entry_hardlink(entry)) != NULL) {
archive_strcat(&shar->work, "ln -f ");
shar_quote(&shar->work, linkname, 1);
archive_string_sprintf(&shar->work, " %s\n",
shar->quoted_name.s);
} else if ((linkname = archive_entry_symlink(entry)) != NULL) {
archive_strcat(&shar->work, "ln -fs ");
shar_quote(&shar->work, linkname, 1);
archive_string_sprintf(&shar->work, " %s\n",
shar->quoted_name.s);
} else {
switch(archive_entry_filetype(entry)) {
case AE_IFREG:
if (archive_entry_size(entry) == 0) {
/* More portable than "touch." */
archive_string_sprintf(&shar->work,
"test -e \"%s\" || :> \"%s\"\n",
shar->quoted_name.s, shar->quoted_name.s);
} else {
if (shar->dump) {
unsigned int mode = archive_entry_mode(entry) & 0777;
archive_string_sprintf(&shar->work,
"uudecode -p > %s << 'SHAR_END'\n",
shar->quoted_name.s);
archive_string_sprintf(&shar->work,
"begin %o ", mode);
shar_quote(&shar->work, name, 0);
archive_strcat(&shar->work, "\n");
} else {
archive_string_sprintf(&shar->work,
"sed 's/^X//' > %s << 'SHAR_END'\n",
shar->quoted_name.s);
}
shar->has_data = 1;
shar->end_of_line = 1;
shar->outpos = 0;
}
break;
case AE_IFDIR:
archive_string_sprintf(&shar->work,
"mkdir -p %s > /dev/null 2>&1\n",
shar->quoted_name.s);
/* Record that we just created this directory. */
if (shar->last_dir != NULL)
free(shar->last_dir);
shar->last_dir = strdup(name);
/* Trim a trailing '/'. */
pp = strrchr(shar->last_dir, '/');
if (pp != NULL && pp[1] == '\0')
*pp = '\0';
/*
* TODO: Put dir name/mode on a list to be fixed
* up at end of archive.
*/
break;
case AE_IFIFO:
archive_string_sprintf(&shar->work,
"mkfifo %s\n", shar->quoted_name.s);
break;
case AE_IFCHR:
archive_string_sprintf(&shar->work,
"mknod %s c %ju %ju\n", shar->quoted_name.s,
(uintmax_t)archive_entry_rdevmajor(entry),
(uintmax_t)archive_entry_rdevminor(entry));
break;
case AE_IFBLK:
archive_string_sprintf(&shar->work,
"mknod %s b %ju %ju\n", shar->quoted_name.s,
(uintmax_t)archive_entry_rdevmajor(entry),
(uintmax_t)archive_entry_rdevminor(entry));
break;
default:
return (ARCHIVE_WARN);
}
}
return (ARCHIVE_OK);
}
static int
_warc_rdhdr(struct archive_read *a, struct archive_entry *entry)
{
#define HDR_PROBE_LEN (12U)
struct warc_s *w = a->format->data;
unsigned int ver;
const char *buf;
ssize_t nrd;
const char *eoh;
/* for the file name, saves some strndup()'ing */
warc_string_t fnam;
/* warc record type, not that we really use it a lot */
warc_type_t ftyp;
/* content-length+error monad */
ssize_t cntlen;
/* record time is the WARC-Date time we reinterpret it as ctime */
time_t rtime;
/* mtime is the Last-Modified time which will be the entry's mtime */
time_t mtime;
start_over:
/* just use read_ahead() they keep track of unconsumed
* bits and bobs for us; no need to put an extra shift in
* and reproduce that functionality here */
buf = __archive_read_ahead(a, HDR_PROBE_LEN, &nrd);
if (nrd < 0) {
/* no good */
archive_set_error(
&a->archive, ARCHIVE_ERRNO_MISC,
"Bad record header");
return (ARCHIVE_FATAL);
} else if (buf == NULL) {
/* there should be room for at least WARC/bla\r\n
* must be EOF therefore */
return (ARCHIVE_EOF);
}
/* looks good so far, try and find the end of the header now */
eoh = _warc_find_eoh(buf, nrd);
if (eoh == NULL) {
/* still no good, the header end might be beyond the
* probe we've requested, but then again who'd cram
* so much stuff into the header *and* be 28500-compliant */
archive_set_error(
&a->archive, ARCHIVE_ERRNO_MISC,
"Bad record header");
return (ARCHIVE_FATAL);
} else if ((ver = _warc_rdver(buf, eoh - buf)) > 10000U) {
/* nawww, I wish they promised backward compatibility
* anyhoo, in their infinite wisdom the 28500 guys might
* come up with something we can't possibly handle so
* best end things here */
archive_set_error(
&a->archive, ARCHIVE_ERRNO_MISC,
"Unsupported record version");
return (ARCHIVE_FATAL);
} else if ((cntlen = _warc_rdlen(buf, eoh - buf)) < 0) {
/* nightmare! the specs say content-length is mandatory
* so I don't feel overly bad stopping the reader here */
archive_set_error(
&a->archive, EINVAL,
"Bad content length");
return (ARCHIVE_FATAL);
} else if ((rtime = _warc_rdrtm(buf, eoh - buf)) == (time_t)-1) {
/* record time is mandatory as per WARC/1.0,
* so just barf here, fast and loud */
archive_set_error(
&a->archive, EINVAL,
"Bad record time");
return (ARCHIVE_FATAL);
}
/* let the world know we're a WARC archive */
a->archive.archive_format = ARCHIVE_FORMAT_WARC;
if (ver != w->pver) {
/* stringify this entry's version */
archive_string_sprintf(&w->sver,
"WARC/%u.%u", ver / 10000, ver % 10000);
/* remember the version */
w->pver = ver;
}
/* start off with the type */
ftyp = _warc_rdtyp(buf, eoh - buf);
/* and let future calls know about the content */
w->cntlen = cntlen;
w->cntoff = 0U;
mtime = 0;/* Avoid compiling error on some platform. */
switch (ftyp) {
case WT_RSRC:
case WT_RSP:
/* only try and read the filename in the cases that are
* guaranteed to have one */
fnam = _warc_rduri(buf, eoh - buf);
/* check the last character in the URI to avoid creating
* directory endpoints as files, see Todo above */
if (fnam.len == 0 || fnam.str[fnam.len - 1] == '/') {
/* break here for now */
fnam.len = 0U;
fnam.str = NULL;
break;
}
/* bang to our string pool, so we save a
* malloc()+free() roundtrip */
if (fnam.len + 1U > w->pool.len) {
w->pool.len = ((fnam.len + 64U) / 64U) * 64U;
w->pool.str = realloc(w->pool.str, w->pool.len);
}
memcpy(w->pool.str, fnam.str, fnam.len);
w->pool.str[fnam.len] = '\0';
/* let noone else know about the pool, it's a secret, shhh */
fnam.str = w->pool.str;
/* snarf mtime or deduce from rtime
* this is a custom header added by our writer, it's quite
* hard to believe anyone else would go through with it
* (apart from being part of some http responses of course) */
if ((mtime = _warc_rdmtm(buf, eoh - buf)) == (time_t)-1) {
mtime = rtime;
}
break;
default:
fnam.len = 0U;
fnam.str = NULL;
break;
}
/* now eat some of those delicious buffer bits */
__archive_read_consume(a, eoh - buf);
switch (ftyp) {
case WT_RSRC:
case WT_RSP:
if (fnam.len > 0U) {
/* populate entry object */
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_copy_pathname(entry, fnam.str);
archive_entry_set_size(entry, cntlen);
archive_entry_set_perm(entry, 0644);
/* rtime is the new ctime, mtime stays mtime */
archive_entry_set_ctime(entry, rtime, 0L);
archive_entry_set_mtime(entry, mtime, 0L);
break;
}
/* FALLTHROUGH */
default:
/* consume the content and start over */
_warc_skip(a);
goto start_over;
}
return (ARCHIVE_OK);
}
static int
archive_write_mtree_finish_entry(struct archive_write *a)
{
struct mtree_writer *mtree = a->format_data;
struct archive_entry *entry;
struct archive_string *str;
const char *name;
int keys, ret;
entry = mtree->entry;
if (entry == NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER,
"Finished entry without being open first.");
return (ARCHIVE_FATAL);
}
mtree->entry = NULL;
if (mtree->dironly && archive_entry_filetype(entry) != AE_IFDIR) {
archive_entry_free(entry);
return (ARCHIVE_OK);
}
str = (mtree->indent)? &mtree->ebuf : &mtree->buf;
keys = get_keys(mtree, entry);
if ((keys & F_NLINK) != 0 &&
archive_entry_nlink(entry) != 1 &&
archive_entry_filetype(entry) != AE_IFDIR)
archive_string_sprintf(str,
" nlink=%u", archive_entry_nlink(entry));
if ((keys & F_GNAME) != 0 &&
(name = archive_entry_gname(entry)) != NULL) {
archive_strcat(str, " gname=");
mtree_quote(str, name);
}
if ((keys & F_UNAME) != 0 &&
(name = archive_entry_uname(entry)) != NULL) {
archive_strcat(str, " uname=");
mtree_quote(str, name);
}
if ((keys & F_FLAGS) != 0 &&
(name = archive_entry_fflags_text(entry)) != NULL) {
archive_strcat(str, " flags=");
mtree_quote(str, name);
}
if ((keys & F_TIME) != 0)
archive_string_sprintf(str, " time=%jd.%jd",
(intmax_t)archive_entry_mtime(entry),
(intmax_t)archive_entry_mtime_nsec(entry));
if ((keys & F_MODE) != 0)
archive_string_sprintf(str, " mode=%o",
archive_entry_mode(entry) & 07777);
if ((keys & F_GID) != 0)
archive_string_sprintf(str, " gid=%jd",
(intmax_t)archive_entry_gid(entry));
if ((keys & F_UID) != 0)
archive_string_sprintf(str, " uid=%jd",
(intmax_t)archive_entry_uid(entry));
switch (archive_entry_filetype(entry)) {
case AE_IFLNK:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=link");
if ((keys & F_SLINK) != 0) {
archive_strcat(str, " link=");
mtree_quote(str, archive_entry_symlink(entry));
}
break;
case AE_IFSOCK:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=socket");
break;
case AE_IFCHR:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=char");
if ((keys & F_DEV) != 0) {
archive_string_sprintf(str,
" device=native,%d,%d",
archive_entry_rdevmajor(entry),
archive_entry_rdevminor(entry));
}
break;
case AE_IFBLK:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=block");
if ((keys & F_DEV) != 0) {
archive_string_sprintf(str,
" device=native,%d,%d",
archive_entry_rdevmajor(entry),
archive_entry_rdevminor(entry));
}
break;
case AE_IFDIR:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=dir");
break;
case AE_IFIFO:
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=fifo");
break;
case AE_IFREG:
default: /* Handle unknown file types as regular files. */
if ((keys & F_TYPE) != 0)
archive_strcat(str, " type=file");
if ((keys & F_SIZE) != 0)
archive_string_sprintf(str, " size=%jd",
(intmax_t)archive_entry_size(entry));
break;
}
if (mtree->compute_sum & F_CKSUM) {
uint64_t len;
/* Include the length of the file. */
for (len = mtree->crc_len; len != 0; len >>= 8)
COMPUTE_CRC(mtree->crc, len & 0xff);
mtree->crc = ~mtree->crc;
archive_string_sprintf(str, " cksum=%ju",
(uintmax_t)mtree->crc);
}
/*
* Write /set keyword. It means set global datas.
* [directory-only mode]
* - It is only once to write /set keyword. It is using values of the
* first entry.
* [normal mode]
* - Write /set keyword. It is using values of the first entry whose
* filetype is a regular file.
* - When a parent directory of the entry whose filetype is the regular
* file is changed, check the global datas and write it again if its
* values are different from the entry's.
*/
static void
set_global(struct mtree_writer *mtree, struct archive_entry *entry)
{
struct archive_string setstr;
struct archive_string unsetstr;
const char *name;
int keys, oldkeys, effkeys;
mode_t set_type = 0;
switch (archive_entry_filetype(entry)) {
case AE_IFLNK: case AE_IFSOCK: case AE_IFCHR:
case AE_IFBLK: case AE_IFIFO:
break;
case AE_IFDIR:
if (mtree->dironly)
set_type = AE_IFDIR;
break;
case AE_IFREG:
default: /* Handle unknown file types as regular files. */
if (!mtree->dironly)
set_type = AE_IFREG;
break;
}
if (set_type == 0)
return;
if (mtree->set.processed &&
!parent_dir_changed(&mtree->set.parent, entry))
return;
/* At first, save a parent directory of the entry for following
* entries. */
if (!mtree->set.processed && set_type == AE_IFREG)
parent_dir_changed(&mtree->set.parent, entry);
archive_string_init(&setstr);
archive_string_init(&unsetstr);
keys = mtree->keys & (F_FLAGS | F_GID | F_GNAME | F_NLINK | F_MODE
| F_TYPE | F_UID | F_UNAME);
oldkeys = mtree->set.keys;
effkeys = keys;
if (mtree->set.processed) {
/*
* Check the global datas for whether it needs updating.
*/
effkeys &= ~F_TYPE;
if ((oldkeys & (F_UNAME | F_UID)) != 0 &&
mtree->set.uid == archive_entry_uid(entry))
effkeys &= ~(F_UNAME | F_UID);
if ((oldkeys & (F_GNAME | F_GID)) != 0 &&
mtree->set.gid == archive_entry_gid(entry))
effkeys &= ~(F_GNAME | F_GID);
if ((oldkeys & F_MODE) != 0 &&
mtree->set.mode == (archive_entry_mode(entry) & 07777))
effkeys &= ~F_MODE;
if ((oldkeys & F_FLAGS) != 0) {
unsigned long fflags_set;
unsigned long fflags_clear;
archive_entry_fflags(entry, &fflags_set, &fflags_clear);
if (fflags_set == mtree->set.fflags_set &&
fflags_clear == mtree->set.fflags_clear)
effkeys &= ~F_FLAGS;
}
}
if ((keys & effkeys & F_TYPE) != 0) {
mtree->set.type = set_type;
if (set_type == AE_IFDIR)
archive_strcat(&setstr, " type=dir");
else
archive_strcat(&setstr, " type=file");
}
if ((keys & effkeys & F_UNAME) != 0) {
if ((name = archive_entry_uname(entry)) != NULL) {
archive_strcat(&setstr, " uname=");
mtree_quote(&setstr, name);
} else if ((oldkeys & F_UNAME) != 0)
archive_strcat(&unsetstr, " uname");
else
keys &= ~F_UNAME;
}
if ((keys & effkeys & F_UID) != 0) {
mtree->set.uid = archive_entry_uid(entry);
archive_string_sprintf(&setstr, " uid=%jd",
(intmax_t)mtree->set.uid);
}
if ((keys & effkeys & F_GNAME) != 0) {
if ((name = archive_entry_gname(entry)) != NULL) {
archive_strcat(&setstr, " gname=");
mtree_quote(&setstr, name);
} else if ((oldkeys & F_GNAME) != 0)
archive_strcat(&unsetstr, " gname");
else
keys &= ~F_GNAME;
}
if ((keys & effkeys & F_GID) != 0) {
mtree->set.gid = archive_entry_gid(entry);
archive_string_sprintf(&setstr, " gid=%jd",
(intmax_t)mtree->set.gid);
}
if ((keys & effkeys & F_MODE) != 0) {
mtree->set.mode = archive_entry_mode(entry) & 07777;
archive_string_sprintf(&setstr, " mode=%o", mtree->set.mode);
}
if ((keys & effkeys & F_FLAGS) != 0) {
if ((name = archive_entry_fflags_text(entry)) != NULL) {
archive_strcat(&setstr, " flags=");
mtree_quote(&setstr, name);
archive_entry_fflags(entry, &mtree->set.fflags_set,
&mtree->set.fflags_clear);
} else if ((oldkeys & F_FLAGS) != 0)
archive_strcat(&unsetstr, " flags");
else
keys &= ~F_FLAGS;
}
if (unsetstr.length > 0)
archive_string_sprintf(&mtree->buf, "/unset%s\n", unsetstr.s);
archive_string_free(&unsetstr);
if (setstr.length > 0)
archive_string_sprintf(&mtree->buf, "/set%s\n", setstr.s);
archive_string_free(&setstr);
mtree->set.keys = keys;
mtree->set.processed = 1;
/* On directory-only mode, it is only once to write /set keyword. */
if (mtree->dironly)
mtree->set.output = 0;
}