lib/libarchive/archive_entry.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "archive_platform.h"
  27 __FBSDID("$FreeBSD$");
  28
  29 #ifdef HAVE_SYS_STAT_H
  30 #include <sys/stat.h>
  31 #endif
  32 #ifdef HAVE_SYS_TYPES_H
  33 #include <sys/types.h>
  34 #endif
  35 #ifdef MAJOR_IN_MKDEV
  36 #include <sys/mkdev.h>
  37 #else
  38 #ifdef MAJOR_IN_SYSMACROS
  39 #include <sys/sysmacros.h>
  40 #endif
  41 #endif
  42 #ifdef HAVE_EXT2FS_EXT2_FS_H
  43 #include <ext2fs/ext2_fs.h>     /* for Linux file flags */
  44 #endif
  45 #ifdef HAVE_LIMITS_H
  46 #include <limits.h>
  47 #endif
  48 #ifdef HAVE_LINUX_FS_H
  49 #include <linux/fs.h>   /* for Linux file flags */
  50 #endif
  51 #ifdef HAVE_LINUX_EXT2_FS_H
  52 #include <linux/ext2_fs.h>      /* for Linux file flags */
  53 #endif
  54 #include <stddef.h>
  55 #include <stdio.h>
  56 #ifdef HAVE_STDLIB_H
  57 #include <stdlib.h>
  58 #endif
  59 #ifdef HAVE_STRING_H
  60 #include <string.h>
  61 #endif
  62
  63 /* Obtain suitable wide-character manipulation functions. */
  64 #ifdef HAVE_WCHAR_H
  65 #include <wchar.h>
  66 #else
  67 static size_t wcslen(const wchar_t *s)
  68 {
  69         const wchar_t *p = s;
  70         while (*p != L'\0')
  71                 ++p;
  72         return p - s;
  73 }
  74 static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2)
  75 {
  76         wchar_t *dest = s1;
  77         while ((*s1 = *s2) != L'\0')
  78                 ++s1, ++s2;
  79         return dest;
  80 }
  81 #define wmemcpy(a,b,i)  (wchar_t *)memcpy((a), (b), (i) * sizeof(wchar_t))
  82 /* Good enough for simple equality testing, but not for sorting. */
  83 #define wmemcmp(a,b,i)  memcmp((a), (b), (i) * sizeof(wchar_t))
  84 #endif
  85
  86 #include "archive.h"
  87 #include "archive_entry.h"
  88 #include "archive_private.h"
  89
  90 #undef max
  91 #define max(a, b)       ((a)>(b)?(a):(b))
  92
  93 /*
  94  * Handle wide character (i.e., Unicode) and non-wide character
  95  * strings transparently.
  96  *
  97  */
  98
  99 struct aes {
 100         const char *aes_mbs;
 101         char *aes_mbs_alloc;
 102         const wchar_t *aes_wcs;
 103         wchar_t *aes_wcs_alloc;
 104 };
 105
 106 struct ae_acl {
 107         struct ae_acl *next;
 108         int     type;                   /* E.g., access or default */
 109         int     tag;                    /* E.g., user/group/other/mask */
 110         int     permset;                /* r/w/x bits */
 111         int     id;                     /* uid/gid for user/group */
 112         struct aes name;                /* uname/gname */
 113 };
 114
 115 struct ae_xattr {
 116         struct ae_xattr *next;
 117
 118         char    *name;
 119         void    *value;
 120         size_t  size;
 121 };
 122
 123 static void     aes_clean(struct aes *);
 124 static void     aes_copy(struct aes *dest, struct aes *src);
 125 static const char *     aes_get_mbs(struct aes *);
 126 static const wchar_t *  aes_get_wcs(struct aes *);
 127 static void     aes_set_mbs(struct aes *, const char *mbs);
 128 static void     aes_copy_mbs(struct aes *, const char *mbs);
 129 /* static void  aes_set_wcs(struct aes *, const wchar_t *wcs); */
 130 static void     aes_copy_wcs(struct aes *, const wchar_t *wcs);
 131 static void     aes_copy_wcs_len(struct aes *, const wchar_t *wcs, size_t);
 132
 133 static char *    ae_fflagstostr(unsigned long bitset, unsigned long bitclear);
 134 static const wchar_t    *ae_wcstofflags(const wchar_t *stringp,
 135                     unsigned long *setp, unsigned long *clrp);
 136 static void     append_entry_w(wchar_t **wp, const wchar_t *prefix, int tag,
 137                     const wchar_t *wname, int perm, int id);
 138 static void     append_id_w(wchar_t **wp, int id);
 139
 140 static int      acl_special(struct archive_entry *entry,
 141                     int type, int permset, int tag);
 142 static struct ae_acl *acl_new_entry(struct archive_entry *entry,
 143                     int type, int permset, int tag, int id);
 144 static int      isint_w(const wchar_t *start, const wchar_t *end, int *result);
 145 static void     next_field_w(const wchar_t **wp, const wchar_t **start,
 146                     const wchar_t **end, wchar_t *sep);
 147 static int      prefix_w(const wchar_t *start, const wchar_t *end,
 148                     const wchar_t *test);
 149 static void
 150 archive_entry_acl_add_entry_w_len(struct archive_entry *entry, int type,
 151                     int permset, int tag, int id, const wchar_t *name, size_t);
 152
 153
 154 /*
 155  * Description of an archive entry.
 156  *
 157  * Basically, this is a "struct stat" with a few text fields added in.
 158  *
 159  * TODO: Add "comment", "charset", and possibly other entries
 160  * that are supported by "pax interchange" format.  However, GNU, ustar,
 161  * cpio, and other variants don't support these features, so they're not an
 162  * excruciatingly high priority right now.
 163  *
 164  * TODO: "pax interchange" format allows essentially arbitrary
 165  * key/value attributes to be attached to any entry.  Supporting
 166  * such extensions may make this library useful for special
 167  * applications (e.g., a package manager could attach special
 168  * package-management attributes to each entry).  There are tricky
 169  * API issues involved, so this is not going to happen until
 170  * there's a real demand for it.
 171  *
 172  * TODO: Design a good API for handling sparse files.
 173  */
 174 struct archive_entry {
 175         /*
 176          * Note that ae_stat.st_mode & S_IFMT  can be  0!
 177          *
 178          * This occurs when the actual file type of the object is not
 179          * in the archive.  For example, 'tar' archives store
 180          * hardlinks without marking the type of the underlying
 181          * object.
 182          */
 183         struct stat ae_stat;
 184
 185         /*
 186          * Use aes here so that we get transparent mbs<->wcs conversions.
 187          */
 188         struct aes ae_fflags_text;      /* Text fflags per fflagstostr(3) */
 189         unsigned long ae_fflags_set;            /* Bitmap fflags */
 190         unsigned long ae_fflags_clear;
 191         struct aes ae_gname;            /* Name of owning group */
 192         struct aes ae_hardlink; /* Name of target for hardlink */
 193         struct aes ae_pathname; /* Name of entry */
 194         struct aes ae_symlink;          /* symlink contents */
 195         struct aes ae_uname;            /* Name of owner */
 196
 197         struct ae_acl   *acl_head;
 198         struct ae_acl   *acl_p;
 199         int              acl_state;     /* See acl_next for details. */
 200         wchar_t         *acl_text_w;
 201
 202         struct ae_xattr *xattr_head;
 203         struct ae_xattr *xattr_p;
 204 };
 205
 206 static void
 207 aes_clean(struct aes *aes)
 208 {
 209         if (aes->aes_mbs_alloc) {
 210                 free(aes->aes_mbs_alloc);
 211                 aes->aes_mbs_alloc = NULL;
 212         }
 213         if (aes->aes_wcs_alloc) {
 214                 free(aes->aes_wcs_alloc);
 215                 aes->aes_wcs_alloc = NULL;
 216         }
 217         memset(aes, 0, sizeof(*aes));
 218 }
 219
 220 static void
 221 aes_copy(struct aes *dest, struct aes *src)
 222 {
 223         *dest = *src;
 224         if (src->aes_mbs != NULL) {
 225                 dest->aes_mbs_alloc = strdup(src->aes_mbs);
 226                 dest->aes_mbs = dest->aes_mbs_alloc;
 227                 if (dest->aes_mbs == NULL)
 228                         __archive_errx(1, "No memory for aes_copy()");
 229         }
 230
 231         if (src->aes_wcs != NULL) {
 232                 dest->aes_wcs_alloc = (wchar_t *)malloc((wcslen(src->aes_wcs) + 1)
 233                     * sizeof(wchar_t));
 234                 dest->aes_wcs = dest->aes_wcs_alloc;
 235                 if (dest->aes_wcs == NULL)
 236                         __archive_errx(1, "No memory for aes_copy()");
 237                 wcscpy(dest->aes_wcs_alloc, src->aes_wcs);
 238         }
 239 }
 240
 241 static const char *
 242 aes_get_mbs(struct aes *aes)
 243 {
 244         if (aes->aes_mbs == NULL && aes->aes_wcs == NULL)
 245                 return NULL;
 246         if (aes->aes_mbs == NULL && aes->aes_wcs != NULL) {
 247                 /*
 248                  * XXX Need to estimate the number of byte in the
 249                  * multi-byte form.  Assume that, on average, wcs
 250                  * chars encode to no more than 3 bytes.  There must
 251                  * be a better way... XXX
 252                  */
 253                 int mbs_length = wcslen(aes->aes_wcs) * 3 + 64;
 254                 aes->aes_mbs_alloc = (char *)malloc(mbs_length);
 255                 aes->aes_mbs = aes->aes_mbs_alloc;
 256                 if (aes->aes_mbs == NULL)
 257                         __archive_errx(1, "No memory for aes_get_mbs()");
 258                 wcstombs(aes->aes_mbs_alloc, aes->aes_wcs, mbs_length - 1);
 259                 aes->aes_mbs_alloc[mbs_length - 1] = 0;
 260         }
 261         return (aes->aes_mbs);
 262 }
 263
 264 static const wchar_t *
 265 aes_get_wcs(struct aes *aes)
 266 {
 267         if (aes->aes_wcs == NULL && aes->aes_mbs == NULL)
 268                 return NULL;
 269         if (aes->aes_wcs == NULL && aes->aes_mbs != NULL) {
 270                 /*
 271                  * No single byte will be more than one wide character,
 272                  * so this length estimate will always be big enough.
 273                  */
 274                 int wcs_length = strlen(aes->aes_mbs);
 275                 aes->aes_wcs_alloc
 276                     = (wchar_t *)malloc((wcs_length + 1) * sizeof(wchar_t));
 277                 aes->aes_wcs = aes->aes_wcs_alloc;
 278                 if (aes->aes_wcs == NULL)
 279                         __archive_errx(1, "No memory for aes_get_wcs()");
 280                 mbstowcs(aes->aes_wcs_alloc, aes->aes_mbs, wcs_length);
 281                 aes->aes_wcs_alloc[wcs_length] = 0;
 282         }
 283         return (aes->aes_wcs);
 284 }
 285
 286 static void
 287 aes_set_mbs(struct aes *aes, const char *mbs)
 288 {
 289         if (aes->aes_mbs_alloc) {
 290                 free(aes->aes_mbs_alloc);
 291                 aes->aes_mbs_alloc = NULL;
 292         }
 293         if (aes->aes_wcs_alloc) {
 294                 free(aes->aes_wcs_alloc);
 295                 aes->aes_wcs_alloc = NULL;
 296         }
 297         aes->aes_mbs = mbs;
 298         aes->aes_wcs = NULL;
 299 }
 300
 301 static void
 302 aes_copy_mbs(struct aes *aes, const char *mbs)
 303 {
 304         if (aes->aes_mbs_alloc) {
 305                 free(aes->aes_mbs_alloc);
 306                 aes->aes_mbs_alloc = NULL;
 307         }
 308         if (aes->aes_wcs_alloc) {
 309                 free(aes->aes_wcs_alloc);
 310                 aes->aes_wcs_alloc = NULL;
 311         }
 312         aes->aes_mbs_alloc = (char *)malloc((strlen(mbs) + 1) * sizeof(char));
 313         if (aes->aes_mbs_alloc == NULL)
 314                 __archive_errx(1, "No memory for aes_copy_mbs()");
 315         strcpy(aes->aes_mbs_alloc, mbs);
 316         aes->aes_mbs = aes->aes_mbs_alloc;
 317         aes->aes_wcs = NULL;
 318 }
 319
 320 #if 0
 321 static void
 322 aes_set_wcs(struct aes *aes, const wchar_t *wcs)
 323 {
 324         if (aes->aes_mbs_alloc) {
 325                 free(aes->aes_mbs_alloc);
 326                 aes->aes_mbs_alloc = NULL;
 327         }
 328         if (aes->aes_wcs_alloc) {
 329                 free(aes->aes_wcs_alloc);
 330                 aes->aes_wcs_alloc = NULL;
 331         }
 332         aes->aes_mbs = NULL;
 333         aes->aes_wcs = wcs;
 334 }
 335 #endif
 336
 337 static void
 338 aes_copy_wcs(struct aes *aes, const wchar_t *wcs)
 339 {
 340         aes_copy_wcs_len(aes, wcs, wcslen(wcs));
 341 }
 342
 343 static void
 344 aes_copy_wcs_len(struct aes *aes, const wchar_t *wcs, size_t len)
 345 {
 346         if (aes->aes_mbs_alloc) {
 347                 free(aes->aes_mbs_alloc);
 348                 aes->aes_mbs_alloc = NULL;
 349         }
 350         if (aes->aes_wcs_alloc) {
 351                 free(aes->aes_wcs_alloc);
 352                 aes->aes_wcs_alloc = NULL;
 353         }
 354         aes->aes_mbs = NULL;
 355         aes->aes_wcs_alloc = (wchar_t *)malloc((len + 1) * sizeof(wchar_t));
 356         if (aes->aes_wcs_alloc == NULL)
 357                 __archive_errx(1, "No memory for aes_copy_wcs()");
 358         wmemcpy(aes->aes_wcs_alloc, wcs, len);
 359         aes->aes_wcs_alloc[len] = L'\0';
 360         aes->aes_wcs = aes->aes_wcs_alloc;
 361 }
 362
 363 struct archive_entry *
 364 archive_entry_clear(struct archive_entry *entry)
 365 {
 366         aes_clean(&entry->ae_fflags_text);
 367         aes_clean(&entry->ae_gname);
 368         aes_clean(&entry->ae_hardlink);
 369         aes_clean(&entry->ae_pathname);
 370         aes_clean(&entry->ae_symlink);
 371         aes_clean(&entry->ae_uname);
 372         archive_entry_acl_clear(entry);
 373         archive_entry_xattr_clear(entry);
 374         memset(entry, 0, sizeof(*entry));
 375         return entry;
 376 }
 377
 378 struct archive_entry *
 379 archive_entry_clone(struct archive_entry *entry)
 380 {
 381         struct archive_entry *entry2;
 382
 383         /* Allocate new structure and copy over all of the fields. */
 384         entry2 = (struct archive_entry *)malloc(sizeof(*entry2));
 385         if (entry2 == NULL)
 386                 return (NULL);
 387         memset(entry2, 0, sizeof(*entry2));
 388         entry2->ae_stat = entry->ae_stat;
 389         entry2->ae_fflags_set = entry->ae_fflags_set;
 390         entry2->ae_fflags_clear = entry->ae_fflags_clear;
 391
 392         aes_copy(&entry2->ae_fflags_text, &entry->ae_fflags_text);
 393         aes_copy(&entry2->ae_gname, &entry->ae_gname);
 394         aes_copy(&entry2->ae_hardlink, &entry->ae_hardlink);
 395         aes_copy(&entry2->ae_pathname, &entry->ae_pathname);
 396         aes_copy(&entry2->ae_symlink, &entry->ae_symlink);
 397         aes_copy(&entry2->ae_uname, &entry->ae_uname);
 398
 399         /* XXX TODO: Copy ACL data over as well. XXX */
 400         /* XXX TODO: Copy xattr data over as well. XXX */
 401         return (entry2);
 402 }
 403
 404 void
 405 archive_entry_free(struct archive_entry *entry)
 406 {
 407         archive_entry_clear(entry);
 408         free(entry);
 409 }
 410
 411 struct archive_entry *
 412 archive_entry_new(void)
 413 {
 414         struct archive_entry *entry;
 415
 416         entry = (struct archive_entry *)malloc(sizeof(*entry));
 417         if (entry == NULL)
 418                 return (NULL);
 419         memset(entry, 0, sizeof(*entry));
 420         return (entry);
 421 }
 422
 423 /*
 424  * Functions for reading fields from an archive_entry.
 425  */
 426
 427 time_t
 428 archive_entry_atime(struct archive_entry *entry)
 429 {
 430         return (entry->ae_stat.st_atime);
 431 }
 432
 433 long
 434 archive_entry_atime_nsec(struct archive_entry *entry)
 435 {
 436         (void)entry; /* entry can be unused here. */
 437         return (ARCHIVE_STAT_ATIME_NANOS(&entry->ae_stat));
 438 }
 439
 440 time_t
 441 archive_entry_ctime(struct archive_entry *entry)
 442 {
 443         return (entry->ae_stat.st_ctime);
 444 }
 445
 446 long
 447 archive_entry_ctime_nsec(struct archive_entry *entry)
 448 {
 449         (void)entry; /* entry can be unused here. */
 450         return (ARCHIVE_STAT_CTIME_NANOS(&entry->ae_stat));
 451 }
 452
 453 dev_t
 454 archive_entry_dev(struct archive_entry *entry)
 455 {
 456         return (entry->ae_stat.st_dev);
 457 }
 458
 459 void
 460 archive_entry_fflags(struct archive_entry *entry,
 461     unsigned long *set, unsigned long *clear)
 462 {
 463         *set = entry->ae_fflags_set;
 464         *clear = entry->ae_fflags_clear;
 465 }
 466
 467 /*
 468  * Note: if text was provided, this just returns that text.  If you
 469  * really need the text to be rebuilt in a canonical form, set the
 470  * text, ask for the bitmaps, then set the bitmaps.  (Setting the
 471  * bitmaps clears any stored text.)  This design is deliberate: if
 472  * we're editing archives, we don't want to discard flags just because
 473  * they aren't supported on the current system.  The bitmap<->text
 474  * conversions are platform-specific (see below).
 475  */
 476 const char *
 477 archive_entry_fflags_text(struct archive_entry *entry)
 478 {
 479         const char *f;
 480         char *p;
 481
 482         f = aes_get_mbs(&entry->ae_fflags_text);
 483         if (f != NULL)
 484                 return (f);
 485
 486         if (entry->ae_fflags_set == 0  &&  entry->ae_fflags_clear == 0)
 487                 return (NULL);
 488
 489         p = ae_fflagstostr(entry->ae_fflags_set, entry->ae_fflags_clear);
 490         if (p == NULL)
 491                 return (NULL);
 492
 493         aes_copy_mbs(&entry->ae_fflags_text, p);
 494         free(p);
 495         f = aes_get_mbs(&entry->ae_fflags_text);
 496         return (f);
 497 }
 498
 499 gid_t
 500 archive_entry_gid(struct archive_entry *entry)
 501 {
 502         return (entry->ae_stat.st_gid);
 503 }
 504
 505 const char *
 506 archive_entry_gname(struct archive_entry *entry)
 507 {
 508         return (aes_get_mbs(&entry->ae_gname));
 509 }
 510
 511 const wchar_t *
 512 archive_entry_gname_w(struct archive_entry *entry)
 513 {
 514         return (aes_get_wcs(&entry->ae_gname));
 515 }
 516
 517 const char *
 518 archive_entry_hardlink(struct archive_entry *entry)
 519 {
 520         return (aes_get_mbs(&entry->ae_hardlink));
 521 }
 522
 523 const wchar_t *
 524 archive_entry_hardlink_w(struct archive_entry *entry)
 525 {
 526         return (aes_get_wcs(&entry->ae_hardlink));
 527 }
 528
 529 ino_t
 530 archive_entry_ino(struct archive_entry *entry)
 531 {
 532         return (entry->ae_stat.st_ino);
 533 }
 534
 535 mode_t
 536 archive_entry_mode(struct archive_entry *entry)
 537 {
 538         return (entry->ae_stat.st_mode);
 539 }
 540
 541 time_t
 542 archive_entry_mtime(struct archive_entry *entry)
 543 {
 544         return (entry->ae_stat.st_mtime);
 545 }
 546
 547 long
 548 archive_entry_mtime_nsec(struct archive_entry *entry)
 549 {
 550         (void)entry; /* entry can be unused here. */
 551         return (ARCHIVE_STAT_MTIME_NANOS(&entry->ae_stat));
 552 }
 553
 554 const char *
 555 archive_entry_pathname(struct archive_entry *entry)
 556 {
 557         return (aes_get_mbs(&entry->ae_pathname));
 558 }
 559
 560 const wchar_t *
 561 archive_entry_pathname_w(struct archive_entry *entry)
 562 {
 563         return (aes_get_wcs(&entry->ae_pathname));
 564 }
 565
 566 dev_t
 567 archive_entry_rdev(struct archive_entry *entry)
 568 {
 569         return (entry->ae_stat.st_rdev);
 570 }
 571
 572 dev_t
 573 archive_entry_rdevmajor(struct archive_entry *entry)
 574 {
 575         return (major(entry->ae_stat.st_rdev));
 576 }
 577
 578 dev_t
 579 archive_entry_rdevminor(struct archive_entry *entry)
 580 {
 581         return (minor(entry->ae_stat.st_rdev));
 582 }
 583
 584 int64_t
 585 archive_entry_size(struct archive_entry *entry)
 586 {
 587         return (entry->ae_stat.st_size);
 588 }
 589
 590 const struct stat *
 591 archive_entry_stat(struct archive_entry *entry)
 592 {
 593         return (&entry->ae_stat);
 594 }
 595
 596 const char *
 597 archive_entry_symlink(struct archive_entry *entry)
 598 {
 599         return (aes_get_mbs(&entry->ae_symlink));
 600 }
 601
 602 const wchar_t *
 603 archive_entry_symlink_w(struct archive_entry *entry)
 604 {
 605         return (aes_get_wcs(&entry->ae_symlink));
 606 }
 607
 608 uid_t
 609 archive_entry_uid(struct archive_entry *entry)
 610 {
 611         return (entry->ae_stat.st_uid);
 612 }
 613
 614 const char *
 615 archive_entry_uname(struct archive_entry *entry)
 616 {
 617         return (aes_get_mbs(&entry->ae_uname));
 618 }
 619
 620 const wchar_t *
 621 archive_entry_uname_w(struct archive_entry *entry)
 622 {
 623         return (aes_get_wcs(&entry->ae_uname));
 624 }
 625
 626 /*
 627  * Functions to set archive_entry properties.
 628  */
 629
 630 /*
 631  * Note "copy" not "set" here.  The "set" functions that accept a pointer
 632  * only store the pointer; they don't copy the underlying object.
 633  */
 634 void
 635 archive_entry_copy_stat(struct archive_entry *entry, const struct stat *st)
 636 {
 637         entry->ae_stat = *st;
 638 }
 639
 640 void
 641 archive_entry_set_fflags(struct archive_entry *entry,
 642     unsigned long set, unsigned long clear)
 643 {
 644         aes_clean(&entry->ae_fflags_text);
 645         entry->ae_fflags_set = set;
 646         entry->ae_fflags_clear = clear;
 647 }
 648
 649 const wchar_t *
 650 archive_entry_copy_fflags_text_w(struct archive_entry *entry,
 651     const wchar_t *flags)
 652 {
 653         aes_copy_wcs(&entry->ae_fflags_text, flags);
 654         return (ae_wcstofflags(flags,
 655                     &entry->ae_fflags_set, &entry->ae_fflags_clear));
 656 }
 657
 658 void
 659 archive_entry_set_gid(struct archive_entry *entry, gid_t g)
 660 {
 661         entry->ae_stat.st_gid = g;
 662 }
 663
 664 void
 665 archive_entry_set_gname(struct archive_entry *entry, const char *name)
 666 {
 667         aes_set_mbs(&entry->ae_gname, name);
 668 }
 669
 670 void
 671 archive_entry_copy_gname_w(struct archive_entry *entry, const wchar_t *name)
 672 {
 673         aes_copy_wcs(&entry->ae_gname, name);
 674 }
 675
 676 void
 677 archive_entry_set_hardlink(struct archive_entry *entry, const char *target)
 678 {
 679         aes_set_mbs(&entry->ae_hardlink, target);
 680 }
 681
 682 void
 683 archive_entry_copy_hardlink(struct archive_entry *entry, const char *target)
 684 {
 685         aes_copy_mbs(&entry->ae_hardlink, target);
 686 }
 687
 688 void
 689 archive_entry_copy_hardlink_w(struct archive_entry *entry, const wchar_t *target)
 690 {
 691         aes_copy_wcs(&entry->ae_hardlink, target);
 692 }
 693
 694 void
 695 archive_entry_set_atime(struct archive_entry *entry, time_t t, long ns)
 696 {
 697         entry->ae_stat.st_atime = t;
 698         ARCHIVE_STAT_SET_ATIME_NANOS(&entry->ae_stat, ns);
 699 }
 700
 701 void
 702 archive_entry_set_ctime(struct archive_entry *entry, time_t t, long ns)
 703 {
 704         entry->ae_stat.st_ctime = t;
 705         ARCHIVE_STAT_SET_CTIME_NANOS(&entry->ae_stat, ns);
 706 }
 707
 708 /* Set symlink if symlink is already set, else set hardlink. */
 709 void
 710 archive_entry_set_link(struct archive_entry *entry, const char *target)
 711 {
 712         if (entry->ae_symlink.aes_mbs != NULL ||
 713             entry->ae_symlink.aes_wcs != NULL)
 714                 aes_set_mbs(&entry->ae_symlink, target);
 715         else
 716                 aes_set_mbs(&entry->ae_hardlink, target);
 717 }
 718
 719 void
 720 archive_entry_set_mode(struct archive_entry *entry, mode_t m)
 721 {
 722         entry->ae_stat.st_mode = m;
 723 }
 724
 725 void
 726 archive_entry_set_mtime(struct archive_entry *entry, time_t m, long ns)
 727 {
 728         entry->ae_stat.st_mtime = m;
 729         ARCHIVE_STAT_SET_MTIME_NANOS(&entry->ae_stat, ns);
 730 }
 731
 732 void
 733 archive_entry_set_pathname(struct archive_entry *entry, const char *name)
 734 {
 735         aes_set_mbs(&entry->ae_pathname, name);
 736 }
 737
 738 void
 739 archive_entry_copy_pathname(struct archive_entry *entry, const char *name)
 740 {
 741         aes_copy_mbs(&entry->ae_pathname, name);
 742 }
 743
 744 void
 745 archive_entry_copy_pathname_w(struct archive_entry *entry, const wchar_t *name)
 746 {
 747         aes_copy_wcs(&entry->ae_pathname, name);
 748 }
 749
 750 void
 751 archive_entry_set_rdevmajor(struct archive_entry *entry, dev_t m)
 752 {
 753         dev_t d;
 754
 755         d = entry->ae_stat.st_rdev;
 756         entry->ae_stat.st_rdev = makedev(major(m), minor(d));
 757 }
 758
 759 void
 760 archive_entry_set_rdevminor(struct archive_entry *entry, dev_t m)
 761 {
 762         dev_t d;
 763
 764         d = entry->ae_stat.st_rdev;
 765         entry->ae_stat.st_rdev = makedev(major(d), minor(m));
 766 }
 767
 768 void
 769 archive_entry_set_size(struct archive_entry *entry, int64_t s)
 770 {
 771         entry->ae_stat.st_size = s;
 772 }
 773
 774 void
 775 archive_entry_set_symlink(struct archive_entry *entry, const char *linkname)
 776 {
 777         aes_set_mbs(&entry->ae_symlink, linkname);
 778 }
 779
 780 void
 781 archive_entry_copy_symlink(struct archive_entry *entry, const char *linkname)
 782 {
 783         aes_copy_mbs(&entry->ae_symlink, linkname);
 784 }
 785
 786 void
 787 archive_entry_copy_symlink_w(struct archive_entry *entry, const wchar_t *linkname)
 788 {
 789         aes_copy_wcs(&entry->ae_symlink, linkname);
 790 }
 791
 792 void
 793 archive_entry_set_uid(struct archive_entry *entry, uid_t u)
 794 {
 795         entry->ae_stat.st_uid = u;
 796 }
 797
 798 void
 799 archive_entry_set_uname(struct archive_entry *entry, const char *name)
 800 {
 801         aes_set_mbs(&entry->ae_uname, name);
 802 }
 803
 804 void
 805 archive_entry_copy_uname_w(struct archive_entry *entry, const wchar_t *name)
 806 {
 807         aes_copy_wcs(&entry->ae_uname, name);
 808 }
 809
 810 /*
 811  * ACL management.  The following would, of course, be a lot simpler
 812  * if: 1) the last draft of POSIX.1e were a really thorough and
 813  * complete standard that addressed the needs of ACL archiving and 2)
 814  * everyone followed it faithfully.  Alas, neither is true, so the
 815  * following is a lot more complex than might seem necessary to the
 816  * uninitiated.
 817  */
 818
 819 void
 820 archive_entry_acl_clear(struct archive_entry *entry)
 821 {
 822         struct ae_acl   *ap;
 823
 824         while (entry->acl_head != NULL) {
 825                 ap = entry->acl_head->next;
 826                 aes_clean(&entry->acl_head->name);
 827                 free(entry->acl_head);
 828                 entry->acl_head = ap;
 829         }
 830         if (entry->acl_text_w != NULL) {
 831                 free(entry->acl_text_w);
 832                 entry->acl_text_w = NULL;
 833         }
 834         entry->acl_p = NULL;
 835         entry->acl_state = 0; /* Not counting. */
 836 }
 837
 838 /*
 839  * Add a single ACL entry to the internal list of ACL data.
 840  */
 841 void
 842 archive_entry_acl_add_entry(struct archive_entry *entry,
 843     int type, int permset, int tag, int id, const char *name)
 844 {
 845         struct ae_acl *ap;
 846
 847         if (acl_special(entry, type, permset, tag) == 0)
 848                 return;
 849         ap = acl_new_entry(entry, type, permset, tag, id);
 850         if (ap == NULL) {
 851                 /* XXX Error XXX */
 852                 return;
 853         }
 854         if (name != NULL  &&  *name != '\0')
 855                 aes_copy_mbs(&ap->name, name);
 856         else
 857                 aes_clean(&ap->name);
 858 }
 859
 860 /*
 861  * As above, but with a wide-character name.
 862  */
 863 void
 864 archive_entry_acl_add_entry_w(struct archive_entry *entry,
 865     int type, int permset, int tag, int id, const wchar_t *name)
 866 {
 867         archive_entry_acl_add_entry_w_len(entry, type, permset, tag, id, name, wcslen(name));
 868 }
 869
 870 void
 871 archive_entry_acl_add_entry_w_len(struct archive_entry *entry,
 872     int type, int permset, int tag, int id, const wchar_t *name, size_t len)
 873 {
 874         struct ae_acl *ap;
 875
 876         if (acl_special(entry, type, permset, tag) == 0)
 877                 return;
 878         ap = acl_new_entry(entry, type, permset, tag, id);
 879         if (ap == NULL) {
 880                 /* XXX Error XXX */
 881                 return;
 882         }
 883         if (name != NULL  &&  *name != L'\0' && len > 0)
 884                 aes_copy_wcs_len(&ap->name, name, len);
 885         else
 886                 aes_clean(&ap->name);
 887 }
 888
 889 /*
 890  * If this ACL entry is part of the standard POSIX permissions set,
 891  * store the permissions in the stat structure and return zero.
 892  */
 893 static int
 894 acl_special(struct archive_entry *entry, int type, int permset, int tag)
 895 {
 896         if (type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS) {
 897                 switch (tag) {
 898                 case ARCHIVE_ENTRY_ACL_USER_OBJ:
 899                         entry->ae_stat.st_mode &= ~0700;
 900                         entry->ae_stat.st_mode |= (permset & 7) << 6;
 901                         return (0);
 902                 case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
 903                         entry->ae_stat.st_mode &= ~0070;
 904                         entry->ae_stat.st_mode |= (permset & 7) << 3;
 905                         return (0);
 906                 case ARCHIVE_ENTRY_ACL_OTHER:
 907                         entry->ae_stat.st_mode &= ~0007;
 908                         entry->ae_stat.st_mode |= permset & 7;
 909                         return (0);
 910                 }
 911         }
 912         return (1);
 913 }
 914
 915 /*
 916  * Allocate and populate a new ACL entry with everything but the
 917  * name.
 918  */
 919 static struct ae_acl *
 920 acl_new_entry(struct archive_entry *entry,
 921     int type, int permset, int tag, int id)
 922 {
 923         struct ae_acl *ap;
 924
 925         if (type != ARCHIVE_ENTRY_ACL_TYPE_ACCESS &&
 926             type != ARCHIVE_ENTRY_ACL_TYPE_DEFAULT)
 927                 return (NULL);
 928         if (entry->acl_text_w != NULL) {
 929                 free(entry->acl_text_w);
 930                 entry->acl_text_w = NULL;
 931         }
 932
 933         /* XXX TODO: More sanity-checks on the arguments XXX */
 934
 935         /* If there's a matching entry already in the list, overwrite it. */
 936         for (ap = entry->acl_head; ap != NULL; ap = ap->next) {
 937                 if (ap->type == type && ap->tag == tag && ap->id == id) {
 938                         ap->permset = permset;
 939                         return (ap);
 940                 }
 941         }
 942
 943         /* Add a new entry to the list. */
 944         ap = (struct ae_acl *)malloc(sizeof(*ap));
 945         if (ap == NULL)
 946                 return (NULL);
 947         memset(ap, 0, sizeof(*ap));
 948         ap->next = entry->acl_head;
 949         entry->acl_head = ap;
 950         ap->type = type;
 951         ap->tag = tag;
 952         ap->id = id;
 953         ap->permset = permset;
 954         return (ap);
 955 }
 956
 957 /*
 958  * Return a count of entries matching "want_type".
 959  */
 960 int
 961 archive_entry_acl_count(struct archive_entry *entry, int want_type)
 962 {
 963         int count;
 964         struct ae_acl *ap;
 965
 966         count = 0;
 967         ap = entry->acl_head;
 968         while (ap != NULL) {
 969                 if ((ap->type & want_type) != 0)
 970                         count++;
 971                 ap = ap->next;
 972         }
 973
 974         if (count > 0 && ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0))
 975                 count += 3;
 976         return (count);
 977 }
 978
 979 /*
 980  * Prepare for reading entries from the ACL data.  Returns a count
 981  * of entries matching "want_type", or zero if there are no
 982  * non-extended ACL entries of that type.
 983  */
 984 int
 985 archive_entry_acl_reset(struct archive_entry *entry, int want_type)
 986 {
 987         int count, cutoff;
 988
 989         count = archive_entry_acl_count(entry, want_type);
 990
 991         /*
 992          * If the only entries are the three standard ones,
 993          * then don't return any ACL data.  (In this case,
 994          * client can just use chmod(2) to set permissions.)
 995          */
 996         if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)
 997                 cutoff = 3;
 998         else
 999                 cutoff = 0;
