/src/CMake/Utilities/cmlibarchive/libarchive/archive_acl.c

Source
/*-
 * Copyright (c) 2003-2010 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"

#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_WCHAR_H
#include <wchar.h>
#endif

#ifdef __clang_analyzer__
#include <assert.h>
#endif

#include "archive_acl_private.h"
#include "archive_entry.h"
#include "archive_private.h"

#undef max
#define max(a, b) ((a)>(b)?(a):(b))

#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

static int  acl_special(struct archive_acl *acl,
        int type, int permset, int tag);
static struct archive_acl_entry *acl_new_entry(struct archive_acl *acl,
        int type, int permset, int tag, int id);
static int  archive_acl_add_entry_len_l(struct archive_acl *acl,
        int type, int permset, int tag, int id, const char *name,
        size_t len, struct archive_string_conv *sc);
static int  archive_acl_text_want_type(struct archive_acl *acl, int flags);
static size_t archive_acl_text_empty(struct archive_acl *acl, int want_type);
static int  isint_w(const wchar_t *start, const wchar_t *end, int *result);
static int  ismode_w(const wchar_t *start, const wchar_t *end, int *result);
static int  is_nfs4_flags_w(const wchar_t *start, const wchar_t *end,
        int *result);
static int  is_nfs4_perms_w(const wchar_t *start, const wchar_t *end,
        int *result);
static void next_field_w(const wchar_t **wp, const wchar_t **start,
        const wchar_t **end, wchar_t *sep);
static void append_entry_w(struct archive_wstring *ws, const wchar_t *prefix, int type,
        int tag, int flags, const wchar_t *wname, int perm, int id);
static void append_id_w(struct archive_wstring *ws, int id);
static int  isint(const char *start, const char *end, int *result);
static int  ismode(const char *start, const char *end, int *result);
static int  is_nfs4_flags(const char *start, const char *end,
        int *result);
static int  is_nfs4_perms(const char *start, const char *end,
        int *result);
static void next_field(const char **p, size_t *l, const char **start,
        const char **end, char *sep);
static void append_entry(struct archive_string *s, const char *prefix, int type,
        int tag, int flags, const char *name, int perm, int id);
static void append_id(struct archive_string *s, int id);

static const struct {
  const int perm;
  const char c;
  const wchar_t wc;
} nfsv4_acl_perm_map[] = {
  { ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_LIST_DIRECTORY, 'r',
      L'r' },
  { ARCHIVE_ENTRY_ACL_WRITE_DATA | ARCHIVE_ENTRY_ACL_ADD_FILE, 'w',
      L'w' },
  { ARCHIVE_ENTRY_ACL_EXECUTE, 'x', L'x' },
  { ARCHIVE_ENTRY_ACL_APPEND_DATA | ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY,
      'p', L'p' },
  { ARCHIVE_ENTRY_ACL_DELETE, 'd', L'd' },
  { ARCHIVE_ENTRY_ACL_DELETE_CHILD, 'D', L'D' },
  { ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES, 'a', L'a' },
  { ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES, 'A', L'A' },
  { ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS, 'R', L'R' },
  { ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS, 'W', L'W' },
  { ARCHIVE_ENTRY_ACL_READ_ACL, 'c', L'c' },
  { ARCHIVE_ENTRY_ACL_WRITE_ACL, 'C', L'C' },
  { ARCHIVE_ENTRY_ACL_WRITE_OWNER, 'o', L'o' },
  { ARCHIVE_ENTRY_ACL_SYNCHRONIZE, 's', L's' }
};

static const int nfsv4_acl_perm_map_size = (int)(sizeof(nfsv4_acl_perm_map) /
    sizeof(nfsv4_acl_perm_map[0]));

static const struct {
  const int perm;
  const char c;
  const wchar_t wc;
} nfsv4_acl_flag_map[] = {
  { ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT, 'f', L'f' },
  { ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT, 'd', L'd' },
  { ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY, 'i', L'i' },
  { ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT, 'n', L'n' },
  { ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS, 'S', L'S' },
  { ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS, 'F', L'F' },
  { ARCHIVE_ENTRY_ACL_ENTRY_INHERITED, 'I', L'I' }
};

static const int nfsv4_acl_flag_map_size = (int)(sizeof(nfsv4_acl_flag_map) /
    sizeof(nfsv4_acl_flag_map[0]));

void
archive_acl_clear(struct archive_acl *acl)
{
  struct archive_acl_entry *ap;

  while (acl->acl_head != NULL) {
    ap = acl->acl_head->next;
    archive_mstring_clean(&acl->acl_head->name);
    free(acl->acl_head);
    acl->acl_head = ap;
  }
  free(acl->acl_text_w);
  acl->acl_text_w = NULL;
  free(acl->acl_text);
  acl->acl_text = NULL;
  acl->acl_p = NULL;
  acl->acl_types = 0;
  acl->acl_state = 0; /* Not counting. */
}

void
archive_acl_copy(struct archive_acl *dest, struct archive_acl *src)
{
  struct archive_acl_entry *ap, *ap2;

  archive_acl_clear(dest);

  dest->mode = src->mode;
  ap = src->acl_head;
  while (ap != NULL) {
    ap2 = acl_new_entry(dest,
        ap->type, ap->permset, ap->tag, ap->id);
    if (ap2 != NULL)
      archive_mstring_copy(&ap2->name, &ap->name);
    ap = ap->next;
  }
}

int
archive_acl_add_entry(struct archive_acl *acl,
    int type, int permset, int tag, int id, const char *name)
{
  struct archive_acl_entry *ap;

  if (acl_special(acl, type, permset, tag) == 0)
    return ARCHIVE_OK;
  ap = acl_new_entry(acl, type, permset, tag, id);
  if (ap == NULL) {
    /* XXX Error XXX */
    return ARCHIVE_FAILED;
  }
  if (name != NULL  &&  *name != '\0')
    archive_mstring_copy_mbs(&ap->name, name);
  else
    archive_mstring_clean(&ap->name);
  return ARCHIVE_OK;
}

int
archive_acl_add_entry_w_len(struct archive_acl *acl,
    int type, int permset, int tag, int id, const wchar_t *name, size_t len)
{
  struct archive_acl_entry *ap;

  if (acl_special(acl, type, permset, tag) == 0)
    return ARCHIVE_OK;
  ap = acl_new_entry(acl, type, permset, tag, id);
  if (ap == NULL) {
    /* XXX Error XXX */
    return ARCHIVE_FAILED;
  }
  if (name != NULL  &&  *name != L'\0' && len > 0)
    archive_mstring_copy_wcs_len(&ap->name, name, len);
  else
    archive_mstring_clean(&ap->name);
  return ARCHIVE_OK;
}

static int
archive_acl_add_entry_len_l(struct archive_acl *acl,
    int type, int permset, int tag, int id, const char *name, size_t len,
    struct archive_string_conv *sc)
{
  struct archive_acl_entry *ap;
  int r;

  if (acl_special(acl, type, permset, tag) == 0)
    return ARCHIVE_OK;
  ap = acl_new_entry(acl, type, permset, tag, id);
  if (ap == NULL) {
    /* XXX Error XXX */
    return ARCHIVE_FAILED;
  }
  if (name != NULL  &&  *name != '\0' && len > 0) {
    r = archive_mstring_copy_mbs_len_l(&ap->name, name, len, sc);
  } else {
    r = 0;
    archive_mstring_clean(&ap->name);
  }
  if (r == 0)
    return (ARCHIVE_OK);
  else if (errno == ENOMEM)
    return (ARCHIVE_FATAL);
  else
    return (ARCHIVE_WARN);
}

