Merge from vendor branch LIBARCHIVE:
[dragonfly.git] / 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