contrib/libarchive/libarchive/archive_acl.c

   1 /*-
   2  * Copyright (c) 2003-2010 Tim Kientzle
   3  * Copyright (c) 2016 Martin Matuska
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "archive_platform.h"
  28 __FBSDID("$FreeBSD$");
  29
  30 #ifdef HAVE_ERRNO_H
  31 #include <errno.h>
  32 #endif
  33 #ifdef HAVE_LIMITS_H
  34 #include <limits.h>
  35 #endif
  36 #ifdef HAVE_WCHAR_H
  37 #include <wchar.h>
  38 #endif
  39
  40 #include "archive_acl_private.h"
  41 #include "archive_entry.h"
  42 #include "archive_private.h"
  43
  44 #undef max
  45 #define max(a, b)       ((a)>(b)?(a):(b))
  46
  47 #ifndef HAVE_WMEMCMP
  48 /* Good enough for simple equality testing, but not for sorting. */
  49 #define wmemcmp(a,b,i)  memcmp((a), (b), (i) * sizeof(wchar_t))
  50 #endif
  51
  52 static int      acl_special(struct archive_acl *acl,
  53                     int type, int permset, int tag);
  54 static struct archive_acl_entry *acl_new_entry(struct archive_acl *acl,
  55                     int type, int permset, int tag, int id);
  56 static int      archive_acl_add_entry_len_l(struct archive_acl *acl,
  57                     int type, int permset, int tag, int id, const char *name,
  58                     size_t len, struct archive_string_conv *sc);
  59 static int      archive_acl_text_want_type(struct archive_acl *acl, int flags);
  60 static ssize_t  archive_acl_text_len(struct archive_acl *acl, int want_type,
  61                     int flags, int wide, struct archive *a,
  62                     struct archive_string_conv *sc);
  63 static int      isint_w(const wchar_t *start, const wchar_t *end, int *result);
  64 static int      ismode_w(const wchar_t *start, const wchar_t *end, int *result);
  65 static int      is_nfs4_flags_w(const wchar_t *start, const wchar_t *end,
  66                     int *result);
  67 static int      is_nfs4_perms_w(const wchar_t *start, const wchar_t *end,
  68                     int *result);
  69 static void     next_field_w(const wchar_t **wp, const wchar_t **start,
  70                     const wchar_t **end, wchar_t *sep);
  71 static void     append_entry_w(wchar_t **wp, const wchar_t *prefix, int type,
  72                     int tag, int flags, const wchar_t *wname, int perm, int id);
  73 static void     append_id_w(wchar_t **wp, int id);
  74 static int      isint(const char *start, const char *end, int *result);
  75 static int      ismode(const char *start, const char *end, int *result);
  76 static int      is_nfs4_flags(const char *start, const char *end,
  77                     int *result);
  78 static int      is_nfs4_perms(const char *start, const char *end,
  79                     int *result);
  80 static void     next_field(const char **p, const char **start,
  81                     const char **end, char *sep);
  82 static void     append_entry(char **p, const char *prefix, int type,
  83                     int tag, int flags, const char *name, int perm, int id);
  84 static void     append_id(char **p, int id);
  85
  86 static const struct {
  87         const int perm;
  88         const char c;
  89         const wchar_t wc;
  90 } nfsv4_acl_perm_map[] = {
  91         { ARCHIVE_ENTRY_ACL_READ_DATA | ARCHIVE_ENTRY_ACL_LIST_DIRECTORY, 'r',
  92             L'r' },
  93         { ARCHIVE_ENTRY_ACL_WRITE_DATA | ARCHIVE_ENTRY_ACL_ADD_FILE, 'w',
  94             L'w' },
  95         { ARCHIVE_ENTRY_ACL_EXECUTE, 'x', L'x' },
  96         { ARCHIVE_ENTRY_ACL_APPEND_DATA | ARCHIVE_ENTRY_ACL_ADD_SUBDIRECTORY,
  97             'p', L'p' },
  98         { ARCHIVE_ENTRY_ACL_DELETE, 'd', L'd' },
  99         { ARCHIVE_ENTRY_ACL_DELETE_CHILD, 'D', L'D' },
 100         { ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES, 'a', L'a' },
 101         { ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES, 'A', L'A' },
 102         { ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS, 'R', L'R' },
 103         { ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS, 'W', L'W' },
 104         { ARCHIVE_ENTRY_ACL_READ_ACL, 'c', L'c' },
 105         { ARCHIVE_ENTRY_ACL_WRITE_ACL, 'C', L'C' },
 106         { ARCHIVE_ENTRY_ACL_WRITE_OWNER, 'o', L'o' },
 107         { ARCHIVE_ENTRY_ACL_SYNCHRONIZE, 's', L's' }
 108 };
 109
 110 static const int nfsv4_acl_perm_map_size = (int)(sizeof(nfsv4_acl_perm_map) /
 111     sizeof(nfsv4_acl_perm_map[0]));
 112
 113 static const struct {
 114         const int perm;
 115         const char c;
 116         const wchar_t wc;
 117 } nfsv4_acl_flag_map[] = {
 118         { ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT, 'f', L'f' },
 119         { ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT, 'd', L'd' },
 120         { ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY, 'i', L'i' },
 121         { ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT, 'n', L'n' },
 122         { ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS, 'S', L'S' },
 123         { ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS, 'F', L'F' },
 124         { ARCHIVE_ENTRY_ACL_ENTRY_INHERITED, 'I', L'I' }
 125 };
 126
 127 static const int nfsv4_acl_flag_map_size = (int)(sizeof(nfsv4_acl_flag_map) /
 128     sizeof(nfsv4_acl_flag_map[0]));
 129
 130 void
 131 archive_acl_clear(struct archive_acl *acl)
 132 {
 133         struct archive_acl_entry *ap;
 134
 135         while (acl->acl_head != NULL) {
 136                 ap = acl->acl_head->next;
 137                 archive_mstring_clean(&acl->acl_head->name);
 138                 free(acl->acl_head);
 139                 acl->acl_head = ap;
 140         }
 141         free(acl->acl_text_w);
 142         acl->acl_text_w = NULL;
 143         free(acl->acl_text);
 144         acl->acl_text = NULL;
 145         acl->acl_p = NULL;
 146         acl->acl_types = 0;
 147         acl->acl_state = 0; /* Not counting. */
 148 }
 149
 150 void
 151 archive_acl_copy(struct archive_acl *dest, struct archive_acl *src)
 152 {
 153         struct archive_acl_entry *ap, *ap2;
 154
 155         archive_acl_clear(dest);
 156
 157         dest->mode = src->mode;
 158         ap = src->acl_head;
 159         while (ap != NULL) {
 160                 ap2 = acl_new_entry(dest,
 161                     ap->type, ap->permset, ap->tag, ap->id);
 162                 if (ap2 != NULL)
 163                         archive_mstring_copy(&ap2->name, &ap->name);
 164                 ap = ap->next;
 165         }
 166 }
 167
 168 int
 169 archive_acl_add_entry(struct archive_acl *acl,
 170     int type, int permset, int tag, int id, const char *name)
 171 {
 172         struct archive_acl_entry *ap;
 173
 174         if (acl_special(acl, type, permset, tag) == 0)
 175                 return ARCHIVE_OK;
 176         ap = acl_new_entry(acl, type, permset, tag, id);
 177         if (ap == NULL) {
 178                 /* XXX Error XXX */
 179                 return ARCHIVE_FAILED;
 180         }
 181         if (name != NULL  &&  *name != '\0')
 182                 archive_mstring_copy_mbs(&ap->name, name);
 183         else
 184                 archive_mstring_clean(&ap->name);
 185         return ARCHIVE_OK;
 186 }
 187
 188 int
 189 archive_acl_add_entry_w_len(struct archive_acl *acl,
 190     int type, int permset, int tag, int id, const wchar_t *name, size_t len)
 191 {
 192         struct archive_acl_entry *ap;
 193
 194         if (acl_special(acl, type, permset, tag) == 0)
 195                 return ARCHIVE_OK;
 196         ap = acl_new_entry(acl, type, permset, tag, id);
 197         if (ap == NULL) {
 198                 /* XXX Error XXX */
 199                 return ARCHIVE_FAILED;
 200         }
 201         if (name != NULL  &&  *name != L'\0' && len > 0)
 202                 archive_mstring_copy_wcs_len(&ap->name, name, len);
 203         else
 204                 archive_mstring_clean(&ap->name);
 205         return ARCHIVE_OK;
 206 }
 207
 208 static int
 209 archive_acl_add_entry_len_l(struct archive_acl *acl,
 210     int type, int permset, int tag, int id, const char *name, size_t len,
 211     struct archive_string_conv *sc)
 212 {
 213         struct archive_acl_entry *ap;
 214         int r;
 215
 216         if (acl_special(acl, type, permset, tag) == 0)
 217                 return ARCHIVE_OK;
 218         ap = acl_new_entry(acl, type, permset, tag, id);
 219         if (ap == NULL) {
 220                 /* XXX Error XXX */
 221                 return ARCHIVE_FAILED;
 222         }
 223         if (name != NULL  &&  *name != '\0' && len > 0) {
 224                 r = archive_mstring_copy_mbs_len_l(&ap->name, name, len, sc);
 225         } else {
 226                 r = 0;
 227                 archive_mstring_clean(&ap->name);
 228         }
 229         if (r == 0)
 230                 return (ARCHIVE_OK);
 231         else if (errno == ENOMEM)
 232                 return (ARCHIVE_FATAL);
 233         else
 234                 return (ARCHIVE_WARN);
 235 }
 236
 237 /*
 238  * If this ACL entry is part of the standard POSIX permissions set,
 239  * store the permissions in the stat structure and return zero.
 240  */
 241 static int
 242 acl_special(struct archive_acl *acl, int type, int permset, int tag)
 243 {
 244         if (type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS
 245             && ((permset & ~007) == 0)) {
 246                 switch (tag) {
 247                 case ARCHIVE_ENTRY_ACL_USER_OBJ:
 248                         acl->mode &= ~0700;
 249                         acl->mode |= (permset & 7) << 6;
 250                         return (0);
 251                 case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
 252                         acl->mode &= ~0070;
 253                         acl->mode |= (permset & 7) << 3;
 254                         return (0);
 255                 case ARCHIVE_ENTRY_ACL_OTHER:
 256                         acl->mode &= ~0007;
 257                         acl->mode |= permset & 7;
 258                         return (0);
 259                 }
 260         }
 261         return (1);
 262 }
 263
 264 /*
 265  * Allocate and populate a new ACL entry with everything but the
 266  * name.
 267  */
 268 static struct archive_acl_entry *
 269 acl_new_entry(struct archive_acl *acl,
 270     int type, int permset, int tag, int id)
 271 {
 272         struct archive_acl_entry *ap, *aq;
 273
 274         /* Type argument must be a valid NFS4 or POSIX.1e type.
 275          * The type must agree with anything already set and
 276          * the permset must be compatible. */
 277         if (type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
 278                 if (acl->acl_types & ~ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
 279                         return (NULL);
 280                 }
 281                 if (permset &
 282                     ~(ARCHIVE_ENTRY_ACL_PERMS_NFS4
 283                         | ARCHIVE_ENTRY_ACL_INHERITANCE_NFS4)) {
 284                         return (NULL);
 285                 }
 286         } else  if (type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) {
 287                 if (acl->acl_types & ~ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) {
 288                         return (NULL);
 289                 }
 290                 if (permset & ~ARCHIVE_ENTRY_ACL_PERMS_POSIX1E) {
 291                         return (NULL);
 292                 }
 293         } else {
 294                 return (NULL);
 295         }
 296
 297         /* Verify the tag is valid and compatible with NFS4 or POSIX.1e. */
 298         switch (tag) {
 299         case ARCHIVE_ENTRY_ACL_USER:
 300         case ARCHIVE_ENTRY_ACL_USER_OBJ:
 301         case ARCHIVE_ENTRY_ACL_GROUP:
 302         case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
 303                 /* Tags valid in both NFS4 and POSIX.1e */
 304                 break;
 305         case ARCHIVE_ENTRY_ACL_MASK:
 306         case ARCHIVE_ENTRY_ACL_OTHER:
 307                 /* Tags valid only in POSIX.1e. */
 308                 if (type & ~ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) {
 309                         return (NULL);
 310                 }
 311                 break;
 312         case ARCHIVE_ENTRY_ACL_EVERYONE:
 313                 /* Tags valid only in NFS4. */
 314                 if (type & ~ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
 315                         return (NULL);
 316                 }
 317                 break;
 318         default:
 319                 /* No other values are valid. */
 320                 return (NULL);
 321         }
 322
 323         free(acl->acl_text_w);
 324         acl->acl_text_w = NULL;
 325         free(acl->acl_text);
 326         acl->acl_text = NULL;
 327
 328         /*
 329          * If there's a matching entry already in the list, overwrite it.
 330          * NFSv4 entries may be repeated and are not overwritten.
 331          *
 332          * TODO: compare names of no id is provided (needs more rework)
 333          */
 334         ap = acl->acl_head;
 335         aq = NULL;
 336         while (ap != NULL) {
 337                 if (((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) == 0) &&
 338                     ap->type == type && ap->tag == tag && ap->id == id) {
 339                         if (id != -1 || (tag != ARCHIVE_ENTRY_ACL_USER &&
 340                             tag != ARCHIVE_ENTRY_ACL_GROUP)) {
 341                                 ap->permset = permset;
 342                                 return (ap);
 343                         }
 344                 }
 345                 aq = ap;
 346                 ap = ap->next;
 347         }
 348
 349         /* Add a new entry to the end of the list. */
 350         ap = (struct archive_acl_entry *)calloc(1, sizeof(*ap));
 351         if (ap == NULL)
 352                 return (NULL);
 353         if (aq == NULL)
 354                 acl->acl_head = ap;
 355         else
 356                 aq->next = ap;
 357         ap->type = type;
 358         ap->tag = tag;
 359         ap->id = id;
 360         ap->permset = permset;
 361         acl->acl_types |= type;
 362         return (ap);
 363 }
 364
 365 /*
 366  * Return a count of entries matching "want_type".
 367  */
 368 int
 369 archive_acl_count(struct archive_acl *acl, int want_type)
 370 {
 371         int count;
 372         struct archive_acl_entry *ap;
 373
 374         count = 0;
 375         ap = acl->acl_head;
 376         while (ap != NULL) {
 377                 if ((ap->type & want_type) != 0)
 378                         count++;
 379                 ap = ap->next;
 380         }
 381
 382         if (count > 0 && ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0))
 383                 count += 3;
 384         return (count);
 385 }
 386
 387 /*
 388  * Return a bitmask of stored ACL types in an ACL list
 389  */
 390 int
 391 archive_acl_types(struct archive_acl *acl)
 392 {
 393         return (acl->acl_types);
 394 }
 395
 396 /*
 397  * Prepare for reading entries from the ACL data.  Returns a count
 398  * of entries matching "want_type", or zero if there are no
 399  * non-extended ACL entries of that type.
 400  */
 401 int
 402 archive_acl_reset(struct archive_acl *acl, int want_type)
 403 {
 404         int count, cutoff;
 405
 406         count = archive_acl_count(acl, want_type);
 407
 408         /*
 409          * If the only entries are the three standard ones,
 410          * then don't return any ACL data.  (In this case,
 411          * client can just use chmod(2) to set permissions.)
 412          */
 413         if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)
 414                 cutoff = 3;
 415         else
 416                 cutoff = 0;
 417
 418         if (count > cutoff)
 419                 acl->acl_state = ARCHIVE_ENTRY_ACL_USER_OBJ;
 420         else
 421                 acl->acl_state = 0;
 422         acl->acl_p = acl->acl_head;
 423         return (count);
 424 }
 425
 426
 427 /*
 428  * Return the next ACL entry in the list.  Fake entries for the
 429  * standard permissions and include them in the returned list.
 430  */
 431 int
 432 archive_acl_next(struct archive *a, struct archive_acl *acl, int want_type,
 433     int *type, int *permset, int *tag, int *id, const char **name)
 434 {
 435         *name = NULL;
 436         *id = -1;
 437
 438         /*
 439          * The acl_state is either zero (no entries available), -1
 440          * (reading from list), or an entry type (retrieve that type
 441          * from ae_stat.aest_mode).
 442          */
 443         if (acl->acl_state == 0)
 444                 return (ARCHIVE_WARN);
 445
 446         /* The first three access entries are special. */
 447         if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
 448                 switch (acl->acl_state) {
 449                 case ARCHIVE_ENTRY_ACL_USER_OBJ:
 450                         *permset = (acl->mode >> 6) & 7;
 451                         *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
 452                         *tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
 453                         acl->acl_state = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
 454                         return (ARCHIVE_OK);
 455                 case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
 456                         *permset = (acl->mode >> 3) & 7;
 457                         *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
 458                         *tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
 459                         acl->acl_state = ARCHIVE_ENTRY_ACL_OTHER;
 460                         return (ARCHIVE_OK);
 461                 case ARCHIVE_ENTRY_ACL_OTHER:
 462                         *permset = acl->mode & 7;
 463                         *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
 464                         *tag = ARCHIVE_ENTRY_ACL_OTHER;
 465                         acl->acl_state = -1;
 466                         acl->acl_p = acl->acl_head;
 467                         return (ARCHIVE_OK);
 468                 default:
 469                         break;
 470                 }
 471         }
 472
 473         while (acl->acl_p != NULL && (acl->acl_p->type & want_type) == 0)
 474                 acl->acl_p = acl->acl_p->next;
 475         if (acl->acl_p == NULL) {
 476                 acl->acl_state = 0;
 477                 *type = 0;
 478                 *permset = 0;
 479                 *tag = 0;
 480                 *id = -1;
 481                 *name = NULL;
 482                 return (ARCHIVE_EOF); /* End of ACL entries. */
 483         }
 484         *type = acl->acl_p->type;
 485         *permset = acl->acl_p->permset;
 486         *tag = acl->acl_p->tag;
 487         *id = acl->acl_p->id;
 488         if (archive_mstring_get_mbs(a, &acl->acl_p->name, name) != 0) {
 489                 if (errno == ENOMEM)
 490                         return (ARCHIVE_FATAL);
 491                 *name = NULL;
 492         }
 493         acl->acl_p = acl->acl_p->next;
 494         return (ARCHIVE_OK);
 495 }
 496
 497 /*
 498  * Determine what type of ACL do we want
 499  */
 500 static int
 501 archive_acl_text_want_type(struct archive_acl *acl, int flags)
 502 {
 503         int want_type;
 504
 505         /* Check if ACL is NFSv4 */
 506         if ((acl->acl_types & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
 507                 /* NFSv4 should never mix with POSIX.1e */
 508                 if ((acl->acl_types & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0)
 509                         return (0);
 510                 else
 511                         return (ARCHIVE_ENTRY_ACL_TYPE_NFS4);
 512         }
 513
 514         /* Now deal with POSIX.1e ACLs */
 515
 516         want_type = 0;
 517         if ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)
 518                 want_type |= ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
 519         if ((flags & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0)
 520                 want_type |= ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
 521
 522         /* By default we want both access and default ACLs */
 523         if (want_type == 0)
 524                 return (ARCHIVE_ENTRY_ACL_TYPE_POSIX1E);
 525
 526         return (want_type);
 527 }
 528
 529 /*
 530  * Calculate ACL text string length
 531  */
 532 static ssize_t
 533 archive_acl_text_len(struct archive_acl *acl, int want_type, int flags,
 534     int wide, struct archive *a, struct archive_string_conv *sc) {
 535         struct archive_acl_entry *ap;
 536         const char *name;
 537         const wchar_t *wname;
 538         int count, idlen, tmp, r;
 539         ssize_t length;
 540         size_t len;
 541
 542         count = 0;
 543         length = 0;
 544         for (ap = acl->acl_head; ap != NULL; ap = ap->next) {
 545                 if ((ap->type & want_type) == 0)
 546                         continue;
 547                 /*
 548                  * Filemode-mapping ACL entries are stored exclusively in
 549                  * ap->mode so they should not be in the list
 550                  */
 551                 if ((ap->type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS)
 552                     && (ap->tag == ARCHIVE_ENTRY_ACL_USER_OBJ
 553                     || ap->tag == ARCHIVE_ENTRY_ACL_GROUP_OBJ
 554                     || ap->tag == ARCHIVE_ENTRY_ACL_OTHER))
 555                         continue;
 556                 count++;
 557                 if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0
 558                     && (ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0)
 559                         length += 8; /* "default:" */
 560                 switch (ap->tag) {
 561                 case ARCHIVE_ENTRY_ACL_USER_OBJ:
 562                         if (want_type == ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
 563                                 length += 6; /* "owner@" */
 564                                 break;
 565                         }
 566                         /* FALLTHROUGH */
 567                 case ARCHIVE_ENTRY_ACL_USER:
 568                 case ARCHIVE_ENTRY_ACL_MASK:
 569                         length += 4; /* "user", "mask" */
 570                         break;
 571                 case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
 572                         if (want_type == ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
 573                                 length += 6; /* "group@" */
 574                                 break;
 575                         }
 576                         /* FALLTHROUGH */
 577                 case ARCHIVE_ENTRY_ACL_GROUP:
 578                 case ARCHIVE_ENTRY_ACL_OTHER:
 579                         length += 5; /* "group", "other" */
 580                         break;
 581                 case ARCHIVE_ENTRY_ACL_EVERYONE:
 582                         length += 9; /* "everyone@" */
 583                         break;
 584                 }
 585                 length += 1; /* colon after tag */
 586                 if (ap->tag == ARCHIVE_ENTRY_ACL_USER ||
 587                     ap->tag == ARCHIVE_ENTRY_ACL_GROUP) {
 588                         if (wide) {
 589                                 r = archive_mstring_get_wcs(a, &ap->name,
 590                                     &wname);
 591                                 if (r == 0 && wname != NULL)
 592                                         length += wcslen(wname);
 593                                 else if (r < 0 && errno == ENOMEM)
 594                                         return (0);
 595                                 else
 596                                         length += sizeof(uid_t) * 3 + 1;
 597                         } else {
 598                                 r = archive_mstring_get_mbs_l(a, &ap->name, &name,
 599                                     &len, sc);
 600                                 if (r != 0)
 601                                         return (0);
 602                                 if (len > 0 && name != NULL)
 603                                         length += len;
 604                                 else
 605                                         length += sizeof(uid_t) * 3 + 1;
 606                         }
 607                         length += 1; /* colon after user or group name */
 608                 } else if (want_type != ARCHIVE_ENTRY_ACL_TYPE_NFS4)
 609                         length += 1; /* 2nd colon empty user,group or other */
 610
 611                 if (((flags & ARCHIVE_ENTRY_ACL_STYLE_SOLARIS) != 0)
 612                     && ((want_type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0)
 613                     && (ap->tag == ARCHIVE_ENTRY_ACL_OTHER
 614                     || ap->tag == ARCHIVE_ENTRY_ACL_MASK)) {
 615                         /* Solaris has no colon after other: and mask: */
 616                         length = length - 1;
 617                 }
 618
 619                 if (want_type == ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
 620                         /* rwxpdDaARWcCos:fdinSFI:deny */
 621                         length += 27;
 622                         if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_DENY) == 0)
 623                                 length += 1; /* allow, alarm, audit */
 624                 } else
 625                         length += 3; /* rwx */
 626
 627                 if ((ap->tag == ARCHIVE_ENTRY_ACL_USER ||
 628                     ap->tag == ARCHIVE_ENTRY_ACL_GROUP) &&
 629                     (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID) != 0) {
 630                         length += 1; /* colon */
 631                         /* ID digit count */
 632                         idlen = 1;
 633                         tmp = ap->id;
 634                         while (tmp > 9) {
 635                                 tmp = tmp / 10;
 636                                 idlen++;
 637                         }
 638                         length += idlen;
 639                 }
 640                 length ++; /* entry separator */
 641         }
 642
 643         /* Add filemode-mapping access entries to the length */
 644         if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
 645                 if ((flags & ARCHIVE_ENTRY_ACL_STYLE_SOLARIS) != 0) {
 646                         /* "user::rwx\ngroup::rwx\nother:rwx\n" */
 647                         length += 31;
 648                 } else {
 649                         /* "user::rwx\ngroup::rwx\nother::rwx\n" */
 650                         length += 32;
 651                 }
 652         } else if (count == 0)
 653                 return (0);
 654
 655         /* The terminating character is included in count */
 656         return (length);
 657 }
 658
 659 /*
 660  * Generate a wide text version of the ACL. The flags parameter controls
 661  * the type and style of the generated ACL.
 662  */
 663 wchar_t *
 664 archive_acl_to_text_w(struct archive_acl *acl, ssize_t *text_len, int flags,
 665     struct archive *a)
 666 {
 667         int count;
 668         ssize_t length;
 669         size_t len;
 670         const wchar_t *wname;
 671         const wchar_t *prefix;
 672         wchar_t separator;
 673         struct archive_acl_entry *ap;
 674         int id, r, want_type;
 675         wchar_t *wp, *ws;
 676
 677         want_type = archive_acl_text_want_type(acl, flags);
 678
 679         /* Both NFSv4 and POSIX.1 types found */
 680         if (want_type == 0)
 681                 return (NULL);
 682
 683         if (want_type == ARCHIVE_ENTRY_ACL_TYPE_POSIX1E)
 684                 flags |= ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT;
 685
 686         length = archive_acl_text_len(acl, want_type, flags, 1, a, NULL);
 687
 688         if (length == 0)
 689                 return (NULL);
 690
 691         if (flags & ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA)
 692                 separator = L',';
 693         else
 694                 separator = L'\n';
 695
 696         /* Now, allocate the string and actually populate it. */
 697         wp = ws = (wchar_t *)malloc(length * sizeof(wchar_t));
 698         if (wp == NULL) {
 699                 if (errno == ENOMEM)
 700                         __archive_errx(1, "No memory");
 701                 return (NULL);
 702         }
 703         count = 0;
 704
 705         if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
 706                 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 707                     ARCHIVE_ENTRY_ACL_USER_OBJ, flags, NULL,
 708                     acl->mode & 0700, -1);
 709                 *wp++ = separator;
 710                 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 711                     ARCHIVE_ENTRY_ACL_GROUP_OBJ, flags, NULL,
 712                     acl->mode & 0070, -1);
 713                 *wp++ = separator;
 714                 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 715                     ARCHIVE_ENTRY_ACL_OTHER, flags, NULL,
 716                     acl->mode & 0007, -1);
 717                 count += 3;
 718         }
 719
 720         for (ap = acl->acl_head; ap != NULL; ap = ap->next) {
 721                 if ((ap->type & want_type) == 0)
 722                         continue;
 723                 /*
 724                  * Filemode-mapping ACL entries are stored exclusively in
 725                  * ap->mode so they should not be in the list
 726                  */
 727                 if ((ap->type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS)
 728                     && (ap->tag == ARCHIVE_ENTRY_ACL_USER_OBJ
 729                     || ap->tag == ARCHIVE_ENTRY_ACL_GROUP_OBJ
 730                     || ap->tag == ARCHIVE_ENTRY_ACL_OTHER))
 731                         continue;
 732                 if (ap->type == ARCHIVE_ENTRY_ACL_TYPE_DEFAULT &&
 733                     (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) != 0)
 734                         prefix = L"default:";
 735                 else
 736                         prefix = NULL;
 737                 r = archive_mstring_get_wcs(a, &ap->name, &wname);
 738                 if (r == 0) {
 739                         if (count > 0)
 740                                 *wp++ = separator;
 741                         if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)
 742                                 id = ap->id;
 743                         else
 744                                 id = -1;
 745                         append_entry_w(&wp, prefix, ap->type, ap->tag, flags,
 746                             wname, ap->permset, id);
 747                         count++;
 748                 } else if (r < 0 && errno == ENOMEM) {
 749                         free(ws);
 750                         return (NULL);
 751                 }
 752         }
 753
 754         /* Add terminating character */
 755         *wp++ = L'\0';
 756
 757         len = wcslen(ws);
 758
 759         if ((ssize_t)len > (length - 1))
 760                 __archive_errx(1, "Buffer overrun");
 761
 762         if (text_len != NULL)
 763                 *text_len = len;
 764
 765         return (ws);
 766 }
 767
 768 static void
 769 append_id_w(wchar_t **wp, int id)
 770 {
 771         if (id < 0)
 772                 id = 0;
 773         if (id > 9)
 774                 append_id_w(wp, id / 10);
 775         *(*wp)++ = L"0123456789"[id % 10];
 776 }
 777
 778 static void
 779 append_entry_w(wchar_t **wp, const wchar_t *prefix, int type,
 780     int tag, int flags, const wchar_t *wname, int perm, int id)
 781 {
 782         int i;
 783
 784         if (prefix != NULL) {
 785                 wcscpy(*wp, prefix);
 786                 *wp += wcslen(*wp);
 787         }
 788         switch (tag) {
 789         case ARCHIVE_ENTRY_ACL_USER_OBJ:
 790                 wname = NULL;
 791                 id = -1;
 792                 if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
 793                         wcscpy(*wp, L"owner@");
 794                         break;
 795                 }
 796                 /* FALLTHROUGH */
 797         case ARCHIVE_ENTRY_ACL_USER:
 798                 wcscpy(*wp, L"user");
 799                 break;
 800         case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
 801                 wname = NULL;
 802                 id = -1;
 803                 if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
 804                         wcscpy(*wp, L"group@");
 805                         break;
 806                 }
 807                 /* FALLTHROUGH */
 808         case ARCHIVE_ENTRY_ACL_GROUP:
 809                 wcscpy(*wp, L"group");
 810                 break;
 811         case ARCHIVE_ENTRY_ACL_MASK:
 812                 wcscpy(*wp, L"mask");
 813                 wname = NULL;
 814                 id = -1;
 815                 break;
 816         case ARCHIVE_ENTRY_ACL_OTHER:
 817                 wcscpy(*wp, L"other");
 818                 wname = NULL;
 819                 id = -1;
 820                 break;
 821         case ARCHIVE_ENTRY_ACL_EVERYONE:
 822                 wcscpy(*wp, L"everyone@");
 823                 wname = NULL;
 824                 id = -1;
 825                 break;
 826         }
 827         *wp += wcslen(*wp);
 828         *(*wp)++ = L':';
 829         if (((type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0) ||
 830             tag == ARCHIVE_ENTRY_ACL_USER ||
 831             tag == ARCHIVE_ENTRY_ACL_GROUP) {
 832                 if (wname != NULL) {
 833                         wcscpy(*wp, wname);
 834                         *wp += wcslen(*wp);
 835                 } else if (tag == ARCHIVE_ENTRY_ACL_USER
 836                     || tag == ARCHIVE_ENTRY_ACL_GROUP) {
 837                         append_id_w(wp, id);
 838                         if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) == 0)
 839                                 id = -1;
 840                 }
 841                 /* Solaris style has no second colon after other and mask */
 842                 if (((flags & ARCHIVE_ENTRY_ACL_STYLE_SOLARIS) == 0)
 843                     || (tag != ARCHIVE_ENTRY_ACL_OTHER
 844                     && tag != ARCHIVE_ENTRY_ACL_MASK))
 845                         *(*wp)++ = L':';
 846         }
 847         if ((type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0) {
 848                 /* POSIX.1e ACL perms */
 849                 *(*wp)++ = (perm & 0444) ? L'r' : L'-';
 850                 *(*wp)++ = (perm & 0222) ? L'w' : L'-';
 851                 *(*wp)++ = (perm & 0111) ? L'x' : L'-';
 852         } else {
 853                 /* NFSv4 ACL perms */
 854                 for (i = 0; i < nfsv4_acl_perm_map_size; i++) {
 855                         if (perm & nfsv4_acl_perm_map[i].perm)
 856                                 *(*wp)++ = nfsv4_acl_perm_map[i].wc;
 857                         else if ((flags & ARCHIVE_ENTRY_ACL_STYLE_COMPACT) == 0)
 858                                 *(*wp)++ = L'-';
 859                 }
 860                 *(*wp)++ = L':';
 861                 for (i = 0; i < nfsv4_acl_flag_map_size; i++) {
 862                         if (perm & nfsv4_acl_flag_map[i].perm)
 863                                 *(*wp)++ = nfsv4_acl_flag_map[i].wc;
 864                         else if ((flags & ARCHIVE_ENTRY_ACL_STYLE_COMPACT) == 0)
 865                                 *(*wp)++ = L'-';
 866                 }
 867                 *(*wp)++ = L':';
 868                 switch (type) {
 869                 case ARCHIVE_ENTRY_ACL_TYPE_ALLOW:
 870                         wcscpy(*wp, L"allow");
 871                         break;
 872                 case ARCHIVE_ENTRY_ACL_TYPE_DENY:
 873                         wcscpy(*wp, L"deny");
 874                         break;
 875                 case ARCHIVE_ENTRY_ACL_TYPE_AUDIT:
 876                         wcscpy(*wp, L"audit");
 877                         break;
 878                 case ARCHIVE_ENTRY_ACL_TYPE_ALARM:
 879                         wcscpy(*wp, L"alarm");
 880                         break;
 881                 default:
 882                         break;
 883                 }
 884                 *wp += wcslen(*wp);
 885         }
 886         if (id != -1) {
 887                 *(*wp)++ = L':';
 888                 append_id_w(wp, id);
 889         }
 890 }
 891
 892 /*
 893  * Generate a text version of the ACL. The flags parameter controls
 894  * the type and style of the generated ACL.
 895  */
 896 char *
 897 archive_acl_to_text_l(struct archive_acl *acl, ssize_t *text_len, int flags,
 898     struct archive_string_conv *sc)
 899 {
 900         int count;
 901         ssize_t length;
 902         size_t len;
 903         const char *name;
 904         const char *prefix;
 905         char separator;
 906         struct archive_acl_entry *ap;
 907         int id, r, want_type;
 908         char *p, *s;
 909
 910         want_type = archive_acl_text_want_type(acl, flags);
 911
 912         /* Both NFSv4 and POSIX.1 types found */
 913         if (want_type == 0)
 914                 return (NULL);
 915
 916         if (want_type == ARCHIVE_ENTRY_ACL_TYPE_POSIX1E)
 917                 flags |= ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT;
 918
 919         length = archive_acl_text_len(acl, want_type, flags, 0, NULL, sc);
 920
 921         if (length == 0)
 922                 return (NULL);
 923
 924         if (flags & ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA)
 925                 separator = ',';
 926         else
 927                 separator = '\n';
 928
 929         /* Now, allocate the string and actually populate it. */
 930         p = s = (char *)malloc(length * sizeof(char));
 931         if (p == NULL) {
 932                 if (errno == ENOMEM)
 933                         __archive_errx(1, "No memory");
 934                 return (NULL);
 935         }
 936         count = 0;
 937
 938         if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
 939                 append_entry(&p, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 940                     ARCHIVE_ENTRY_ACL_USER_OBJ, flags, NULL,
 941                     acl->mode & 0700, -1);
 942                 *p++ = separator;
 943                 append_entry(&p, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 944                     ARCHIVE_ENTRY_ACL_GROUP_OBJ, flags, NULL,
 945                     acl->mode & 0070, -1);
 946                 *p++ = separator;
 947                 append_entry(&p, NULL, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 948                     ARCHIVE_ENTRY_ACL_OTHER, flags, NULL,
 949                     acl->mode & 0007, -1);
 950                 count += 3;
 951         }
 952
 953         for (ap = acl->acl_head; ap != NULL; ap = ap->next) {
 954                 if ((ap->type & want_type) == 0)
 955                         continue;
 956                 /*
 957                  * Filemode-mapping ACL entries are stored exclusively in
 958                  * ap->mode so they should not be in the list
 959                  */
 960                 if ((ap->type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS)
 961                     && (ap->tag == ARCHIVE_ENTRY_ACL_USER_OBJ
 962                     || ap->tag == ARCHIVE_ENTRY_ACL_GROUP_OBJ
 963                     || ap->tag == ARCHIVE_ENTRY_ACL_OTHER))
 964                         continue;
 965                 if (ap->type == ARCHIVE_ENTRY_ACL_TYPE_DEFAULT &&
 966                     (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) != 0)
 967                         prefix = "default:";
 968                 else
 969                         prefix = NULL;
 970                 r = archive_mstring_get_mbs_l(
 971                     NULL, &ap->name, &name, &len, sc);
 972                 if (r != 0) {
 973                         free(s);
 974                         return (NULL);
 975                 }
 976                 if (count > 0)
 977                         *p++ = separator;
 978                 if (name == NULL ||
 979                     (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)) {
 980                         id = ap->id;
 981                 } else {
 982                         id = -1;
 983                 }
 984                 append_entry(&p, prefix, ap->type, ap->tag, flags, name,
 985                     ap->permset, id);
 986                 count++;
 987         }
 988
 989         /* Add terminating character */
 990         *p++ = '\0';
 991
 992         len = strlen(s);
 993
 994         if ((ssize_t)len > (length - 1))
 995                 __archive_errx(1, "Buffer overrun");
 996
 997         if (text_len != NULL)
 998                 *text_len = len;
 999