/*
 * If this ACL entry is part of the standard POSIX permissions set,
 * store the permissions in the stat structure and return zero.
 */
static int
acl_special(struct archive_acl *acl, int type, int permset, int tag)
{
  if (type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS
      && ((permset & ~007) == 0)) {
    switch (tag) {
    case ARCHIVE_ENTRY_ACL_USER_OBJ:
      acl->mode &= ~0700;
      acl->mode |= (permset & 7) << 6;
      return (0);
    case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
      acl->mode &= ~0070;
      acl->mode |= (permset & 7) << 3;
      return (0);
    case ARCHIVE_ENTRY_ACL_OTHER:
      acl->mode &= ~0007;
      acl->mode |= permset & 7;
      return (0);
    }
  }
  return (1);
}

/*
 * Allocate and populate a new ACL entry with everything but the
 * name.
 */
static struct archive_acl_entry *
acl_new_entry(struct archive_acl *acl,
    int type, int permset, int tag, int id)
{
  struct archive_acl_entry *ap, *aq;

  /* Reject an invalid type */
  switch (type) {
  case ARCHIVE_ENTRY_ACL_TYPE_ACCESS:
  case ARCHIVE_ENTRY_ACL_TYPE_DEFAULT:
  case ARCHIVE_ENTRY_ACL_TYPE_ALLOW:
  case ARCHIVE_ENTRY_ACL_TYPE_DENY:
  case ARCHIVE_ENTRY_ACL_TYPE_AUDIT:
  case ARCHIVE_ENTRY_ACL_TYPE_ALARM:
    break;
  default:
    return (NULL);
  }

  /* Type argument must be a valid NFS4 or POSIX.1e type.
   * The type must agree with anything already set and
   * the permset must be compatible. */
  if (type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
    if (acl->acl_types & ~ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
      return (NULL);
    }
    if (permset &
        ~(ARCHIVE_ENTRY_ACL_PERMS_NFS4
      | ARCHIVE_ENTRY_ACL_INHERITANCE_NFS4)) {
      return (NULL);
    }
  } else  if (type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) {
    if (acl->acl_types & ~ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) {
      return (NULL);
    }
    if (permset & ~ARCHIVE_ENTRY_ACL_PERMS_POSIX1E) {
      return (NULL);
    }
  } else {
    return (NULL);
  }

  /* Verify the tag is valid and compatible with NFS4 or POSIX.1e. */
  switch (tag) {
  case ARCHIVE_ENTRY_ACL_USER:
  case ARCHIVE_ENTRY_ACL_USER_OBJ:
  case ARCHIVE_ENTRY_ACL_GROUP:
  case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
    /* Tags valid in both NFS4 and POSIX.1e */
    break;
  case ARCHIVE_ENTRY_ACL_MASK:
  case ARCHIVE_ENTRY_ACL_OTHER:
    /* Tags valid only in POSIX.1e. */
    if (type & ~ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) {
      return (NULL);
    }
    break;
  case ARCHIVE_ENTRY_ACL_EVERYONE:
    /* Tags valid only in NFS4. */
    if (type & ~ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
      return (NULL);
    }
    break;
  default:
    /* No other values are valid. */
    return (NULL);
  }

  free(acl->acl_text_w);
  acl->acl_text_w = NULL;
  free(acl->acl_text);
  acl->acl_text = NULL;

  /*
   * If there's a matching entry already in the list, overwrite it.
   * NFSv4 entries may be repeated and are not overwritten.
   *
   * TODO: compare names of no id is provided (needs more rework)
   */
  ap = acl->acl_head;
  aq = NULL;
  while (ap != NULL) {
    if (((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) == 0) &&
        ap->type == type && ap->tag == tag && ap->id == id) {
      if (id != -1 || (tag != ARCHIVE_ENTRY_ACL_USER &&
          tag != ARCHIVE_ENTRY_ACL_GROUP)) {
        ap->permset = permset;
        return (ap);
      }
    }
    aq = ap;
    ap = ap->next;
  }

  /* Add a new entry to the end of the list. */
  ap = calloc(1, sizeof(*ap));
  if (ap == NULL)
    return (NULL);
  if (aq == NULL)
    acl->acl_head = ap;
  else
    aq->next = ap;
  ap->type = type;
  ap->tag = tag;
  ap->id = id;
  ap->permset = permset;
  acl->acl_types |= type;
  return (ap);
}

/*
 * Return a count of entries matching "want_type".
 */
int
archive_acl_count(struct archive_acl *acl, int want_type)
{
  int count;
  struct archive_acl_entry *ap;

  count = 0;
  ap = acl->acl_head;
  while (ap != NULL) {
    if ((ap->type & want_type) != 0)
      count++;
    ap = ap->next;
  }

  if (count > 0 && ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0))
    count += 3;
  return (count);
}

/*
 * Return a bitmask of stored ACL types in an ACL list
 */
int
archive_acl_types(struct archive_acl *acl)
{
  return (acl->acl_types);
}

/*
 * Prepare for reading entries from the ACL data.  Returns a count
 * of entries matching "want_type", or zero if there are no
 * non-extended ACL entries of that type.
 */
int
archive_acl_reset(struct archive_acl *acl, int want_type)
{
  int count, cutoff;

  count = archive_acl_count(acl, want_type);

  /*
   * If the only entries are the three standard ones,
   * then don't return any ACL data.  (In this case,
   * client can just use chmod(2) to set permissions.)
   */
  if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)
    cutoff = 3;
  else
    cutoff = 0;

  if (count > cutoff)
    acl->acl_state = ARCHIVE_ENTRY_ACL_USER_OBJ;
  else
    acl->acl_state = 0;
  acl->acl_p = acl->acl_head;
  return (count);
}


/*
 * Return the next ACL entry in the list.  Fake entries for the
 * standard permissions and include them in the returned list.
 */
int
archive_acl_next(struct archive *a, struct archive_acl *acl, int want_type,
    int *type, int *permset, int *tag, int *id, const char **name)
{
  *name = NULL;
  *id = -1;

  /*
   * The acl_state is either zero (no entries available), -1
   * (reading from list), or an entry type (retrieve that type
   * from ae_stat.aest_mode).
   */
  if (acl->acl_state == 0)
    return (ARCHIVE_WARN);

  /* The first three access entries are special. */
  if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
    switch (acl->acl_state) {
    case ARCHIVE_ENTRY_ACL_USER_OBJ:
      *permset = (acl->mode >> 6) & 7;
      *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
      *tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
      acl->acl_state = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
      return (ARCHIVE_OK);
    case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
      *permset = (acl->mode >> 3) & 7;
      *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
      *tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
      acl->acl_state = ARCHIVE_ENTRY_ACL_OTHER;
      return (ARCHIVE_OK);
    case ARCHIVE_ENTRY_ACL_OTHER:
      *permset = acl->mode & 7;
      *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
      *tag = ARCHIVE_ENTRY_ACL_OTHER;
      acl->acl_state = -1;
      acl->acl_p = acl->acl_head;
      return (ARCHIVE_OK);
    default:
      break;
    }
  }

  while (acl->acl_p != NULL && (acl->acl_p->type & want_type) == 0)
    acl->acl_p = acl->acl_p->next;
  if (acl->acl_p == NULL) {
    acl->acl_state = 0;
    *type = 0;
    *permset = 0;
    *tag = 0;
    *id = -1;
    *name = NULL;
    return (ARCHIVE_EOF); /* End of ACL entries. */
  }
  *type = acl->acl_p->type;
  *permset = acl->acl_p->permset;
  *tag = acl->acl_p->tag;
  *id = acl->acl_p->id;
  if (archive_mstring_get_mbs(a, &acl->acl_p->name, name) != 0) {
    if (errno == ENOMEM)
      return (ARCHIVE_FATAL);
    *name = NULL;
  }
  acl->acl_p = acl->acl_p->next;
  return (ARCHIVE_OK);
}

