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