1000         return (s);
1001 }
1002
1003 static void
1004 append_id(char **p, int id)
1005 {
1006         if (id < 0)
1007                 id = 0;
1008         if (id > 9)
1009                 append_id(p, id / 10);
1010         *(*p)++ = "0123456789"[id % 10];
1011 }
1012
1013 static void
1014 append_entry(char **p, const char *prefix, int type,
1015     int tag, int flags, const char *name, int perm, int id)
1016 {
1017         int i;
1018
1019         if (prefix != NULL) {
1020                 strcpy(*p, prefix);
1021                 *p += strlen(*p);
1022         }
1023         switch (tag) {
1024         case ARCHIVE_ENTRY_ACL_USER_OBJ:
1025                 name = NULL;
1026                 id = -1;
1027                 if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
1028                         strcpy(*p, "owner@");
1029                         break;
1030                 }
1031                 /* FALLTHROUGH */
1032         case ARCHIVE_ENTRY_ACL_USER:
1033                 strcpy(*p, "user");
1034                 break;
1035         case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
1036                 name = NULL;
1037                 id = -1;
1038                 if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) != 0) {
1039                         strcpy(*p, "group@");
1040                         break;
1041                 }
1042                 /* FALLTHROUGH */
1043         case ARCHIVE_ENTRY_ACL_GROUP:
1044                 strcpy(*p, "group");
1045                 break;
1046         case ARCHIVE_ENTRY_ACL_MASK:
1047                 strcpy(*p, "mask");
1048                 name = NULL;
1049                 id = -1;
1050                 break;
1051         case ARCHIVE_ENTRY_ACL_OTHER:
1052                 strcpy(*p, "other");
1053                 name = NULL;
1054                 id = -1;
1055                 break;
1056         case ARCHIVE_ENTRY_ACL_EVERYONE:
1057                 strcpy(*p, "everyone@");
1058                 name = NULL;
1059                 id = -1;
1060                 break;
1061         }
1062         *p += strlen(*p);
1063         *(*p)++ = ':';
1064         if (((type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0) ||
1065             tag == ARCHIVE_ENTRY_ACL_USER ||
1066             tag == ARCHIVE_ENTRY_ACL_GROUP) {
1067                 if (name != NULL) {
1068                         strcpy(*p, name);
1069                         *p += strlen(*p);
1070                 } else if (tag == ARCHIVE_ENTRY_ACL_USER
1071                     || tag == ARCHIVE_ENTRY_ACL_GROUP) {
1072                         append_id(p, id);
1073                         if ((type & ARCHIVE_ENTRY_ACL_TYPE_NFS4) == 0)
1074                                 id = -1;
1075                 }
1076                 /* Solaris style has no second colon after other and mask */
1077                 if (((flags & ARCHIVE_ENTRY_ACL_STYLE_SOLARIS) == 0)
1078                     || (tag != ARCHIVE_ENTRY_ACL_OTHER
1079                     && tag != ARCHIVE_ENTRY_ACL_MASK))
1080                         *(*p)++ = ':';
1081         }
1082         if ((type & ARCHIVE_ENTRY_ACL_TYPE_POSIX1E) != 0) {
1083                 /* POSIX.1e ACL perms */
1084                 *(*p)++ = (perm & 0444) ? 'r' : '-';
1085                 *(*p)++ = (perm & 0222) ? 'w' : '-';
1086                 *(*p)++ = (perm & 0111) ? 'x' : '-';
1087         } else {
1088                 /* NFSv4 ACL perms */
1089                 for (i = 0; i < nfsv4_acl_perm_map_size; i++) {
1090                         if (perm & nfsv4_acl_perm_map[i].perm)
1091                                 *(*p)++ = nfsv4_acl_perm_map[i].c;
1092                         else if ((flags & ARCHIVE_ENTRY_ACL_STYLE_COMPACT) == 0)
1093                                 *(*p)++ = '-';
1094                 }
1095                 *(*p)++ = ':';
1096                 for (i = 0; i < nfsv4_acl_flag_map_size; i++) {
1097                         if (perm & nfsv4_acl_flag_map[i].perm)
1098                                 *(*p)++ = nfsv4_acl_flag_map[i].c;
1099                         else if ((flags & ARCHIVE_ENTRY_ACL_STYLE_COMPACT) == 0)
1100                                 *(*p)++ = '-';
1101                 }
1102                 *(*p)++ = ':';
1103                 switch (type) {
1104                 case ARCHIVE_ENTRY_ACL_TYPE_ALLOW:
1105                         strcpy(*p, "allow");
1106                         break;
1107                 case ARCHIVE_ENTRY_ACL_TYPE_DENY:
1108                         strcpy(*p, "deny");
1109                         break;
1110                 case ARCHIVE_ENTRY_ACL_TYPE_AUDIT:
1111                         strcpy(*p, "audit");
1112                         break;
1113                 case ARCHIVE_ENTRY_ACL_TYPE_ALARM:
1114                         strcpy(*p, "alarm");
1115                         break;
1116                 }
1117                 *p += strlen(*p);
1118         }
1119         if (id != -1) {
1120                 *(*p)++ = ':';
1121                 append_id(p, id);
1122         }
1123 }
1124
1125 /*
1126  * Parse a wide ACL text string.
1127  *
1128  * The want_type argument may be one of the following:
1129  * ARCHIVE_ENTRY_ACL_TYPE_ACCESS - text is a POSIX.1e ACL of type ACCESS
1130  * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT - text is a POSIX.1e ACL of type DEFAULT
1131  * ARCHIVE_ENTRY_ACL_TYPE_NFS4 - text is as a NFSv4 ACL
1132  *
1133  * POSIX.1e ACL entries prefixed with "default:" are treated as
1134  * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT unless type is ARCHIVE_ENTRY_ACL_TYPE_NFS4
1135  */
1136 int
1137 archive_acl_from_text_w(struct archive_acl *acl, const wchar_t *text,
1138     int want_type)
1139 {
1140         struct {
1141                 const wchar_t *start;
1142                 const wchar_t *end;
1143         } field[6], name;
1144
1145         const wchar_t *s, *st;
1146
1147         int numfields, fields, n, r, sol, ret;
1148         int type, types, tag, permset, id;
1149         size_t len;
1150         wchar_t sep;
1151
1152         ret = ARCHIVE_OK;
1153         types = 0;
1154
1155         switch (want_type) {
1156         case ARCHIVE_ENTRY_ACL_TYPE_POSIX1E:
1157                 want_type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
1158                 __LA_FALLTHROUGH;
1159         case ARCHIVE_ENTRY_ACL_TYPE_ACCESS:
1160         case ARCHIVE_ENTRY_ACL_TYPE_DEFAULT:
1161                 numfields = 5;
1162                 break;
1163         case ARCHIVE_ENTRY_ACL_TYPE_NFS4:
1164                 numfields = 6;
1165                 break;
1166         default:
1167                 return (ARCHIVE_FATAL);
1168         }
1169
1170         while (text != NULL && *text != L'\0') {
1171                 /*
1172                  * Parse the fields out of the next entry,
1173                  * advance 'text' to start of next entry.
1174                  */
1175                 fields = 0;
1176                 do {
1177                         const wchar_t *start, *end;
1178                         next_field_w(&text, &start, &end, &sep);
1179                         if (fields < numfields) {
1180                                 field[fields].start = start;
1181                                 field[fields].end = end;
1182                         }
1183                         ++fields;
1184                 } while (sep == L':');
1185
1186                 /* Set remaining fields to blank. */
1187                 for (n = fields; n < numfields; ++n)
1188                         field[n].start = field[n].end = NULL;
1189
1190                 if (field[0].start != NULL && *(field[0].start) == L'#') {
1191                         /* Comment, skip entry */
1192                         continue;
1193                 }
1194
1195                 n = 0;
1196                 sol = 0;
1197                 id = -1;
1198                 permset = 0;
1199                 name.start = name.end = NULL;
1200
1201                 if (want_type != ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
1202                         /* POSIX.1e ACLs */
1203                         /*
1204                          * Default keyword "default:user::rwx"
1205                          * if found, we have one more field
1206                          *
1207                          * We also support old Solaris extension:
1208                          * "defaultuser::rwx" is the default ACL corresponding
1209                          * to "user::rwx", etc. valid only for first field
1210                          */
1211                         s = field[0].start;
1212                         len = field[0].end - field[0].start;
1213                         if (*s == L'd' && (len == 1 || (len >= 7
1214                             && wmemcmp((s + 1), L"efault", 6) == 0))) {
1215                                 type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
1216                                 if (len > 7)
1217                                         field[0].start += 7;
1218                                 else
1219                                         n = 1;
1220                         } else
1221                                 type = want_type;
1222
1223                         /* Check for a numeric ID in field n+1 or n+3. */
1224                         isint_w(field[n + 1].start, field[n + 1].end, &id);
1225                         /* Field n+3 is optional. */
1226                         if (id == -1 && fields > n+3)
1227                                 isint_w(field[n + 3].start, field[n + 3].end,
1228                                     &id);
1229
1230                         tag = 0;
1231                         s = field[n].start;
1232                         st = field[n].start + 1;
1233                         len = field[n].end - field[n].start;
1234
1235                         switch (*s) {
1236                         case L'u':
1237                                 if (len == 1 || (len == 4
1238                                     && wmemcmp(st, L"ser", 3) == 0))
1239                                         tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
1240                                 break;
1241                         case L'g':
1242                                 if (len == 1 || (len == 5
1243                                     && wmemcmp(st, L"roup", 4) == 0))
1244                                         tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
1245                                 break;
1246                         case L'o':
1247                                 if (len == 1 || (len == 5
1248                                     && wmemcmp(st, L"ther", 4) == 0))
1249                                         tag = ARCHIVE_ENTRY_ACL_OTHER;
1250                                 break;
1251                         case L'm':
1252                                 if (len == 1 || (len == 4
1253                                     && wmemcmp(st, L"ask", 3) == 0))
1254                                         tag = ARCHIVE_ENTRY_ACL_MASK;
1255                                 break;
1256                         default:
1257                                         break;
1258                         }
1259
1260                         switch (tag) {
1261                         case ARCHIVE_ENTRY_ACL_OTHER:
1262                         case ARCHIVE_ENTRY_ACL_MASK:
1263                                 if (fields == (n + 2)
1264                                     && field[n + 1].start < field[n + 1].end
1265                                     && ismode_w(field[n + 1].start,
1266                                     field[n + 1].end, &permset)) {
1267                                         /* This is Solaris-style "other:rwx" */
1268                                         sol = 1;
1269                                 } else if (fields == (n + 3) &&
1270                                     field[n + 1].start < field[n + 1].end) {
1271                                         /* Invalid mask or other field */
1272                                         ret = ARCHIVE_WARN;
1273                                         continue;
1274                                 }
1275                                 break;
1276                         case ARCHIVE_ENTRY_ACL_USER_OBJ:
1277                         case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
1278                                 if (id != -1 ||
1279                                     field[n + 1].start < field[n + 1].end) {
1280                                         name = field[n + 1];
1281                                         if (tag == ARCHIVE_ENTRY_ACL_USER_OBJ)
1282                                                 tag = ARCHIVE_ENTRY_ACL_USER;
1283                                         else
1284                                                 tag = ARCHIVE_ENTRY_ACL_GROUP;
1285                                 }
1286                                 break;
1287                         default:
1288                                 /* Invalid tag, skip entry */
1289                                 ret = ARCHIVE_WARN;
1290                                 continue;
1291                         }
1292
1293                         /*
1294                          * Without "default:" we expect mode in field 2
1295                          * Exception: Solaris other and mask fields
1296                          */
1297                         if (permset == 0 && !ismode_w(field[n + 2 - sol].start,
1298                             field[n + 2 - sol].end, &permset)) {
1299                                 /* Invalid mode, skip entry */
1300                                 ret = ARCHIVE_WARN;
1301                                 continue;
1302                         }
1303                 } else {
1304                         /* NFS4 ACLs */
1305                         s = field[0].start;
1306                         len = field[0].end - field[0].start;
1307                         tag = 0;
1308
1309                         switch (len) {
1310                         case 4:
1311                                 if (wmemcmp(s, L"user", 4) == 0)
1312                                         tag = ARCHIVE_ENTRY_ACL_USER;
1313                                 break;
1314                         case 5:
1315                                 if (wmemcmp(s, L"group", 5) == 0)
1316                                         tag = ARCHIVE_ENTRY_ACL_GROUP;
1317                                 break;
1318                         case 6:
1319                                 if (wmemcmp(s, L"owner@", 6) == 0)
1320                                         tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
1321                                 else if (wmemcmp(s, L"group@", len) == 0)
1322                                         tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
1323                                 break;
1324                         case 9:
1325                                 if (wmemcmp(s, L"everyone@", 9) == 0)
1326                                         tag = ARCHIVE_ENTRY_ACL_EVERYONE;
1327                         default:
1328                                 break;
1329                         }
1330
1331                         if (tag == 0) {
1332                                 /* Invalid tag, skip entry */
1333                                 ret = ARCHIVE_WARN;
1334                                 continue;
1335                         } else if (tag == ARCHIVE_ENTRY_ACL_USER ||
1336                             tag == ARCHIVE_ENTRY_ACL_GROUP) {
1337                                 n = 1;
1338                                 name = field[1];
1339                                 isint_w(name.start, name.end, &id);
1340                         } else
1341                                 n = 0;
1342
1343                         if (!is_nfs4_perms_w(field[1 + n].start,
1344                             field[1 + n].end, &permset)) {
1345                                 /* Invalid NFSv4 perms, skip entry */
1346                                 ret = ARCHIVE_WARN;
1347                                 continue;
1348                         }
1349                         if (!is_nfs4_flags_w(field[2 + n].start,
1350                             field[2 + n].end, &permset)) {
1351                                 /* Invalid NFSv4 flags, skip entry */
1352                                 ret = ARCHIVE_WARN;
1353                                 continue;
1354                         }
1355                         s = field[3 + n].start;
1356                         len = field[3 + n].end - field[3 + n].start;
1357                         type = 0;
1358                         if (len == 4) {
1359                                 if (wmemcmp(s, L"deny", 4) == 0)
1360                                         type = ARCHIVE_ENTRY_ACL_TYPE_DENY;
1361                         } else if (len == 5) {
1362                                 if (wmemcmp(s, L"allow", 5) == 0)
1363                                         type = ARCHIVE_ENTRY_ACL_TYPE_ALLOW;
1364                                 else if (wmemcmp(s, L"audit", 5) == 0)
1365                                         type = ARCHIVE_ENTRY_ACL_TYPE_AUDIT;
1366                                 else if (wmemcmp(s, L"alarm", 5) == 0)
1367                                         type = ARCHIVE_ENTRY_ACL_TYPE_ALARM;
1368                         }
1369                         if (type == 0) {
1370                                 /* Invalid entry type, skip entry */
1371                                 ret = ARCHIVE_WARN;
1372                                 continue;
1373                         }
1374                         isint_w(field[4 + n].start, field[4 + n].end, &id);
1375                 }
1376
1377                 /* Add entry to the internal list. */
1378                 r = archive_acl_add_entry_w_len(acl, type, permset,
1379                     tag, id, name.start, name.end - name.start);
1380                 if (r < ARCHIVE_WARN)
1381                         return (r);
1382                 if (r != ARCHIVE_OK)
1383                         ret = ARCHIVE_WARN;
1384                 types |= type;
1385         }
1386
1387         /* Reset ACL */
1388         archive_acl_reset(acl, types);
1389
1390         return (ret);
1391 }
1392
1393 /*
1394  * Parse a string to a positive decimal integer.  Returns true if
1395  * the string is non-empty and consists only of decimal digits,
1396  * false otherwise.
1397  */
1398 static int
1399 isint_w(const wchar_t *start, const wchar_t *end, int *result)
1400 {
1401         int n = 0;
1402         if (start >= end)
1403                 return (0);
1404         while (start < end) {
1405                 if (*start < L'0' || *start > L'9')
1406                         return (0);
1407                 if (n > (INT_MAX / 10) ||
1408                     (n == INT_MAX / 10 && (*start - L'0') > INT_MAX % 10)) {
1409                         n = INT_MAX;
1410                 } else {
1411                         n *= 10;
1412                         n += *start - L'0';
1413                 }
1414                 start++;
1415         }
1416         *result = n;
1417         return (1);
1418 }
1419
1420 /*
1421  * Parse a string as a mode field.  Returns true if
1422  * the string is non-empty and consists only of mode characters,
1423  * false otherwise.
1424  */
1425 static int
1426 ismode_w(const wchar_t *start, const wchar_t *end, int *permset)
1427 {
1428         const wchar_t *p;
1429
1430         if (start >= end)
1431                 return (0);
1432         p = start;
1433         *permset = 0;
1434         while (p < end) {
1435                 switch (*p++) {
1436                 case L'r': case L'R':
1437                         *permset |= ARCHIVE_ENTRY_ACL_READ;
1438                         break;
1439                 case L'w': case L'W':
1440                         *permset |= ARCHIVE_ENTRY_ACL_WRITE;
1441                         break;
1442                 case L'x': case L'X':
1443                         *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
1444                         break;
1445                 case L'-':
1446                         break;
1447                 default:
1448                         return (0);
1449                 }
1450         }
1451         return (1);
1452 }
1453
1454 /*
1455  * Parse a string as a NFS4 ACL permission field.
1456  * Returns true if the string is non-empty and consists only of NFS4 ACL
1457  * permission characters, false otherwise
1458  */
1459 static int
1460 is_nfs4_perms_w(const wchar_t *start, const wchar_t *end, int *permset)
1461 {
1462         const wchar_t *p = start;
1463
1464         while (p < end) {
1465                 switch (*p++) {
1466                 case L'r':
1467                         *permset |= ARCHIVE_ENTRY_ACL_READ_DATA;
1468                         break;
1469                 case L'w':
1470                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_DATA;
1471                         break;
1472                 case L'x':
1473                         *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
1474                         break;
1475                 case L'p':
1476                         *permset |= ARCHIVE_ENTRY_ACL_APPEND_DATA;
1477                         break;
1478                 case L'D':
1479                         *permset |= ARCHIVE_ENTRY_ACL_DELETE_CHILD;
1480                         break;
1481                 case L'd':
1482                         *permset |= ARCHIVE_ENTRY_ACL_DELETE;
1483                         break;
1484                 case L'a':
1485                         *permset |= ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES;
1486                         break;
1487                 case L'A':
1488                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES;
1489                         break;
1490                 case L'R':
1491                         *permset |= ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS;
1492                         break;
1493                 case L'W':
1494                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS;
1495                         break;
1496                 case L'c':
1497                         *permset |= ARCHIVE_ENTRY_ACL_READ_ACL;
1498                         break;
1499                 case L'C':
1500                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_ACL;
1501                         break;
1502                 case L'o':
1503                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_OWNER;
1504                         break;
1505                 case L's':
1506                         *permset |= ARCHIVE_ENTRY_ACL_SYNCHRONIZE;
1507                         break;
1508                 case L'-':
1509                         break;
1510                 default:
1511                         return(0);
1512                 }
1513         }
1514         return (1);
1515 }
1516
1517 /*
1518  * Parse a string as a NFS4 ACL flags field.
1519  * Returns true if the string is non-empty and consists only of NFS4 ACL
1520  * flag characters, false otherwise
1521  */
1522 static int
1523 is_nfs4_flags_w(const wchar_t *start, const wchar_t *end, int *permset)
1524 {
1525         const wchar_t *p = start;
1526
1527         while (p < end) {
1528                 switch(*p++) {
1529                 case L'f':
1530                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT;
1531                         break;
1532                 case L'd':
1533                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT;
1534                         break;
1535                 case L'i':
1536                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY;
1537                         break;
1538                 case L'n':
1539                         *permset |=
1540                             ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT;
1541                         break;
1542                 case L'S':
1543                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS;
1544                         break;
1545                 case L'F':
1546                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS;
1547                         break;
1548                 case L'I':
1549                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_INHERITED;
1550                         break;
1551                 case L'-':
1552                         break;
1553                 default:
1554                         return (0);
1555                 }
1556         }
1557         return (1);
1558 }
1559
1560 /*
1561  * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]".  *wp is updated
1562  * to point to just after the separator.  *start points to the first
1563  * character of the matched text and *end just after the last
1564  * character of the matched identifier.  In particular *end - *start
1565  * is the length of the field body, not including leading or trailing
1566  * whitespace.
1567  */
1568 static void
1569 next_field_w(const wchar_t **wp, const wchar_t **start,
1570     const wchar_t **end, wchar_t *sep)
1571 {
1572         /* Skip leading whitespace to find start of field. */
1573         while (**wp == L' ' || **wp == L'\t' || **wp == L'\n') {
1574                 (*wp)++;
1575         }
1576         *start = *wp;
1577
1578         /* Scan for the separator. */
1579         while (**wp != L'\0' && **wp != L',' && **wp != L':' &&
1580             **wp != L'\n' && **wp != L'#') {
1581                 (*wp)++;
1582         }
1583         *sep = **wp;
1584
1585         /* Locate end of field, trim trailing whitespace if necessary */
1586         if (*wp == *start) {
1587                 *end = *wp;
1588         } else {
1589                 *end = *wp - 1;
1590                 while (**end == L' ' || **end == L'\t' || **end == L'\n') {
1591                         (*end)--;
1592                 }
1593                 (*end)++;
1594         }
1595
1596         /* Handle in-field comments */
1597         if (*sep == L'#') {
1598                 while (**wp != L'\0' && **wp != L',' && **wp != L'\n') {
1599                         (*wp)++;
1600                 }
1601                 *sep = **wp;
1602         }
1603
1604         /* Adjust scanner location. */
1605         if (**wp != L'\0')
1606                 (*wp)++;
1607 }
1608
1609 /*
1610  * Parse an ACL text string.
1611  *
1612  * The want_type argument may be one of the following:
1613  * ARCHIVE_ENTRY_ACL_TYPE_ACCESS - text is a POSIX.1e ACL of type ACCESS
1614  * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT - text is a POSIX.1e ACL of type DEFAULT
1615  * ARCHIVE_ENTRY_ACL_TYPE_NFS4 - text is as a NFSv4 ACL
1616  *
1617  * POSIX.1e ACL entries prefixed with "default:" are treated as
1618  * ARCHIVE_ENTRY_ACL_TYPE_DEFAULT unless type is ARCHIVE_ENTRY_ACL_TYPE_NFS4
1619  */
1620 int
1621 archive_acl_from_text_l(struct archive_acl *acl, const char *text,
1622     int want_type, struct archive_string_conv *sc)
1623 {
1624         struct {
1625                 const char *start;
1626                 const char *end;
1627         } field[6], name;
1628
1629         const char *s, *st;
1630         int numfields, fields, n, r, sol, ret;
1631         int type, types, tag, permset, id;
1632         size_t len;
1633         char sep;
1634
1635         switch (want_type) {
1636         case ARCHIVE_ENTRY_ACL_TYPE_POSIX1E:
1637                 want_type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
1638                 __LA_FALLTHROUGH;
1639         case ARCHIVE_ENTRY_ACL_TYPE_ACCESS:
1640         case ARCHIVE_ENTRY_ACL_TYPE_DEFAULT:
1641                 numfields = 5;
1642                 break;
1643         case ARCHIVE_ENTRY_ACL_TYPE_NFS4:
1644                 numfields = 6;
1645                 break;
1646         default:
1647                 return (ARCHIVE_FATAL);
1648         }
1649
1650         ret = ARCHIVE_OK;
1651         types = 0;
1652
1653         while (text != NULL &&  *text != '\0') {
1654                 /*
1655                  * Parse the fields out of the next entry,
1656                  * advance 'text' to start of next entry.
1657                  */
1658                 fields = 0;
1659                 do {
1660                         const char *start, *end;
1661                         next_field(&text, &start, &end, &sep);
1662                         if (fields < numfields) {
1663                                 field[fields].start = start;
1664                                 field[fields].end = end;
1665                         }
1666                         ++fields;
1667                 } while (sep == ':');
1668
1669                 /* Set remaining fields to blank. */
1670                 for (n = fields; n < numfields; ++n)
1671                         field[n].start = field[n].end = NULL;
1672
1673                 if (field[0].start != NULL && *(field[0].start) == '#') {
1674                         /* Comment, skip entry */
1675                         continue;
1676                 }
1677
1678                 n = 0;
1679                 sol = 0;
1680                 id = -1;
1681                 permset = 0;
1682                 name.start = name.end = NULL;
1683
1684                 if (want_type != ARCHIVE_ENTRY_ACL_TYPE_NFS4) {
1685                         /* POSIX.1e ACLs */
1686                         /*
1687                          * Default keyword "default:user::rwx"
1688                          * if found, we have one more field
1689                          *
1690                          * We also support old Solaris extension:
1691                          * "defaultuser::rwx" is the default ACL corresponding
1692                          * to "user::rwx", etc. valid only for first field
1693                          */
1694                         s = field[0].start;
1695                         len = field[0].end - field[0].start;
1696                         if (*s == 'd' && (len == 1 || (len >= 7
1697                             && memcmp((s + 1), "efault", 6) == 0))) {
1698                                 type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
1699                                 if (len > 7)
1700                                         field[0].start += 7;
1701                                 else
1702                                         n = 1;
1703                         } else
1704                                 type = want_type;
1705
1706                         /* Check for a numeric ID in field n+1 or n+3. */
1707                         isint(field[n + 1].start, field[n + 1].end, &id);
1708                         /* Field n+3 is optional. */
1709                         if (id == -1 && fields > (n + 3))
1710                                 isint(field[n + 3].start, field[n + 3].end,
1711                                     &id);
1712
1713                         tag = 0;
1714                         s = field[n].start;
1715                         st = field[n].start + 1;
1716                         len = field[n].end - field[n].start;
1717
1718                         if (len == 0) {
1719                                 ret = ARCHIVE_WARN;
1720                                 continue;
1721                         }
1722
1723                         switch (*s) {
1724                         case 'u':
1725                                 if (len == 1 || (len == 4
1726                                     && memcmp(st, "ser", 3) == 0))
1727                                         tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
1728                                 break;
1729                         case 'g':
1730                                 if (len == 1 || (len == 5
1731                                     && memcmp(st, "roup", 4) == 0))
1732                                         tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
1733                                 break;
1734                         case 'o':
1735                                 if (len == 1 || (len == 5
1736                                     && memcmp(st, "ther", 4) == 0))
1737                                         tag = ARCHIVE_ENTRY_ACL_OTHER;
1738                                 break;
1739                         case 'm':
1740                                 if (len == 1 || (len == 4
1741                                     && memcmp(st, "ask", 3) == 0))
1742                                         tag = ARCHIVE_ENTRY_ACL_MASK;
1743                                 break;
1744                         default:
1745                                         break;
1746                         }
1747
1748                         switch (tag) {
1749                         case ARCHIVE_ENTRY_ACL_OTHER:
1750                         case ARCHIVE_ENTRY_ACL_MASK:
1751                                 if (fields == (n + 2)
1752                                     && field[n + 1].start < field[n + 1].end
1753                                     && ismode(field[n + 1].start,
1754                                     field[n + 1].end, &permset)) {
1755                                         /* This is Solaris-style "other:rwx" */
1756                                         sol = 1;
1757                                 } else if (fields == (n + 3) &&
1758                                     field[n + 1].start < field[n + 1].end) {
1759                                         /* Invalid mask or other field */
1760                                         ret = ARCHIVE_WARN;
1761                                         continue;
1762                                 }
1763                                 break;
1764                         case ARCHIVE_ENTRY_ACL_USER_OBJ:
1765                         case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
1766                                 if (id != -1 ||
1767                                     field[n + 1].start < field[n + 1].end) {
1768                                         name = field[n + 1];
1769                                         if (tag == ARCHIVE_ENTRY_ACL_USER_OBJ)
1770                                                 tag = ARCHIVE_ENTRY_ACL_USER;
1771                                         else
1772                                                 tag = ARCHIVE_ENTRY_ACL_GROUP;
1773                                 }
1774                                 break;
1775                         default:
1776                                 /* Invalid tag, skip entry */
1777                                 ret = ARCHIVE_WARN;
1778                                 continue;
1779                         }
1780
1781                         /*
1782                          * Without "default:" we expect mode in field 3
1783                          * Exception: Solaris other and mask fields
1784                          */
1785                         if (permset == 0 && !ismode(field[n + 2 - sol].start,
1786                             field[n + 2 - sol].end, &permset)) {
1787                                 /* Invalid mode, skip entry */
1788                                 ret = ARCHIVE_WARN;
1789                                 continue;
1790                         }
1791                 } else {
1792                         /* NFS4 ACLs */
1793                         s = field[0].start;
1794                         len = field[0].end - field[0].start;
1795                         tag = 0;
1796
1797                         switch (len) {
1798                         case 4:
1799                                 if (memcmp(s, "user", 4) == 0)
1800                                         tag = ARCHIVE_ENTRY_ACL_USER;
1801                                 break;
1802                         case 5:
1803                                 if (memcmp(s, "group", 5) == 0)
1804                                         tag = ARCHIVE_ENTRY_ACL_GROUP;
1805                                 break;
1806                         case 6:
1807                                 if (memcmp(s, "owner@", 6) == 0)
1808                                         tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
1809                                 else if (memcmp(s, "group@", 6) == 0)
1810                                         tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
1811                                 break;
1812                         case 9:
1813                                 if (memcmp(s, "everyone@", 9) == 0)
1814                                         tag = ARCHIVE_ENTRY_ACL_EVERYONE;
1815                                 break;
1816                         default:
1817                                 break;
1818                         }
1819
1820                         if (tag == 0) {
1821                                 /* Invalid tag, skip entry */
1822                                 ret = ARCHIVE_WARN;
1823                                 continue;
1824                         } else if (tag == ARCHIVE_ENTRY_ACL_USER ||
1825                             tag == ARCHIVE_ENTRY_ACL_GROUP) {
1826                                 n = 1;
1827                                 name = field[1];
1828                                 isint(name.start, name.end, &id);
1829                         } else
1830                                 n = 0;
1831
1832                         if (!is_nfs4_perms(field[1 + n].start,
1833                             field[1 + n].end, &permset)) {
1834                                 /* Invalid NFSv4 perms, skip entry */
1835                                 ret = ARCHIVE_WARN;
1836                                 continue;
1837                         }
1838                         if (!is_nfs4_flags(field[2 + n].start,
1839                             field[2 + n].end, &permset)) {
1840                                 /* Invalid NFSv4 flags, skip entry */
1841                                 ret = ARCHIVE_WARN;
1842                                 continue;
1843                         }
1844                         s = field[3 + n].start;
1845                         len = field[3 + n].end - field[3 + n].start;
1846                         type = 0;
1847                         if (len == 4) {
1848                                 if (memcmp(s, "deny", 4) == 0)
1849                                         type = ARCHIVE_ENTRY_ACL_TYPE_DENY;
1850                         } else if (len == 5) {
1851                                 if (memcmp(s, "allow", 5) == 0)
1852                                         type = ARCHIVE_ENTRY_ACL_TYPE_ALLOW;
1853                                 else if (memcmp(s, "audit", 5) == 0)
1854                                         type = ARCHIVE_ENTRY_ACL_TYPE_AUDIT;
1855                                 else if (memcmp(s, "alarm", 5) == 0)
1856                                         type = ARCHIVE_ENTRY_ACL_TYPE_ALARM;
1857                         }
1858                         if (type == 0) {
1859                                 /* Invalid entry type, skip entry */
1860                                 ret = ARCHIVE_WARN;
1861                                 continue;
1862                         }
1863                         isint(field[4 + n].start, field[4 + n].end,
1864                             &id);
1865                 }
1866
1867                 /* Add entry to the internal list. */
1868                 r = archive_acl_add_entry_len_l(acl, type, permset,
1869                     tag, id, name.start, name.end - name.start, sc);
1870                 if (r < ARCHIVE_WARN)
1871                         return (r);
1872                 if (r != ARCHIVE_OK)
1873                         ret = ARCHIVE_WARN;
1874                 types |= type;
1875         }
1876
1877         /* Reset ACL */
1878         archive_acl_reset(acl, types);
1879
1880         return (ret);
1881 }
1882
1883 /*
1884  * Parse a string to a positive decimal integer.  Returns true if
1885  * the string is non-empty and consists only of decimal digits,
1886  * false otherwise.
1887  */
1888 static int
1889 isint(const char *start, const char *end, int *result)
1890 {
1891         int n = 0;
1892         if (start >= end)
1893                 return (0);
1894         while (start < end) {
1895                 if (*start < '0' || *start > '9')
1896                         return (0);
1897                 if (n > (INT_MAX / 10) ||
1898                     (n == INT_MAX / 10 && (*start - '0') > INT_MAX % 10)) {
1899                         n = INT_MAX;
1900                 } else {
1901                         n *= 10;
1902                         n += *start - '0';
1903                 }
1904                 start++;
1905         }
1906         *result = n;
1907         return (1);
1908 }
1909
1910 /*
1911  * Parse a string as a mode field.  Returns true if
1912  * the string is non-empty and consists only of mode characters,
1913  * false otherwise.
1914  */
1915 static int
1916 ismode(const char *start, const char *end, int *permset)
1917 {
1918         const char *p;
1919
1920         if (start >= end)
1921                 return (0);
1922         p = start;
1923         *permset = 0;
1924         while (p < end) {
1925                 switch (*p++) {
1926                 case 'r': case 'R':
1927                         *permset |= ARCHIVE_ENTRY_ACL_READ;
1928                         break;
1929                 case 'w': case 'W':
1930                         *permset |= ARCHIVE_ENTRY_ACL_WRITE;
1931                         break;
1932                 case 'x': case 'X':
1933                         *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
1934                         break;
1935                 case '-':
1936                         break;
1937                 default:
1938                         return (0);
1939                 }
1940         }
1941         return (1);
1942 }
1943
1944 /*
1945  * Parse a string as a NFS4 ACL permission field.
1946  * Returns true if the string is non-empty and consists only of NFS4 ACL
1947  * permission characters, false otherwise
1948  */
1949 static int
1950 is_nfs4_perms(const char *start, const char *end, int *permset)
1951 {
1952         const char *p = start;
1953
1954         while (p < end) {
1955                 switch (*p++) {
1956                 case 'r':
1957                         *permset |= ARCHIVE_ENTRY_ACL_READ_DATA;
1958                         break;
1959                 case 'w':
1960                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_DATA;
1961                         break;
1962                 case 'x':
1963                         *permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
1964                         break;
1965                 case 'p':
1966                         *permset |= ARCHIVE_ENTRY_ACL_APPEND_DATA;
1967                         break;
1968                 case 'D':
1969                         *permset |= ARCHIVE_ENTRY_ACL_DELETE_CHILD;
1970                         break;
1971                 case 'd':
1972                         *permset |= ARCHIVE_ENTRY_ACL_DELETE;
1973                         break;
1974                 case 'a':
1975                         *permset |= ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES;
1976                         break;
1977                 case 'A':
1978                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES;
1979                         break;
1980                 case 'R':
1981                         *permset |= ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS;
1982                         break;
1983                 case 'W':
1984                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS;
1985                         break;
1986                 case 'c':
1987                         *permset |= ARCHIVE_ENTRY_ACL_READ_ACL;
1988                         break;
1989                 case 'C':
1990                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_ACL;
1991                         break;
1992                 case 'o':
1993                         *permset |= ARCHIVE_ENTRY_ACL_WRITE_OWNER;
1994                         break;
1995                 case 's':
1996                         *permset |= ARCHIVE_ENTRY_ACL_SYNCHRONIZE;
1997                         break;
1998                 case '-':
1999                         break;
2000                 default:
2001                         return(0);
2002                 }
2003         }
2004         return (1);
2005 }
2006
2007 /*
2008  * Parse a string as a NFS4 ACL flags field.
2009  * Returns true if the string is non-empty and consists only of NFS4 ACL
2010  * flag characters, false otherwise
2011  */
2012 static int
2013 is_nfs4_flags(const char *start, const char *end, int *permset)
2014 {
2015         const char *p = start;
2016
2017         while (p < end) {
2018                 switch(*p++) {
2019                 case 'f':
2020                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT;
2021                         break;
2022                 case 'd':
2023                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT;
2024                         break;
2025                 case 'i':
2026                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY;
2027                         break;
2028                 case 'n':
2029                         *permset |=
2030                             ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT;
2031                         break;
2032                 case 'S':
2033                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_SUCCESSFUL_ACCESS;
2034                         break;
2035                 case 'F':
2036                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_FAILED_ACCESS;
2037                         break;
2038                 case 'I':
2039                         *permset |= ARCHIVE_ENTRY_ACL_ENTRY_INHERITED;
2040                         break;
2041                 case '-':
2042                         break;
2043                 default:
2044                         return (0);
2045                 }
2046         }
2047         return (1);
2048 }
2049
2050 /*
2051  * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]".  *wp is updated
2052  * to point to just after the separator.  *start points to the first
2053  * character of the matched text and *end just after the last
2054  * character of the matched identifier.  In particular *end - *start
2055  * is the length of the field body, not including leading or trailing
2056  * whitespace.
2057  */
2058 static void
2059 next_field(const char **p, const char **start,
2060     const char **end, char *sep)
2061 {
2062         /* Skip leading whitespace to find start of field. */
2063         while (**p == ' ' || **p == '\t' || **p == '\n') {
2064                 (*p)++;
2065         }
2066         *start = *p;
2067
2068         /* Scan for the separator. */
2069         while (**p != '\0' && **p != ',' && **p != ':' && **p != '\n' &&
2070             **p != '#') {
2071                 (*p)++;
2072         }
2073         *sep = **p;
2074
2075         /* Locate end of field, trim trailing whitespace if necessary */
2076         if (*p == *start) {
2077                 *end = *p;
2078         } else {
2079                 *end = *p - 1;
2080                 while (**end == ' ' || **end == '\t' || **end == '\n') {
2081                         (*end)--;
2082                 }
2083                 (*end)++;
2084         }
2085
2086         /* Handle in-field comments */
2087         if (*sep == '#') {
2088                 while (**p != '\0' && **p != ',' && **p != '\n') {
2089                         (*p)++;
2090                 }
2091                 *sep = **p;
2092         }
2093
2094         /* Adjust scanner location. */
2095         if (**p != '\0')
2096                 (*p)++;
2097 }