/*
 * Determine what type of ACL do we want
 */
static int
archive_acl_text_want_type(struct archive_acl *acl, int flags)
{
  int want_type;

  /* Check if ACL is NFSv4 */
  if ((acl->acl_types & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
    /* NFSv4 should never mix with POSIX.1e */
    if ((acl->acl_types & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0)
      return (0);
    else
      return (ARCHIVE_ENTRY_ACL_TYPE_NFS4);
  }

  /* Now deal with POSIX.1e ACLs */

  want_type = 0;
  if ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)
    want_type |= ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
  if ((flags & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0)
    want_type |= ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;

  /* By default we want both access and default ACLs */
  if (want_type == 0)
    return (ARCHIVE_ENTRY_ACL_TYPE_POSIX1E);

  return (want_type);
}

/*
 * Check if ACL text would be empty
 */
static size_t
archive_acl_text_empty(struct archive_acl *acl, int want_type) {
  struct archive_acl_entry *ap;

  for (ap = acl->acl_head; ap != NULL; ap = ap->next) {
    if ((ap->type & want_type) == 0)
      continue;
    /*
     * Filemode-mapping ACL entries are stored exclusively in
     * ap->mode so they should not be in the list
     */
    if ((ap->type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS)
        && (ap->tag == ARCHIVE_ENTRY_ACL_USER_OBJ
        || ap->tag == ARCHIVE_ENTRY_ACL_GROUP_OBJ
        || ap->tag == ARCHIVE_ENTRY_ACL_OTHER))
      continue;

    return (0);
  }

  return (1);
}

/*
 * Generate a wide text version of the ACL. The flags parameter controls
 * the type and style of the generated ACL.
 */
wchar_t *
archive_acl_to_text_w(struct archive_acl *acl, ssize_t *text_len, int flags,
    struct archive *a)
{
  const wchar_t *wname;
  const wchar_t *prefix;
  wchar_t separator;
  struct archive_acl_entry *ap;
  struct archive_wstring ws;
  int id, r, want_type;

  want_type = archive_acl_text_want_type(acl, flags);

  /* Both NFSv4 and POSIX.1 types found */
  if (want_type == 0)
    return (NULL);

  if (want_type == ARCHIVE_ENTRY_ACL_TYPE_POSIX1E)
    flags |= ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT;

  if (archive_acl_text_empty(acl, want_type))
    return (NULL);

  if (flags & ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA)
    separator = L',';
  else
    separator = L'\n';

  archive_string_init(&ws);

  if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
    append_entry_w(&ws, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
        ARCHIVE_ENTRY_ACL_USER_OBJ, flags, NULL,
        acl->mode & 0700, -1);
    archive_wstrappend_wchar(&ws, separator);
    append_entry_w(&ws, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
        ARCHIVE_ENTRY_ACL_GROUP_OBJ, flags, NULL,
        acl->mode & 0070, -1);
    archive_wstrappend_wchar(&ws, separator);
    append_entry_w(&ws, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
        ARCHIVE_ENTRY_ACL_OTHER, flags, NULL,
        acl->mode & 0007, -1);
  }

  for (ap = acl->acl_head; ap != NULL; ap = ap->next) {
    if ((ap->type & want_type) == 0)
      continue;
    /*
     * Filemode-mapping ACL entries are stored exclusively in
     * ap->mode so they should not be in the list
     */
    if ((ap->type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS)
        && (ap->tag == ARCHIVE_ENTRY_ACL_USER_OBJ
        || ap->tag == ARCHIVE_ENTRY_ACL_GROUP_OBJ
        || ap->tag == ARCHIVE_ENTRY_ACL_OTHER))
      continue;
    if (ap->type == ARCHIVE_ENTRY_ACL_TYPE_DEFAULT &&
        (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) != 0)
      prefix = L"default:";
    else
      prefix = NULL;
    r = archive_mstring_get_wcs(a, &ap->name, &wname);
    if (r == 0) {
      if (ws.length > 0)
        archive_wstrappend_wchar(&ws, separator);
      if ((flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID) ||
          wname == NULL)
        id = ap->id;
      else
        id = -1;
      append_entry_w(&ws, prefix, ap->type, ap->tag, flags,
          wname, ap->permset, id);
    } else if (r < 0 && errno == ENOMEM) {
      archive_wstring_free(&ws);
      return (NULL);
    }
  }

  if (text_len != NULL)
    *text_len = ws.length;

  return (ws.s);
}

static void
append_id_w(struct archive_wstring *ws, int id)
{
  if (id < 0)
    id = 0;
  if (id > 9)
    append_id_w(ws, id / 10);
  archive_wstrappend_wchar(ws, L"0123456789"[id % 10]);
}

static void
append_entry_w(struct archive_wstring *ws, const wchar_t *prefix, int type,
    int tag, int flags, const wchar_t *wname, int perm, int id)
{
  int i;

  if (prefix != NULL)
    archive_wstrcat(ws, prefix);
  switch (tag) {
  case ARCHIVE_ENTRY_ACL_USER_OBJ:
    wname = NULL;
    id = -1;
    if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
      archive_wstrcat(ws, L"owner@");
      break;
    }
    /* FALLTHROUGH */
  case ARCHIVE_ENTRY_ACL_USER:
    archive_wstrcat(ws, L"user");
    break;
  case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
    wname = NULL;
    id = -1;
    if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
      archive_wstrcat(ws, L"group@");
      break;
    }
    /* FALLTHROUGH */
  case ARCHIVE_ENTRY_ACL_GROUP:
    archive_wstrcat(ws, L"group");
    break;
  case ARCHIVE_ENTRY_ACL_MASK:
    archive_wstrcat(ws, L"mask");
    wname = NULL;
    id = -1;
    break;
  case ARCHIVE_ENTRY_ACL_OTHER:
    archive_wstrcat(ws, L"other");
    wname = NULL;
    id = -1;
    break;
  case ARCHIVE_ENTRY_ACL_EVERYONE:
    archive_wstrcat(ws, L"everyone@");
    wname = NULL;
    id = -1;
    break;
  default:
    break;
  }
  archive_wstrappend_wchar(ws, L':');
  if (((type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0) ||
      tag == ARCHIVE_ENTRY_ACL_USER ||
      tag == ARCHIVE_ENTRY_ACL_GROUP) {
    if (wname != NULL) {
      archive_wstrcat(ws, wname);
    } else if (tag == ARCHIVE_ENTRY_ACL_USER
        || tag == ARCHIVE_ENTRY_ACL_GROUP) {
      append_id_w(ws, id);
      if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) == 0)
        id = -1;
    }
    /* Solaris style has no second colon after other and mask */
    if (((flags & ARCHIVE_ENTRY_ACL_STYLE_SOLARIS) == 0)
        || (tag != ARCHIVE_ENTRY_ACL_OTHER
        && tag != ARCHIVE_ENTRY_ACL_MASK))
      archive_wstrappend_wchar(ws, L':');
  }
  if ((type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0) {
    /* POSIX.1e ACL perms */
    archive_wstrappend_wchar(ws, (perm & 0444) ? L'r' : L'-');
    archive_wstrappend_wchar(ws, (perm & 0222) ? L'w' : L'-');
    archive_wstrappend_wchar(ws, (perm & 0111) ? L'x' : L'-');
  } else {
    /* NFSv4 ACL perms */
    for (i = 0; i < nfsv4_acl_perm_map_size; i++) {
      if (perm & nfsv4_acl_perm_map[i].perm)
        archive_wstrappend_wchar(ws, nfsv4_acl_perm_map[i].wc);
      else if ((flags & ARCHIVE_ENTRY_ACL_STYLE_COMPACT) == 0)
        archive_wstrappend_wchar(ws, L'-');
    }
    archive_wstrappend_wchar(ws, L':');
    for (i = 0; i < nfsv4_acl_flag_map_size; i++) {
      if (perm & nfsv4_acl_flag_map[i].perm)
        archive_wstrappend_wchar(ws, nfsv4_acl_flag_map[i].wc);
      else if ((flags & ARCHIVE_ENTRY_ACL_STYLE_COMPACT) == 0)
        archive_wstrappend_wchar(ws, L'-');
    }
    archive_wstrappend_wchar(ws, L':');
    switch (type) {
    case ARCHIVE_ENTRY_ACL_TYPE_ALLOW:
      archive_wstrcat(ws, L"allow");
      break;
    case ARCHIVE_ENTRY_ACL_TYPE_DENY:
      archive_wstrcat(ws, L"deny");
      break;
    case ARCHIVE_ENTRY_ACL_TYPE_AUDIT:
      archive_wstrcat(ws, L"audit");
      break;
    case ARCHIVE_ENTRY_ACL_TYPE_ALARM:
      archive_wstrcat(ws, L"alarm");
      break;
    default:
      break;
    }
  }
  if (id != -1) {
    archive_wstrappend_wchar(ws, L':');
    append_id_w(ws, id);
  }
}