1000
1001         if (count > cutoff)
1002                 entry->acl_state = ARCHIVE_ENTRY_ACL_USER_OBJ;
1003         else
1004                 entry->acl_state = 0;
1005         entry->acl_p = entry->acl_head;
1006         return (count);
1007 }
1008
1009 /*
1010  * Return the next ACL entry in the list.  Fake entries for the
1011  * standard permissions and include them in the returned list.
1012  */
1013
1014 int
1015 archive_entry_acl_next(struct archive_entry *entry, int want_type, int *type,
1016     int *permset, int *tag, int *id, const char **name)
1017 {
1018         *name = NULL;
1019         *id = -1;
1020
1021         /*
1022          * The acl_state is either zero (no entries available), -1
1023          * (reading from list), or an entry type (retrieve that type
1024          * from ae_stat.st_mode).
1025          */
1026         if (entry->acl_state == 0)
1027                 return (ARCHIVE_WARN);
1028
1029         /* The first three access entries are special. */
1030         if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
1031                 switch (entry->acl_state) {
1032                 case ARCHIVE_ENTRY_ACL_USER_OBJ:
1033                         *permset = (entry->ae_stat.st_mode >> 6) & 7;
1034                         *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
1035                         *tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
1036                         entry->acl_state = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
1037                         return (ARCHIVE_OK);
1038                 case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
1039                         *permset = (entry->ae_stat.st_mode >> 3) & 7;
1040                         *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
1041                         *tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
1042                         entry->acl_state = ARCHIVE_ENTRY_ACL_OTHER;
1043                         return (ARCHIVE_OK);
1044                 case ARCHIVE_ENTRY_ACL_OTHER:
1045                         *permset = entry->ae_stat.st_mode & 7;
1046                         *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;
1047                         *tag = ARCHIVE_ENTRY_ACL_OTHER;
1048                         entry->acl_state = -1;
1049                         entry->acl_p = entry->acl_head;
1050                         return (ARCHIVE_OK);
1051                 default:
1052                         break;
1053                 }
1054         }
1055
1056         while (entry->acl_p != NULL && (entry->acl_p->type & want_type) == 0)
1057                 entry->acl_p = entry->acl_p->next;
1058         if (entry->acl_p == NULL) {
1059                 entry->acl_state = 0;
1060                 return (ARCHIVE_EOF); /* End of ACL entries. */
1061         }
1062         *type = entry->acl_p->type;
1063         *permset = entry->acl_p->permset;
1064         *tag = entry->acl_p->tag;
1065         *id = entry->acl_p->id;
1066         *name = aes_get_mbs(&entry->acl_p->name);
1067         entry->acl_p = entry->acl_p->next;
1068         return (ARCHIVE_OK);
1069 }
1070
1071 /*
1072  * Generate a text version of the ACL.  The flags parameter controls
1073  * the style of the generated ACL.
1074  */
1075 const wchar_t *
1076 archive_entry_acl_text_w(struct archive_entry *entry, int flags)
1077 {
1078         int count;
1079         int length;
1080         const wchar_t *wname;
1081         const wchar_t *prefix;
1082         wchar_t separator;
1083         struct ae_acl *ap;
1084         int id;
1085         wchar_t *wp;
1086
1087         if (entry->acl_text_w != NULL) {
1088                 free (entry->acl_text_w);
1089                 entry->acl_text_w = NULL;
1090         }
1091
1092         separator = L',';
1093         count = 0;
1094         length = 0;
1095         ap = entry->acl_head;
1096         while (ap != NULL) {
1097                 if ((ap->type & flags) != 0) {
1098                         count++;
1099                         if ((flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) &&
1100                             (ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT))
1101                                 length += 8; /* "default:" */
1102                         length += 5; /* tag name */
1103                         length += 1; /* colon */
1104                         wname = aes_get_wcs(&ap->name);
1105                         if (wname != NULL)
1106                                 length += wcslen(wname);
1107                         else
1108                                 length += sizeof(uid_t) * 3 + 1;
1109                         length ++; /* colon */
1110                         length += 3; /* rwx */
1111                         length += 1; /* colon */
1112                         length += max(sizeof(uid_t), sizeof(gid_t)) * 3 + 1;
1113                         length ++; /* newline */
1114                 }
1115                 ap = ap->next;
1116         }
1117
1118         if (count > 0 && ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)) {
1119                 length += 10; /* "user::rwx\n" */
1120                 length += 11; /* "group::rwx\n" */
1121                 length += 11; /* "other::rwx\n" */
1122         }
1123
1124         if (count == 0)
1125                 return (NULL);
1126
1127         /* Now, allocate the string and actually populate it. */
1128         wp = entry->acl_text_w = (wchar_t *)malloc(length * sizeof(wchar_t));
1129         if (wp == NULL)
1130                 __archive_errx(1, "No memory to generate the text version of the ACL");
1131         count = 0;
1132         if ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
1133                 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_USER_OBJ, NULL,
1134                     entry->ae_stat.st_mode & 0700, -1);
1135                 *wp++ = ',';
1136                 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_GROUP_OBJ, NULL,
1137                     entry->ae_stat.st_mode & 0070, -1);
1138                 *wp++ = ',';
1139                 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_OTHER, NULL,
1140                     entry->ae_stat.st_mode & 0007, -1);
1141                 count += 3;
1142
1143                 ap = entry->acl_head;
1144                 while (ap != NULL) {
1145                         if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) {
1146                                 wname = aes_get_wcs(&ap->name);
1147                                 *wp++ = separator;
1148                                 if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)
1149                                         id = ap->id;
1150                                 else
1151                                         id = -1;
1152                                 append_entry_w(&wp, NULL, ap->tag, wname,
1153                                     ap->permset, id);
1154                                 count++;
1155                         }
1156                         ap = ap->next;
1157                 }
1158         }
1159
1160
1161         if ((flags & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0) {
1162                 if (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT)
1163                         prefix = L"default:";
1164                 else
1165                         prefix = NULL;
1166                 ap = entry->acl_head;
1167                 count = 0;
1168                 while (ap != NULL) {
1169                         if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0) {
1170                                 wname = aes_get_wcs(&ap->name);
1171                                 if (count > 0)
1172                                         *wp++ = separator;
1173                                 if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID)
1174                                         id = ap->id;
1175                                 else
1176                                         id = -1;
1177                                 append_entry_w(&wp, prefix, ap->tag,
1178                                     wname, ap->permset, id);
1179                                 count ++;
1180                         }
1181                         ap = ap->next;
1182                 }
1183         }
1184
1185         return (entry->acl_text_w);
1186 }
1187
1188 static void
1189 append_id_w(wchar_t **wp, int id)
1190 {
1191         if (id < 0)
1192                 id = 0;
1193         if (id > 9)
1194                 append_id_w(wp, id / 10);
1195         *(*wp)++ = L"0123456789"[id % 10];
1196 }
1197
1198 static void
1199 append_entry_w(wchar_t **wp, const wchar_t *prefix, int tag,
1200     const wchar_t *wname, int perm, int id)
1201 {
1202         if (prefix != NULL) {
1203                 wcscpy(*wp, prefix);
1204                 *wp += wcslen(*wp);
1205         }
1206         switch (tag) {
1207         case ARCHIVE_ENTRY_ACL_USER_OBJ:
1208                 wname = NULL;
1209                 id = -1;
1210                 /* FALL THROUGH */
1211         case ARCHIVE_ENTRY_ACL_USER:
1212                 wcscpy(*wp, L"user");
1213                 break;
1214         case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
1215                 wname = NULL;
1216                 id = -1;
1217                 /* FALL THROUGH */
1218         case ARCHIVE_ENTRY_ACL_GROUP:
1219                 wcscpy(*wp, L"group");
1220                 break;
1221         case ARCHIVE_ENTRY_ACL_MASK:
1222                 wcscpy(*wp, L"mask");
1223                 wname = NULL;
1224                 id = -1;
1225                 break;
1226         case ARCHIVE_ENTRY_ACL_OTHER:
1227                 wcscpy(*wp, L"other");
1228                 wname = NULL;
1229                 id = -1;
1230                 break;
1231         }
1232         *wp += wcslen(*wp);
1233         *(*wp)++ = L':';
1234         if (wname != NULL) {
1235                 wcscpy(*wp, wname);
1236                 *wp += wcslen(*wp);
1237         } else if (tag == ARCHIVE_ENTRY_ACL_USER
1238             || tag == ARCHIVE_ENTRY_ACL_GROUP) {
1239                 append_id_w(wp, id);
1240                 id = -1;
1241         }
1242         *(*wp)++ = L':';
1243         *(*wp)++ = (perm & 0444) ? L'r' : L'-';
1244         *(*wp)++ = (perm & 0222) ? L'w' : L'-';
1245         *(*wp)++ = (perm & 0111) ? L'x' : L'-';
1246         if (id != -1) {
1247                 *(*wp)++ = L':';
1248                 append_id_w(wp, id);
1249         }
1250         **wp = L'\0';
1251 }
1252
1253 /*
1254  * Parse a textual ACL.  This automatically recognizes and supports
1255  * extensions described above.  The 'type' argument is used to
1256  * indicate the type that should be used for any entries not
1257  * explicitly marked as "default:".
1258  */
1259 int
1260 __archive_entry_acl_parse_w(struct archive_entry *entry,
1261     const wchar_t *text, int default_type)
1262 {
1263         struct {
1264                 const wchar_t *start;
1265                 const wchar_t *end;
1266         } field[4];
1267
1268         int fields;
1269         int type, tag, permset, id;
1270         const wchar_t *p;
1271         wchar_t sep;
1272
1273         while (text != NULL  &&  *text != L'\0') {
1274                 /*
1275                  * Parse the fields out of the next entry,
1276                  * advance 'text' to start of next entry.
1277                  */
1278                 fields = 0;
1279                 do {
1280                         const wchar_t *start, *end;
1281                         next_field_w(&text, &start, &end, &sep);
1282                         if (fields < 4) {
1283                                 field[fields].start = start;
1284                                 field[fields].end = end;
1285                         }
1286                         ++fields;
1287                 } while (sep == L':');
1288
1289                 if (fields < 3)
1290                         return (ARCHIVE_WARN);
1291
1292                 /* Check for a numeric ID in field 1 or 3. */
1293                 id = -1;
1294                 isint_w(field[1].start, field[1].end, &id);
1295                 /* Field 3 is optional. */
1296                 if (id == -1 && fields > 3)
1297                         isint_w(field[3].start, field[3].end, &id);
1298
1299                 /* Parse the permissions from field 2. */
1300                 permset = 0;
1301                 p = field[2].start;
1302                 while (p < field[2].end) {
1303                         switch (*p++) {
1304                         case 'r': case 'R':
1305                                 permset |= ARCHIVE_ENTRY_ACL_READ;
1306                                 break;
1307                         case 'w': case 'W':
1308                                 permset |= ARCHIVE_ENTRY_ACL_WRITE;
1309                                 break;
1310                         case 'x': case 'X':
1311                                 permset |= ARCHIVE_ENTRY_ACL_EXECUTE;
1312                                 break;
1313                         case '-':
1314                                 break;
1315                         default:
1316                                 return (ARCHIVE_WARN);
1317                         }
1318                 }
1319
1320                 /*
1321                  * Solaris extension:  "defaultuser::rwx" is the
1322                  * default ACL corresponding to "user::rwx", etc.
1323                  */
1324                 if (field[0].end-field[0].start > 7
1325                     && wmemcmp(field[0].start, L"default", 7) == 0) {
1326                         type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;
1327                         field[0].start += 7;
1328                 } else
1329                         type = default_type;
1330
1331                 if (prefix_w(field[0].start, field[0].end, L"user")) {
1332                         if (id != -1 || field[1].start < field[1].end)
1333                                 tag = ARCHIVE_ENTRY_ACL_USER;
1334                         else
1335                                 tag = ARCHIVE_ENTRY_ACL_USER_OBJ;
1336                 } else if (prefix_w(field[0].start, field[0].end, L"group")) {
1337                         if (id != -1 || field[1].start < field[1].end)
1338                                 tag = ARCHIVE_ENTRY_ACL_GROUP;
1339                         else
1340                                 tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ;
1341                 } else if (prefix_w(field[0].start, field[0].end, L"other")) {
1342                         if (id != -1 || field[1].start < field[1].end)
1343                                 return (ARCHIVE_WARN);
1344                         tag = ARCHIVE_ENTRY_ACL_OTHER;
1345                 } else if (prefix_w(field[0].start, field[0].end, L"mask")) {
1346                         if (id != -1 || field[1].start < field[1].end)
1347                                 return (ARCHIVE_WARN);
1348                         tag = ARCHIVE_ENTRY_ACL_MASK;
1349                 } else
1350                         return (ARCHIVE_WARN);
1351
1352                 /* Add entry to the internal list. */
1353                 archive_entry_acl_add_entry_w_len(entry, type, permset,
1354                     tag, id, field[1].start, field[1].end - field[1].start);
1355         }
1356         return (ARCHIVE_OK);
1357 }
1358
1359 /*
1360  * extended attribute handling
1361  */
1362
1363 void
1364 archive_entry_xattr_clear(struct archive_entry *entry)
1365 {
1366         struct ae_xattr *xp;
1367
1368         while (entry->xattr_head != NULL) {
1369                 xp = entry->xattr_head->next;
1370                 free(entry->xattr_head->name);
1371                 free(entry->xattr_head->value);
1372                 free(entry->xattr_head);
1373                 entry->xattr_head = xp;
1374         }
1375
1376         entry->xattr_head = NULL;
1377 }
1378
1379 void
1380 archive_entry_xattr_add_entry(struct archive_entry *entry,
1381         const char *name, const void *value, size_t size)
1382 {
1383         struct ae_xattr *xp;
1384
1385         for (xp = entry->xattr_head; xp != NULL; xp = xp->next)
1386                 ;
1387
1388         if ((xp = (struct ae_xattr *)malloc(sizeof(struct ae_xattr))) == NULL)
1389                 /* XXX Error XXX */
1390                 return;
1391
1392         xp->name = strdup(name);
1393         if ((xp->value = malloc(size)) != NULL) {
1394                 memcpy(xp->value, value, size);
1395                 xp->size = size;
1396         } else
1397                 xp->size = 0;
1398
1399         xp->next = entry->xattr_head;
1400         entry->xattr_head = xp;
1401 }
1402
1403
1404 /*
1405  * returns number of the extended attribute entries
1406  */
1407 int
1408 archive_entry_xattr_count(struct archive_entry *entry)
1409 {
1410         struct ae_xattr *xp;
1411         int count = 0;
1412
1413         for (xp = entry->xattr_head; xp != NULL; xp = xp->next)
1414                 count++;
1415
1416         return count;
1417 }
1418
1419 int
1420 archive_entry_xattr_reset(struct archive_entry * entry)
1421 {
1422         entry->xattr_p = entry->xattr_head;
1423
1424         return archive_entry_xattr_count(entry);
1425 }
1426
1427 int
1428 archive_entry_xattr_next(struct archive_entry * entry,
1429         const char **name, const void **value, size_t *size)
1430 {
1431         if (entry->xattr_p) {
1432                 *name = entry->xattr_p->name;
1433                 *value = entry->xattr_p->value;
1434                 *size = entry->xattr_p->size;
1435
1436                 entry->xattr_p = entry->xattr_p->next;
1437
1438                 return (ARCHIVE_OK);
1439         } else {
1440                 *name = NULL;
1441                 *name = NULL;
1442                 *size = (size_t)0;
1443                 return (ARCHIVE_WARN);
1444         }
1445 }
1446
1447 /*
1448  * end of xattr handling
1449  */
1450
1451 /*
1452  * Parse a string to a positive decimal integer.  Returns true if
1453  * the string is non-empty and consists only of decimal digits,
1454  * false otherwise.
1455  */
1456 static int
1457 isint_w(const wchar_t *start, const wchar_t *end, int *result)
1458 {
1459         int n = 0;
1460         if (start >= end)
1461                 return (0);
1462         while (start < end) {
1463                 if (*start < '0' || *start > '9')
1464                         return (0);
1465                 if (n > (INT_MAX / 10))
1466                         n = INT_MAX;
1467                 else {
1468                         n *= 10;
1469                         n += *start - '0';
1470                 }
1471                 start++;
1472         }
1473         *result = n;
1474         return (1);
1475 }
1476
1477 /*
1478  * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]".  *wp is updated
1479  * to point to just after the separator.  *start points to the first
1480  * character of the matched text and *end just after the last
1481  * character of the matched identifier.  In particular *end - *start
1482  * is the length of the field body, not including leading or trailing
1483  * whitespace.
1484  */
1485 static void
1486 next_field_w(const wchar_t **wp, const wchar_t **start,
1487     const wchar_t **end, wchar_t *sep)
1488 {
1489         /* Skip leading whitespace to find start of field. */
1490         while (**wp == L' ' || **wp == L'\t' || **wp == L'\n') {
1491                 (*wp)++;
1492         }
1493         *start = *wp;
1494
1495         /* Scan for the separator. */
1496         while (**wp != L'\0' && **wp != L',' && **wp != L':' &&
1497             **wp != L'\n') {
1498                 (*wp)++;
1499         }
1500         *sep = **wp;
1501
1502         /* Trim trailing whitespace to locate end of field. */
1503         *end = *wp - 1;
1504         while (**end == L' ' || **end == L'\t' || **end == L'\n') {
1505                 (*end)--;
1506         }
1507         (*end)++;
1508
1509         /* Adjust scanner location. */
1510         if (**wp != L'\0')
1511                 (*wp)++;
1512 }
1513
1514 /*
1515  * Return true if the characters [start...end) are a prefix of 'test'.
1516  * This makes it easy to handle the obvious abbreviations: 'u' for 'user', etc.
1517  */
1518 static int
1519 prefix_w(const wchar_t *start, const wchar_t *end, const wchar_t *test)
1520 {
1521         if (start == end)
1522                 return (0);
1523
1524         if (*start++ != *test++)
1525                 return (0);
1526
1527         while (start < end  &&  *start++ == *test++)
1528                 ;
1529
1530         if (start < end)
1531                 return (0);
1532
1533         return (1);
1534 }
1535
1536
1537 /*
1538  * Following code is modified from UC Berkeley sources, and
1539  * is subject to the following copyright notice.
1540  */
1541
1542 /*-
1543  * Copyright (c) 1993
1544  *      The Regents of the University of California.  All rights reserved.
1545  *
1546  * Redistribution and use in source and binary forms, with or without
1547  * modification, are permitted provided that the following conditions
1548  * are met:
1549  * 1. Redistributions of source code must retain the above copyright
1550  *    notice, this list of conditions and the following disclaimer.
1551  * 2. Redistributions in binary form must reproduce the above copyright
1552  *    notice, this list of conditions and the following disclaimer in the
1553  *    documentation and/or other materials provided with the distribution.
1554  * 4. Neither the name of the University nor the names of its contributors
1555  *    may be used to endorse or promote products derived from this software
1556  *    without specific prior written permission.
1557  *
1558  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
1559  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1560  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1561  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
1562  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1563  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1564  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1565  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1566  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1567  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1568  * SUCH DAMAGE.
1569  */
1570
1571 static struct flag {
1572         const char      *name;
1573         const wchar_t   *wname;
1574         unsigned long    set;
1575         unsigned long    clear;
1576 } flags[] = {
1577         /* Preferred (shorter) names per flag first, all prefixed by "no" */
1578 #ifdef SF_APPEND
1579         { "nosappnd",   L"nosappnd",            SF_APPEND,      0 },
1580         { "nosappend",  L"nosappend",           SF_APPEND,      0 },
1581 #endif
1582 #ifdef  EXT2_APPEND_FL                          /* 'a' */
1583         { "nosappnd",   L"nosappnd",            EXT2_APPEND_FL, 0 },
1584         { "nosappend",  L"nosappend",           EXT2_APPEND_FL, 0 },
1585 #endif
1586 #ifdef SF_ARCHIVED
1587         { "noarch",     L"noarch",              SF_ARCHIVED,    0 },
1588         { "noarchived", L"noarchived",          SF_ARCHIVED,    0 },
1589 #endif
1590 #ifdef SF_IMMUTABLE
1591         { "noschg",     L"noschg",              SF_IMMUTABLE,   0 },
1592         { "noschange",  L"noschange",           SF_IMMUTABLE,   0 },
1593         { "nosimmutable",       L"nosimmutable",        SF_IMMUTABLE,   0 },
1594 #endif
1595 #ifdef EXT2_IMMUTABLE_FL                        /* 'i' */
1596         { "noschg",     L"noschg",              EXT2_IMMUTABLE_FL,      0 },
1597         { "noschange",  L"noschange",           EXT2_IMMUTABLE_FL,      0 },
1598         { "nosimmutable",       L"nosimmutable",        EXT2_IMMUTABLE_FL,      0 },
1599 #endif
1600 #ifdef SF_NOUNLINK
1601         { "nosunlnk",   L"nosunlnk",            SF_NOUNLINK,    0 },
1602         { "nosunlink",  L"nosunlink",           SF_NOUNLINK,    0 },
1603 #endif
1604 #ifdef SF_SNAPSHOT
1605         { "nosnapshot", L"nosnapshot",  SF_SNAPSHOT,    0 },
1606 #endif
1607 #ifdef UF_APPEND
1608         { "nouappnd",   L"nouappnd",            UF_APPEND,      0 },
1609         { "nouappend",  L"nouappend",           UF_APPEND,      0 },
1610 #endif
1611 #ifdef UF_IMMUTABLE
1612         { "nouchg",     L"nouchg",              UF_IMMUTABLE,   0 },
1613         { "nouchange",  L"nouchange",           UF_IMMUTABLE,   0 },
1614         { "nouimmutable",       L"nouimmutable",        UF_IMMUTABLE,   0 },
1615 #endif
1616 #ifdef UF_NODUMP
1617         { "nodump",     L"nodump",              0,              UF_NODUMP},
1618 #endif
1619 #ifdef EXT2_NODUMP_FL                           /* 'd' */
1620         { "nodump",     L"nodump",              0,              EXT2_NODUMP_FL},
1621 #endif
1622 #ifdef UF_OPAQUE
1623         { "noopaque",   L"noopaque",            UF_OPAQUE,      0 },
1624 #endif
1625 #ifdef UF_NOUNLINK
1626         { "nouunlnk",   L"nouunlnk",            UF_NOUNLINK,    0 },
1627         { "nouunlink",  L"nouunlink",           UF_NOUNLINK,    0 },
1628 #endif
1629 #ifdef EXT2_COMPR_FL                            /* 'c' */
1630         { "nocompress", L"nocompress",          EXT2_COMPR_FL,  0 },
1631 #endif
1632
1633 #ifdef EXT2_NOATIME_FL                          /* 'A' */
1634         { "noatime",    L"noatime",             0,              EXT2_NOATIME_FL},
1635 #endif
1636         { NULL,         NULL,                   0,              0 }
1637 };
1638
1639 /*
1640  * fflagstostr --
1641  *      Convert file flags to a comma-separated string.  If no flags
1642  *      are set, return the empty string.
1643  */
1644 char *
1645 ae_fflagstostr(unsigned long bitset, unsigned long bitclear)
1646 {
1647         char *string, *dp;
1648         const char *sp;
1649         unsigned long bits;
1650         struct flag *flag;
1651         int     length;
1652
1653         bits = bitset | bitclear;
1654         length = 0;
1655         for (flag = flags; flag->name != NULL; flag++)
1656                 if (bits & (flag->set | flag->clear)) {
1657                         length += strlen(flag->name) + 1;
1658                         bits &= ~(flag->set | flag->clear);
1659                 }
1660
1661         if (length == 0)
1662                 return (NULL);
1663         string = (char *)malloc(length);
1664         if (string == NULL)
1665                 return (NULL);
1666
1667         dp = string;
1668         for (flag = flags; flag->name != NULL; flag++) {
1669                 if (bitset & flag->set || bitclear & flag->clear) {
1670                         sp = flag->name + 2;
1671                 } else if (bitset & flag->clear  ||  bitclear & flag->set) {
1672                         sp = flag->name;
1673                 } else
1674                         continue;
1675                 bitset &= ~(flag->set | flag->clear);
1676                 bitclear &= ~(flag->set | flag->clear);
1677                 if (dp > string)
1678                         *dp++ = ',';
1679                 while ((*dp++ = *sp++) != '\0')
1680                         ;
1681                 dp--;
1682         }
1683
1684         *dp = '\0';
1685         return (string);
1686 }
1687
1688 /*
1689  * wcstofflags --
1690  *      Take string of arguments and return file flags.  This
1691  *      version works a little differently than strtofflags(3).
1692  *      In particular, it always tests every token, skipping any
1693  *      unrecognized tokens.  It returns a pointer to the first
1694  *      unrecognized token, or NULL if every token was recognized.
1695  *      This version is also const-correct and does not modify the
1696  *      provided string.
1697  */
1698 const wchar_t *
1699 ae_wcstofflags(const wchar_t *s, unsigned long *setp, unsigned long *clrp)
1700 {
1701         const wchar_t *start, *end;
1702         struct flag *flag;
1703         unsigned long set, clear;
1704         const wchar_t *failed;
1705
1706         set = clear = 0;
1707         start = s;
1708         failed = NULL;
1709         /* Find start of first token. */
1710         while (*start == L'\t'  ||  *start == L' '  ||  *start == L',')
1711                 start++;
1712         while (*start != L'\0') {
1713                 /* Locate end of token. */
1714                 end = start;
1715                 while (*end != L'\0'  &&  *end != L'\t'  &&
1716                     *end != L' '  &&  *end != L',')
1717                         end++;
1718                 for (flag = flags; flag->wname != NULL; flag++) {
1719                         if (wmemcmp(start, flag->wname, end - start) == 0) {
1720                                 /* Matched "noXXXX", so reverse the sense. */
1721                                 clear |= flag->set;
1722                                 set |= flag->clear;
1723                                 break;
1724                         } else if (wmemcmp(start, flag->wname + 2, end - start)
1725                             == 0) {
1726                                 /* Matched "XXXX", so don't reverse. */
1727                                 set |= flag->set;
1728                                 clear |= flag->clear;
1729                                 break;
1730                         }
1731                 }
1732                 /* Ignore unknown flag names. */
1733                 if (flag->wname == NULL  &&  failed == NULL)
1734                         failed = start;
1735
1736                 /* Find start of next token. */
1737                 start = end;
1738                 while (*start == L'\t'  ||  *start == L' '  ||  *start == L',')
1739                         start++;
1740
1741         }
1742
1743         if (setp)
1744                 *setp = set;
1745         if (clrp)
1746                 *clrp = clear;
1747
1748         /* Return location of first failure. */
1749         return (failed);
1750 }
1751
1752
1753 #ifdef TEST
1754 #include <stdio.h>
1755 int
1756 main(int argc, char **argv)
1757 {
1758         struct archive_entry *entry = archive_entry_new();
1759         unsigned long set, clear;
1760         const wchar_t *remainder;
1761
1762         remainder = archive_entry_copy_fflags_text_w(entry, L"nosappnd dump archive,,,,,,,");
1763         archive_entry_fflags(entry, &set, &clear);
1764
1765         wprintf(L"set=0x%lX clear=0x%lX remainder='%ls'\n", set, clear, remainder);
1766
1767         wprintf(L"new flags='%s'\n", archive_entry_fflags_text(entry));
1768         return (0);
1769 }
1770 #endif