/*
 * Generate a text version of the ACL. The flags parameter controls
 * the type and style of the generated ACL.
 */
char *
archive_acl_to_text_l(struct archive_acl *acl, ssize_t *text_len, int flags,
    struct archive_string_conv *sc)
{
  size_t len;
  const char *name;
  const char *prefix;
  char separator;
  struct archive_acl_entry *ap;
  struct archive_string s;
  int id, r, want_type;

  want_type = archive_acl_text_want_type(acl, flags);

  /* Both NFSv4 and POSIX.1 types found */
  if (want_type == 0)
    return (NULL);

  if (want_type == ARCHIVE_ENTRY_ACL_TYPE_POSIX1E)
    flags |= ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT;

  if (archive_acl_text_empty(acl, want_type))
    return (NULL);

  if (flags & ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA)
    separator = ',';
  else
    separator = '\n';

  archive_string_init(&s);

  if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
    append_entry(&s, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
        ARCHIVE_ENTRY_ACL_USER_OBJ, flags, NULL,
        acl->mode & 0700, -1);
    archive_strappend_char(&s, separator);
    append_entry(&s, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
        ARCHIVE_ENTRY_ACL_GROUP_OBJ, flags, NULL,
        acl->mode & 0070, -1);
    archive_strappend_char(&s, separator);
    append_entry(&s, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
        ARCHIVE_ENTRY_ACL_OTHER, flags, NULL,
        acl->mode & 0007, -1);
  }

  for (ap = acl->acl_head; ap != NULL; ap = ap->next) {
    if ((ap->type & want_type) == 0)
      continue;
    /*
     * Filemode-mapping ACL entries are stored exclusively in
     * ap->mode so they should not be in the list
     */
    if ((ap->type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS)
        && (ap->tag == ARCHIVE_ENTRY_ACL_USER_OBJ
        || ap->tag == ARCHIVE_ENTRY_ACL_GROUP_OBJ
        || ap->tag == ARCHIVE_ENTRY_ACL_OTHER))
      continue;
    if (ap->type == ARCHIVE_ENTRY_ACL_TYPE_DEFAULT &&
        (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) != 0)
      prefix = "default:";
    else
      prefix = NULL;
    r = archive_mstring_get_mbs_l(
        NULL, &ap->name, &name, &len, sc);
    if (r != 0) {
      archive_string_free(&s);
      return (NULL);
    }
    if (s.length > 0)
      archive_strappend_char(&s, separator);
    if (name == NULL ||
        (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)) {
      id = ap->id;
    } else {
      id = -1;
    }
    append_entry(&s, prefix, ap->type, ap->tag, flags, name,
        ap->permset, id);
  }

  if (text_len != NULL)
    *text_len = s.length;

  return (s.s);
}

static void
append_id(struct archive_string *s, int id)
{
  if (id < 0)
    id = 0;
  if (id > 9)
    append_id(s, id / 10);
  archive_strappend_char(s, "0123456789"[id % 10]);
}

static void
append_entry(struct archive_string *s, const char *prefix, int type,
    int tag, int flags, const char *name, int perm, int id)
{
  int i;

  if (prefix != NULL)
    archive_strcat(s, prefix);
  switch (tag) {
  case ARCHIVE_ENTRY_ACL_USER_OBJ:
    name = NULL;
    id = -1;
    if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
      archive_strcat(s, "owner@");
      break;
    }
    /* FALLTHROUGH */
  case ARCHIVE_ENTRY_ACL_USER:
    archive_strcat(s, "user");
    break;
  case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
    name = NULL;
    id = -1;
    if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
      archive_strcat(s, "group@");
      break;
    }
    /* FALLTHROUGH */
  case ARCHIVE_ENTRY_ACL_GROUP:
    archive_strcat(s, "group");
    break;
  case ARCHIVE_ENTRY_ACL_MASK:
    archive_strcat(s, "mask");
    name = NULL;
    id = -1;
    break;
  case ARCHIVE_ENTRY_ACL_OTHER:
    archive_strcat(s, "other");
    name = NULL;
    id = -1;
    break;
  case ARCHIVE_ENTRY_ACL_EVERYONE:
    archive_strcat(s, "everyone@");
    name = NULL;
    id = -1;
    break;
  default:
    break;
  }
  archive_strappend_char(s, ':');
  if (((type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0) ||
      tag == ARCHIVE_ENTRY_ACL_USER ||
      tag == ARCHIVE_ENTRY_ACL_GROUP) {
    if (name != NULL) {
      archive_strcat(s, name);
    } else if (tag == ARCHIVE_ENTRY_ACL_USER
        || tag == ARCHIVE_ENTRY_ACL_GROUP) {
      append_id(s, id);
      if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) == 0)
        id = -1;
    }
    /* Solaris style has no second colon after other and mask */
    if (((flags & ARCHIVE_ENTRY_ACL_STYLE_SOLARIS) == 0)
        || (tag != ARCHIVE_ENTRY_ACL_OTHER
        && tag != ARCHIVE_ENTRY_ACL_MASK))
      archive_strappend_char(s, ':');
  }
  if ((type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0) {
    /* POSIX.1e ACL perms */
    archive_strappend_char(s, (perm & 0444) ? 'r' : '-');
    archive_strappend_char(s, (perm & 0222) ? 'w' : '-');
    archive_strappend_char(s, (perm & 0111) ? 'x' : '-');
  } else {
    /* NFSv4 ACL perms */
    for (i = 0; i < nfsv4_acl_perm_map_size; i++) {
      if (perm & nfsv4_acl_perm_map[i].perm)
        archive_strappend_char(s, nfsv4_acl_perm_map[i].c);
      else if ((flags & ARCHIVE_ENTRY_ACL_STYLE_COMPACT) == 0)
        archive_strappend_char(s, '-');
    }
    archive_strappend_char(s, ':');
    for (i = 0; i < nfsv4_acl_flag_map_size; i++) {
      if (perm & nfsv4_acl_flag_map[i].perm)
        archive_strappend_char(s, nfsv4_acl_flag_map[i].c);
      else if ((flags & ARCHIVE_ENTRY_ACL_STYLE_COMPACT) == 0)
        archive_strappend_char(s, '-');
    }
    archive_strappend_char(s, ':');
    switch (type) {
    case ARCHIVE_ENTRY_ACL_TYPE_ALLOW:
      archive_strcat(s, "allow");
      break;
    case ARCHIVE_ENTRY_ACL_TYPE_DENY:
      archive_strcat(s, "deny");
      break;
    case ARCHIVE_ENTRY_ACL_TYPE_AUDIT:
      archive_strcat(s, "audit");
      break;
    case ARCHIVE_ENTRY_ACL_TYPE_ALARM:
      archive_strcat(s, "alarm");
      break;
    default:
      break;
    }
  }
  if (id != -1) {
    archive_strappend_char(s, ':');
    append_id(s, id);
  }
}

/*
 * Parse a wide ACL text string.
 *
 * The want_type argument may be one of the following:
 * ARCHIVE_ENTRY_ACL_TYPE_ACCESS - text is a POSIX.1e ACL of type ACCESS
 * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT - text is a POSIX.1e ACL of type DEFAULT
 * ARCHIVE_ENTRY_ACL_TYPE_NFS4 - text is as a NFSv4 ACL
 *
 * POSIX.1e ACL entries prefixed with "default:" are treated as
 * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT unless type is ARCHIVE_ENTRY_ACL_TYPE_NFS4
 */
int
archive_acl_from_text_w(struct archive_acl *acl, const wchar_t *text,
    int want_type)
{
  struct {
    const wchar_t *start;
    const wchar_t *end;
  } field[6], name;

  const wchar_t *s, *st;

  int numfields, fields, n, r, sol, ret;
  int type, types, tag, permset, id;
  size_t len;
  wchar_t sep;

  ret = ARCHIVE_OK;
  types = 0;

  switch (want_type) {
  case ARCHIVE_ENTRY_ACL_TYPE_POSIX1E:
    want_type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
    __LA_FALLTHROUGH;
  case ARCHIVE_ENTRY_ACL_TYPE_ACCESS:
  case ARCHIVE_ENTRY_ACL_TYPE_DEFAULT:
    numfields = 5;
    break;
  case ARCHIVE_ENTRY_ACL_TYPE_NFS4:
    numfields = 6;
    break;
  default:
    return (ARCHIVE_FATAL);
  }

  while (text != NULL && *text != L'\0') {
    /*
     * Parse the fields out of the next entry,
     * advance 'text' to start of next entry.
     */
    fields = 0;
    do {
      const wchar_t *start, *end;
      next_field_w(&text, &start, &end, &sep);
      if (fields < numfields) {
        field[fields].start = start;
        field[fields].end = end;
      }
      ++fields;
    } while (sep == L':');

    /* Set remaining fields to blank. */
    for (n = fields; n < numfields; ++n)
      field[n].start = field[n].end = NULL;
    
    if (field[0].start == NULL || field[0].end == NULL) {
      /* This should never happen */
      return (ARCHIVE_FATAL);
    }

    if (*(field[0].start) == L'#') {
      /* Comment, skip entry */
      continue;
    }

    n = 0;
    sol = 0;
    id = -1;
    permset = 0;
    name.start = name.end = NULL;

    if (want_type != ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
      /* POSIX.1e ACLs */
      /*
       * Default keyword "default:user::rwx"
       * if found, we have one more field
       *
       * We also support old Solaris extension:
       * "defaultuser::rwx" is the default ACL corresponding
       * to "user::rwx", etc. valid only for first field
       */
      s = field[0].start;
      #ifdef __clang_analyzer__
      assert(s);
      #endif
      len = field[0].end - field[0].start;
      if (*s == L'd' && (len == 1 || (len >= 7
          && wmemcmp((s + 1), L"efault", 6) == 0))) {
        type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
        if (len > 7)
          field[0].start += 7;
        else
          n = 1;
      } else
        type = want_type;

      /* Check for a numeric ID in field n+1 or n+3. */
      if (isint_w(field[n + 1].start, field[n + 1].end,
          &id) < 0) {
        ret = ARCHIVE_WARN;
        continue;
      }
      /* Field n+3 is optional. */
      if (id == -1 && fields > n+3 &&
          isint_w(field[n + 3].start, field[n + 3].end,
          &id) < 0) {
        ret = ARCHIVE_WARN;
        continue;
      }

      tag = 0;
      s = field[n].start;
      len = field[n].end - field[n].start;
      if (len == 0) {
        ret = ARCHIVE_WARN;
        continue;
      }
      st = s + 1;

      switch (*s) {
      case L'u':
        if (len == 1 || (len == 4
            && wmemcmp(st, L"ser", 3) == 0))
          tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
        break;
      case L'g':
        if (len == 1 || (len == 5
            && wmemcmp(st, L"roup", 4) == 0))
          tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
        break;
      case L'o':
        if (len == 1 || (len == 5
            && wmemcmp(st, L"ther", 4) == 0))
          tag = ARCHIVE_ENTRY_ACL_OTHER;
        break;
      case L'm':
        if (len == 1 || (len == 4
            && wmemcmp(st, L"ask", 3) == 0))
          tag = ARCHIVE_ENTRY_ACL_MASK;
        break;
      default:
          break;
      }

      switch (tag) {
      case ARCHIVE_ENTRY_ACL_OTHER:
      case ARCHIVE_ENTRY_ACL_MASK:
        if (fields == (n + 2)
            && field[n + 1].start < field[n + 1].end
            && ismode_w(field[n + 1].start,
            field[n + 1].end, &permset)) {
          /* This is Solaris-style "other:rwx" */
          sol = 1;
        } else if (fields == (n + 3) &&
            field[n + 1].start < field[n + 1].end) {
          /* Invalid mask or other field */
          ret = ARCHIVE_WARN;
          continue;
        }
        break;
      case ARCHIVE_ENTRY_ACL_USER_OBJ:
      case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
        if (id != -1 ||
            field[n + 1].start < field[n + 1].end) {
          name = field[n + 1];
          if (tag == ARCHIVE_ENTRY_ACL_USER_OBJ)
            tag = ARCHIVE_ENTRY_ACL_USER;
          else
            tag = ARCHIVE_ENTRY_ACL_GROUP;
        }
        break;
      default:
        /* Invalid tag, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }

      /*
       * Without "default:" we expect mode in field 2
       * Exception: Solaris other and mask fields
       */
      if (permset == 0 && !ismode_w(field[n + 2 - sol].start,
          field[n + 2 - sol].end, &permset)) {
        /* Invalid mode, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }
    } else {
      /* NFS4 ACLs */
      s = field[0].start;
      len = field[0].end - field[0].start;
      tag = 0;

      switch (len) {
      case 4:
        if (wmemcmp(s, L"user", 4) == 0)
          tag = ARCHIVE_ENTRY_ACL_USER;
        break;
      case 5:
        if (wmemcmp(s, L"group", 5) == 0)
          tag = ARCHIVE_ENTRY_ACL_GROUP;
        break;
      case 6:
        if (wmemcmp(s, L"owner@", 6) == 0)
          tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
        else if (wmemcmp(s, L"group@", len) == 0)
          tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
        break;
      case 9:
        if (wmemcmp(s, L"everyone@", 9) == 0)
          tag = ARCHIVE_ENTRY_ACL_EVERYONE;
      default:
        break;
      }

      if (tag == 0) {
        /* Invalid tag, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      } else if (tag == ARCHIVE_ENTRY_ACL_USER ||
          tag == ARCHIVE_ENTRY_ACL_GROUP) {
        n = 1;
        name = field[1];
        if (isint_w(name.start, name.end, &id) < 0) {
          ret = ARCHIVE_WARN;
          continue;
        }
      } else
        n = 0;

      if (!is_nfs4_perms_w(field[1 + n].start,
          field[1 + n].end, &permset)) {
        /* Invalid NFSv4 perms, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }
      if (!is_nfs4_flags_w(field[2 + n].start,
          field[2 + n].end, &permset)) {
        /* Invalid NFSv4 flags, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }
      s = field[3 + n].start;
      len = field[3 + n].end - field[3 + n].start;
      type = 0;
      if (len == 4) {
        if (wmemcmp(s, L"deny", 4) == 0)
          type = ARCHIVE_ENTRY_ACL_TYPE_DENY;
      } else if (len == 5) {
        if (wmemcmp(s, L"allow", 5) == 0)
          type = ARCHIVE_ENTRY_ACL_TYPE_ALLOW;
        else if (wmemcmp(s, L"audit", 5) == 0)
          type = ARCHIVE_ENTRY_ACL_TYPE_AUDIT;
        else if (wmemcmp(s, L"alarm", 5) == 0)
          type = ARCHIVE_ENTRY_ACL_TYPE_ALARM;
      }
      if (type == 0) {
        /* Invalid entry type, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }
      if (isint_w(field[4 + n].start, field[4 + n].end,
          &id) < 0) {
        ret = ARCHIVE_WARN;
        continue;
      }
    }

    /* Add entry to the internal list. */
    r = archive_acl_add_entry_w_len(acl, type, permset,
        tag, id, name.start, name.end - name.start);
    if (r < ARCHIVE_WARN)
      return (r);
    if (r != ARCHIVE_OK)
      ret = ARCHIVE_WARN;
    types |= type;
  }

  /* Reset ACL */
  archive_acl_reset(acl, types);

  return (ret);
}

/*
 * Parse a string to a positive decimal integer.  Returns true if
 * the string is non-empty and consists only of decimal digits,
 * false otherwise.
 */
static int
isint_w(const wchar_t *start, const wchar_t *end, int *result)
{
  int n = 0;
  if (start >= end)
    return (0);
  while (start < end) {
    if (*start < L'0' || *start > L'9')
      return (0);
    if (n > (INT_MAX / 10) ||
        (n == INT_MAX / 10 && (*start - L'0') >= INT_MAX % 10)) {
      return (-1);
    } else {
      n *= 10;
      n += *start - L'0';
    }
    start++;
  }
  *result = n;
  return (1);
}

/*
 * Parse a string as a mode field.  Returns true if
 * the string is non-empty and consists only of mode characters,
 * false otherwise.
 */
static int
ismode_w(const wchar_t *start, const wchar_t *end, int *permset)
{
  const wchar_t *p;

  if (start >= end)
    return (0);
  p = start;
  *permset = 0;
  while (p < end) {
    switch (*p++) {
    case L'r': case L'R':
      *permset |= ARCHIVE_ENTRY_ACL_READ;
      break;
    case L'w': case L'W':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE;
      break;
    case L'x': case L'X':
      *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
      break;
    case L'-':
      break;
    default:
      return (0);
    }
  }
  return (1);
}

/*
 * Parse a string as a NFS4 ACL permission field.
 * Returns true if the string is non-empty and consists only of NFS4 ACL
 * permission characters, false otherwise
 */
static int
is_nfs4_perms_w(const wchar_t *start, const wchar_t *end, int *permset)
{
  const wchar_t *p = start;

  while (p < end) {
    switch (*p++) {
    case L'r':
      *permset |= ARCHIVE_ENTRY_ACL_READ_DATA;
      break;
    case L'w':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_DATA;
      break;
    case L'x':
      *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
      break;
    case L'p':
      *permset |= ARCHIVE_ENTRY_ACL_APPEND_DATA;
      break;
    case L'D':
      *permset |= ARCHIVE_ENTRY_ACL_DELETE_CHILD;
      break;
    case L'd':
      *permset |= ARCHIVE_ENTRY_ACL_DELETE;
      break;
    case L'a':
      *permset |= ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES;
      break;
    case L'A':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES;
      break;
    case L'R':
      *permset |= ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS;
      break;
    case L'W':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS;
      break;
    case L'c':
      *permset |= ARCHIVE_ENTRY_ACL_READ_ACL;
      break;
    case L'C':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_ACL;
      break;
    case L'o':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_OWNER;
      break;
    case L's':
      *permset |= ARCHIVE_ENTRY_ACL_SYNCHRONIZE;
      break;
    case L'-':
      break;
    default:
      return(0);
    }
  }
  return (1);
}

/*
 * Parse a string as a NFS4 ACL flags field.
 * Returns true if the string is non-empty and consists only of NFS4 ACL
 * flag characters, false otherwise
 */
static int
is_nfs4_flags_w(const wchar_t *start, const wchar_t *end, int *permset)
{
  const wchar_t *p = start;

  while (p < end) {
    switch(*p++) {
    case L'f':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT;
      break;
    case L'd':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT;
      break;
    case L'i':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY;
      break;
    case L'n':
      *permset |=
          ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT;
      break;
    case L'S':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS;
      break;
    case L'F':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS;
      break;
    case L'I':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_INHERITED;
      break;
    case L'-':
      break;
    default:
      return (0);
    }
  }
  return (1);
}

/*
 * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]".  *wp is updated
 * to point to just after the separator.  *start points to the first
 * character of the matched text and *end just after the last
 * character of the matched identifier.  In particular *end - *start
 * is the length of the field body, not including leading or trailing
 * whitespace.
 */
static void
next_field_w(const wchar_t **wp, const wchar_t **start,
    const wchar_t **end, wchar_t *sep)
{
  /* Skip leading whitespace to find start of field. */
  while (**wp == L' ' || **wp == L'\t' || **wp == L'\n') {
    (*wp)++;
  }
  *start = *wp;

  /* Scan for the separator. */
  while (**wp != L'\0' && **wp != L',' && **wp != L':' &&
      **wp != L'\n' && **wp != L'#') {
    (*wp)++;
  }
  *sep = **wp;

  /* Locate end of field, trim trailing whitespace if necessary */
  if (*wp == *start) {
    *end = *wp;
  } else {
    *end = *wp - 1;
    while (**end == L' ' || **end == L'\t' || **end == L'\n') {
      (*end)--;
    }
    (*end)++;
  }

  /* Handle in-field comments */
  if (*sep == L'#') {
    while (**wp != L'\0' && **wp != L',' && **wp != L'\n') {
      (*wp)++;
    }
    *sep = **wp;
  }

  /* Adjust scanner location. */
  if (**wp != L'\0')
    (*wp)++;
}

/*
 * Parse an ACL text string.
 *
 * The want_type argument may be one of the following:
 * ARCHIVE_ENTRY_ACL_TYPE_ACCESS - text is a POSIX.1e ACL of type ACCESS
 * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT - text is a POSIX.1e ACL of type DEFAULT
 * ARCHIVE_ENTRY_ACL_TYPE_NFS4 - text is as a NFSv4 ACL
 *
 * POSIX.1e ACL entries prefixed with "default:" are treated as
 * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT unless type is ARCHIVE_ENTRY_ACL_TYPE_NFS4
 */
int
archive_acl_from_text_l(struct archive_acl *acl, const char *text,
    int want_type, struct archive_string_conv *sc)
{
  return archive_acl_from_text_nl(acl, text, strlen(text), want_type, sc);
}

int
archive_acl_from_text_nl(struct archive_acl *acl, const char *text,
    size_t length, int want_type, struct archive_string_conv *sc)
{
  struct {
    const char *start;
    const char *end;
  } field[6], name;

  const char *s, *st, *text_end;
  int numfields, fields, n, r, sol, ret;
  int type, types, tag, permset, id;
  size_t len;
  char sep;

  switch (want_type) {
  case ARCHIVE_ENTRY_ACL_TYPE_POSIX1E:
    want_type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
    __LA_FALLTHROUGH;
  case ARCHIVE_ENTRY_ACL_TYPE_ACCESS:
  case ARCHIVE_ENTRY_ACL_TYPE_DEFAULT:
    numfields = 5;
    break;
  case ARCHIVE_ENTRY_ACL_TYPE_NFS4:
    numfields = 6;
    break;
  default:
    return (ARCHIVE_FATAL);
  }

  ret = ARCHIVE_OK;
  types = 0;
  text_end = (text == NULL) ? text : text + length;

  while (text != NULL && length > 0 && *text != '\0') {
    /*
     * Parse the fields out of the next entry,
     * advance 'text' to start of next entry.
     */
    fields = 0;
    do {
      const char *start, *end;
      next_field(&text, &length, &start, &end, &sep);
      if (fields < numfields) {
        field[fields].start = start;
        field[fields].end = end;
      }
      ++fields;
    } while (sep == ':');

    /* Set remaining fields to blank. */
    for (n = fields; n < numfields; ++n)
      field[n].start = field[n].end = NULL;

    if (field[0].start == NULL || field[0].end == NULL) {
      /* This should never happen */
      return (ARCHIVE_FATAL);
    }

    if (field[0].start == text_end) {
      /*
       * Empty entry: next_field() consumed the rest of the
       * buffer as separators or whitespace, leaving
       * field[0].start one past the end.  'text' is not
       * guaranteed to be NUL terminated, so the byte after it
       * must not be dereferenced.
       */
      ret = ARCHIVE_WARN;
      continue;
    }

    if (*(field[0].start) == '#') {
      /* Comment, skip entry */
      continue;
    }

    n = 0;
    sol = 0;
    id = -1;
    permset = 0;
    name.start = name.end = NULL;

    if (want_type != ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
      /* POSIX.1e ACLs */
      /*
       * Default keyword "default:user::rwx"
       * if found, we have one more field
       *
       * We also support old Solaris extension:
       * "defaultuser::rwx" is the default ACL corresponding
       * to "user::rwx", etc. valid only for first field
       */
      s = field[0].start;
      #ifdef __clang_analyzer__
      assert(s);
      #endif
      len = field[0].end - field[0].start;
      if (*s == 'd' && (len == 1 || (len >= 7
          && memcmp((s + 1), "efault", 6) == 0))) {
        type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
        if (len > 7)
          field[0].start += 7;
        else
          n = 1;
      } else
        type = want_type;

      /* Check for a numeric ID in field n+1 or n+3. */
      if (isint(field[n + 1].start, field[n + 1].end,
          &id) < 0) {
        ret = ARCHIVE_WARN;
        continue;
      }
      /* Field n+3 is optional. */
      if (id == -1 && fields > (n + 3) &&
          isint(field[n + 3].start, field[n + 3].end,
          &id) < 0) {
        ret = ARCHIVE_WARN;
        continue;
      }

      tag = 0;
      s = field[n].start;
      len = field[n].end - field[n].start;

      if (len == 0) {
        ret = ARCHIVE_WARN;
        continue;
      }

      st = s + 1; 

      switch (*s) {
      case 'u':
        if (len == 1 || (len == 4
            && memcmp(st, "ser", 3) == 0))
          tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
        break;
      case 'g':
        if (len == 1 || (len == 5
            && memcmp(st, "roup", 4) == 0))
          tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
        break;
      case 'o':
        if (len == 1 || (len == 5
            && memcmp(st, "ther", 4) == 0))
          tag = ARCHIVE_ENTRY_ACL_OTHER;
        break;
      case 'm':
        if (len == 1 || (len == 4
            && memcmp(st, "ask", 3) == 0))
          tag = ARCHIVE_ENTRY_ACL_MASK;
        break;
      default:
          break;
      }

      switch (tag) {
      case ARCHIVE_ENTRY_ACL_OTHER:
      case ARCHIVE_ENTRY_ACL_MASK:
        if (fields == (n + 2)
            && field[n + 1].start < field[n + 1].end
            && ismode(field[n + 1].start,
            field[n + 1].end, &permset)) {
          /* This is Solaris-style "other:rwx" */
          sol = 1;
        } else if (fields == (n + 3) &&
            field[n + 1].start < field[n + 1].end) {
          /* Invalid mask or other field */
          ret = ARCHIVE_WARN;
          continue;
        }
        break;
      case ARCHIVE_ENTRY_ACL_USER_OBJ:
      case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
        if (id != -1 ||
            field[n + 1].start < field[n + 1].end) {
          name = field[n + 1];
          if (tag == ARCHIVE_ENTRY_ACL_USER_OBJ)
            tag = ARCHIVE_ENTRY_ACL_USER;
          else
            tag = ARCHIVE_ENTRY_ACL_GROUP;
        }
        break;
      default:
        /* Invalid tag, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }

      /*
       * Without "default:" we expect mode in field 3
       * Exception: Solaris other and mask fields
       */
      if (permset == 0 && !ismode(field[n + 2 - sol].start,
          field[n + 2 - sol].end, &permset)) {
        /* Invalid mode, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }
    } else {
      /* NFS4 ACLs */
      s = field[0].start;
      len = field[0].end - field[0].start;
      tag = 0;

      switch (len) {
      case 4:
        if (memcmp(s, "user", 4) == 0)
          tag = ARCHIVE_ENTRY_ACL_USER;
        break;
      case 5:
        if (memcmp(s, "group", 5) == 0)
          tag = ARCHIVE_ENTRY_ACL_GROUP;
        break;
      case 6:
        if (memcmp(s, "owner@", 6) == 0)
          tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
        else if (memcmp(s, "group@", 6) == 0)
          tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
        break;
      case 9:
        if (memcmp(s, "everyone@", 9) == 0)
          tag = ARCHIVE_ENTRY_ACL_EVERYONE;
        break;
      default:
        break;
      }

      if (tag == 0) {
        /* Invalid tag, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      } else if (tag == ARCHIVE_ENTRY_ACL_USER ||
          tag == ARCHIVE_ENTRY_ACL_GROUP) {
        n = 1;
        name = field[1];
        if (isint(name.start, name.end, &id) < 0) {
          ret = ARCHIVE_WARN;
          continue;
        }
      } else
        n = 0;

      if (!is_nfs4_perms(field[1 + n].start,
          field[1 + n].end, &permset)) {
        /* Invalid NFSv4 perms, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }
      if (!is_nfs4_flags(field[2 + n].start,
          field[2 + n].end, &permset)) {
        /* Invalid NFSv4 flags, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }
      s = field[3 + n].start;
      len = field[3 + n].end - field[3 + n].start;
      type = 0;
      if (len == 4) {
        if (memcmp(s, "deny", 4) == 0)
          type = ARCHIVE_ENTRY_ACL_TYPE_DENY;
      } else if (len == 5) {
        if (memcmp(s, "allow", 5) == 0)
          type = ARCHIVE_ENTRY_ACL_TYPE_ALLOW;
        else if (memcmp(s, "audit", 5) == 0)
          type = ARCHIVE_ENTRY_ACL_TYPE_AUDIT;
        else if (memcmp(s, "alarm", 5) == 0)
          type = ARCHIVE_ENTRY_ACL_TYPE_ALARM;
      }
      if (type == 0) {
        /* Invalid entry type, skip entry */
        ret = ARCHIVE_WARN;
        continue;
      }
      if (isint(field[4 + n].start, field[4 + n].end,
          &id) < 0) {
        ret = ARCHIVE_WARN;
        continue;
      }
    }

    /* Add entry to the internal list. */
    r = archive_acl_add_entry_len_l(acl, type, permset,
        tag, id, name.start, name.end - name.start, sc);
    if (r < ARCHIVE_WARN)
      return (r);
    if (r != ARCHIVE_OK)
      ret = ARCHIVE_WARN;
    types |= type;
  }

  /* Reset ACL */
  archive_acl_reset(acl, types);

  return (ret);
}

/*
 * Parse a string to a positive decimal integer.  Returns true if
 * the string is non-empty and consists only of decimal digits,
 * false otherwise.
 */
static int
isint(const char *start, const char *end, int *result)
{
  int n = 0;
  if (start >= end)
    return (0);
  while (start < end) {
    if (*start < '0' || *start > '9')
      return (0);
    if (n > (INT_MAX / 10) ||
        (n == INT_MAX / 10 && (*start - '0') >= INT_MAX % 10)) {
      return (-1);
    } else {
      n *= 10;
      n += *start - '0';
    }
    start++;
  }
  *result = n;
  return (1);
}

/*
 * Parse a string as a mode field.  Returns true if
 * the string is non-empty and consists only of mode characters,
 * false otherwise.
 */
static int
ismode(const char *start, const char *end, int *permset)
{
  const char *p;

  if (start >= end)
    return (0);
  p = start;
  *permset = 0;
  while (p < end) {
    switch (*p++) {
    case 'r': case 'R':
      *permset |= ARCHIVE_ENTRY_ACL_READ;
      break;
    case 'w': case 'W':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE;
      break;
    case 'x': case 'X':
      *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
      break;
    case '-':
      break;
    default:
      return (0);
    }
  }
  return (1);
}

/*
 * Parse a string as a NFS4 ACL permission field.
 * Returns true if the string is non-empty and consists only of NFS4 ACL
 * permission characters, false otherwise
 */
static int
is_nfs4_perms(const char *start, const char *end, int *permset)
{
  const char *p = start;

  while (p < end) {
    switch (*p++) {
    case 'r':
      *permset |= ARCHIVE_ENTRY_ACL_READ_DATA;
      break;
    case 'w':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_DATA;
      break;
    case 'x':
      *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
      break;
    case 'p':
      *permset |= ARCHIVE_ENTRY_ACL_APPEND_DATA;
      break;
    case 'D':
      *permset |= ARCHIVE_ENTRY_ACL_DELETE_CHILD;
      break;
    case 'd':
      *permset |= ARCHIVE_ENTRY_ACL_DELETE;
      break;
    case 'a':
      *permset |= ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES;
      break;
    case 'A':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES;
      break;
    case 'R':
      *permset |= ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS;
      break;
    case 'W':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS;
      break;
    case 'c':
      *permset |= ARCHIVE_ENTRY_ACL_READ_ACL;
      break;
    case 'C':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_ACL;
      break;
    case 'o':
      *permset |= ARCHIVE_ENTRY_ACL_WRITE_OWNER;
      break;
    case 's':
      *permset |= ARCHIVE_ENTRY_ACL_SYNCHRONIZE;
      break;
    case '-':
      break;
    default:
      return(0);
    }
  }
  return (1);
}

/*
 * Parse a string as a NFS4 ACL flags field.
 * Returns true if the string is non-empty and consists only of NFS4 ACL
 * flag characters, false otherwise
 */
static int
is_nfs4_flags(const char *start, const char *end, int *permset)
{
  const char *p = start;

  while (p < end) {
    switch(*p++) {
    case 'f':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT;
      break;
    case 'd':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT;
      break;
    case 'i':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY;
      break;
    case 'n':
      *permset |=
          ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT;
      break;
    case 'S':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS;
      break;
    case 'F':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS;
      break;
    case 'I':
      *permset |= ARCHIVE_ENTRY_ACL_ENTRY_INHERITED;
      break;
    case '-':
      break;
    default:
      return (0);
    }
  }
  return (1);
}

/*
 * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]".  *p is updated
 * to point to just after the separator.  *start points to the first
 * character of the matched text and *end just after the last
 * character of the matched identifier.  In particular *end - *start
 * is the length of the field body, not including leading or trailing
 * whitespace.
 */
static void
next_field(const char **p, size_t *l, const char **start,
    const char **end, char *sep)
{
  /* Skip leading whitespace to find start of field. */
  while (*l > 0 && (**p == ' ' || **p == '\t' || **p == '\n')) {
    (*p)++;
    (*l)--;
  }
  *start = *p;

  /* Locate end of field, trim trailing whitespace if necessary */
  while (*l > 0 && **p != ' ' && **p != '\t' && **p != '\n' && **p != ',' && **p != ':' && **p != '#') {
    (*p)++;
    (*l)--;
  }
  *end = *p;

  /* Scan for the separator. */
  while (*l > 0 && **p != ',' && **p != ':' && **p != '\n' && **p != '#') {
    (*p)++;
    (*l)--;
  }
  if (*l > 0)
    *sep = **p;
  else
    *sep = '\0';

  /* Handle in-field comments */
  if (*sep == '#') {
    while (*l > 0 && **p != ',' && **p != '\n') {
      (*p)++;
      (*l)--;
    }
    if (*l > 0)
      *sep = **p;
    else
      *sep = '\0';
  }

  /* Skip separator. */
  if (*l > 0) {
    (*p)++;
    (*l)--;
  }
}

Coverage Report

Created: 2026-09-14 06:43