2 * Copyright (c) 2003-2007 Tim Kientzle
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
26 #include "archive_platform.h"
27 __FBSDID("$FreeBSD: src/lib/libarchive/archive_entry.c,v 1.52 2008/05/26 17:00:22 kientzle Exp $");
29 #ifdef HAVE_SYS_STAT_H
32 #ifdef HAVE_SYS_TYPES_H
33 #include <sys/types.h>
36 #include <sys/mkdev.h>
38 #ifdef MAJOR_IN_SYSMACROS
39 #include <sys/sysmacros.h>
42 #ifdef HAVE_EXT2FS_EXT2_FS_H
43 #include <ext2fs/ext2_fs.h> /* for Linux file flags */
48 #ifdef HAVE_LINUX_FS_H
49 #include <linux/fs.h> /* for Linux file flags */
51 #ifdef HAVE_LINUX_EXT2_FS_H
52 #include <linux/ext2_fs.h> /* for Linux file flags */
67 #include "archive_entry.h"
68 #include "archive_private.h"
69 #include "archive_entry_private.h"
72 #define max(a, b) ((a)>(b)?(a):(b))
74 /* Play games to come up with a suitable makedev() definition. */
77 #include <sys/netmgr.h>
78 #define ae_makedev(maj, min) makedev(ND_LOCAL_NODE, (maj), (min))
80 /* There's a "makedev" macro. */
81 #define ae_makedev(maj, min) makedev((maj), (min))
82 #elif defined mkdev || defined _WIN32 || defined __WIN32__
84 #define ae_makedev(maj, min) mkdev((maj), (min))
86 /* There's a "makedev" function. */
87 #define ae_makedev(maj, min) makedev((maj), (min))
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 int aes_set_mbs(struct aes
*, const char *mbs
);
95 static int aes_copy_mbs(struct aes
*, const char *mbs
);
96 /* static void aes_set_wcs(struct aes *, const wchar_t *wcs); */
97 static int aes_copy_wcs(struct aes
*, const wchar_t *wcs
);
98 static int aes_copy_wcs_len(struct aes
*, const wchar_t *wcs
, size_t);
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 const char *ae_strtofflags(const char *stringp
,
104 unsigned long *setp
, unsigned long *clrp
);
105 static void append_entry_w(wchar_t **wp
, const wchar_t *prefix
, int tag
,
106 const wchar_t *wname
, int perm
, int id
);
107 static void append_id_w(wchar_t **wp
, int id
);
109 static int acl_special(struct archive_entry
*entry
,
110 int type
, int permset
, int tag
);
111 static struct ae_acl
*acl_new_entry(struct archive_entry
*entry
,
112 int type
, int permset
, int tag
, int id
);
113 static int isint_w(const wchar_t *start
, const wchar_t *end
, int *result
);
114 static void next_field_w(const wchar_t **wp
, const wchar_t **start
,
115 const wchar_t **end
, wchar_t *sep
);
116 static int prefix_w(const wchar_t *start
, const wchar_t *end
,
117 const wchar_t *test
);
119 archive_entry_acl_add_entry_w_len(struct archive_entry
*entry
, int type
,
120 int permset
, int tag
, int id
, const wchar_t *name
, size_t);
124 static wchar_t * wcscpy(wchar_t *s1
, const wchar_t *s2
)
127 while ((*s1
= *s2
) != L
'\0')
133 static size_t wcslen(const wchar_t *s
)
135 const wchar_t *p
= s
;
142 /* Good enough for simple equality testing, but not for sorting. */
143 #define wmemcmp(a,b,i) memcmp((a), (b), (i) * sizeof(wchar_t))
146 #define wmemcpy(a,b,i) (wchar_t *)memcpy((a), (b), (i) * sizeof(wchar_t))
150 aes_clean(struct aes
*aes
)
153 free((wchar_t *)(uintptr_t)aes
->aes_wcs
);
156 archive_string_free(&(aes
->aes_mbs
));
157 archive_string_free(&(aes
->aes_utf8
));
162 aes_copy(struct aes
*dest
, struct aes
*src
)
166 dest
->aes_set
= src
->aes_set
;
167 archive_string_copy(&(dest
->aes_mbs
), &(src
->aes_mbs
));
168 archive_string_copy(&(dest
->aes_utf8
), &(src
->aes_utf8
));
170 if (src
->aes_wcs
!= NULL
) {
171 wp
= (wchar_t *)malloc((wcslen(src
->aes_wcs
) + 1)
174 __archive_errx(1, "No memory for aes_copy()");
175 wcscpy(wp
, src
->aes_wcs
);
181 aes_get_utf8(struct aes
*aes
)
183 if (aes
->aes_set
& AES_SET_UTF8
)
184 return (aes
->aes_utf8
.s
);
185 if ((aes
->aes_set
& AES_SET_WCS
)
186 && archive_strappend_w_utf8(&(aes
->aes_utf8
), aes
->aes_wcs
) != NULL
) {
187 aes
->aes_set
|= AES_SET_UTF8
;
188 return (aes
->aes_utf8
.s
);
194 aes_get_mbs(struct aes
*aes
)
196 /* If we already have an MBS form, return that immediately. */
197 if (aes
->aes_set
& AES_SET_MBS
)
198 return (aes
->aes_mbs
.s
);
199 /* If there's a WCS form, try converting with the native locale. */
200 if ((aes
->aes_set
& AES_SET_WCS
)
201 && archive_strappend_w_mbs(&(aes
->aes_mbs
), aes
->aes_wcs
) != NULL
) {
202 aes
->aes_set
|= AES_SET_MBS
;
203 return (aes
->aes_mbs
.s
);
205 /* We'll use UTF-8 for MBS if all else fails. */
206 return (aes_get_utf8(aes
));
209 static const wchar_t *
210 aes_get_wcs(struct aes
*aes
)
215 /* Return WCS form if we already have it. */
216 if (aes
->aes_set
& AES_SET_WCS
)
217 return (aes
->aes_wcs
);
219 if (aes
->aes_set
& AES_SET_MBS
) {
220 /* Try converting MBS to WCS using native locale. */
222 * No single byte will be more than one wide character,
223 * so this length estimate will always be big enough.
225 size_t wcs_length
= aes
->aes_mbs
.length
;
227 w
= (wchar_t *)malloc((wcs_length
+ 1) * sizeof(wchar_t));
229 __archive_errx(1, "No memory for aes_get_wcs()");
230 r
= mbstowcs(w
, aes
->aes_mbs
.s
, wcs_length
);
233 aes
->aes_set
|= AES_SET_WCS
;
234 return (aes
->aes_wcs
= w
);
239 if (aes
->aes_set
& AES_SET_UTF8
) {
240 /* Try converting UTF8 to WCS. */
241 aes
->aes_wcs
= __archive_string_utf8_w(&(aes
->aes_utf8
));
242 aes
->aes_set
|= AES_SET_WCS
;
243 return (aes
->aes_wcs
);
249 aes_set_mbs(struct aes
*aes
, const char *mbs
)
251 return (aes_copy_mbs(aes
, mbs
));
255 aes_copy_mbs(struct aes
*aes
, const char *mbs
)
261 aes
->aes_set
= AES_SET_MBS
; /* Only MBS form is set now. */
262 archive_strcpy(&(aes
->aes_mbs
), mbs
);
263 archive_string_empty(&(aes
->aes_utf8
));
265 free((wchar_t *)(uintptr_t)aes
->aes_wcs
);
272 * The 'update' form tries to proactively update all forms of
273 * this string (WCS and MBS) and returns an error if any of
274 * them fail. This is used by the 'pax' handler, for instance,
275 * to detect and report character-conversion failures early while
276 * still allowing clients to get potentially useful values from
277 * the more tolerant lazy conversions. (get_mbs and get_wcs will
278 * strive to give the user something useful, so you can get hopefully
279 * usable values even if some of the character conversions are failing.)
282 aes_update_utf8(struct aes
*aes
, const char *utf8
)
286 return (1); /* Succeeded in clearing everything. */
289 /* Save the UTF8 string. */
290 archive_strcpy(&(aes
->aes_utf8
), utf8
);
292 /* Empty the mbs and wcs strings. */
293 archive_string_empty(&(aes
->aes_mbs
));
295 free((wchar_t *)(uintptr_t)aes
->aes_wcs
);
299 aes
->aes_set
= AES_SET_UTF8
; /* Only UTF8 is set now. */
301 /* TODO: We should just do a direct UTF-8 to MBS conversion
302 * here. That would be faster, use less space, and give the
303 * same information. (If a UTF-8 to MBS conversion succeeds,
304 * then UTF-8->WCS and Unicode->MBS conversions will both
307 /* Try converting UTF8 to WCS, return false on failure. */
308 aes
->aes_wcs
= __archive_string_utf8_w(&(aes
->aes_utf8
));
309 if (aes
->aes_wcs
== NULL
)
311 aes
->aes_set
= AES_SET_UTF8
| AES_SET_WCS
; /* Both UTF8 and WCS set. */
313 /* Try converting WCS to MBS, return false on failure. */
314 if (archive_strappend_w_mbs(&(aes
->aes_mbs
), aes
->aes_wcs
) == NULL
)
316 aes
->aes_set
= AES_SET_UTF8
| AES_SET_WCS
| AES_SET_MBS
;
318 /* All conversions succeeded. */
323 aes_copy_wcs(struct aes
*aes
, const wchar_t *wcs
)
325 return aes_copy_wcs_len(aes
, wcs
, wcs
== NULL
? 0 : wcslen(wcs
));
329 aes_copy_wcs_len(struct aes
*aes
, const wchar_t *wcs
, size_t len
)
337 aes
->aes_set
= AES_SET_WCS
; /* Only WCS form set. */
338 archive_string_empty(&(aes
->aes_mbs
));
339 archive_string_empty(&(aes
->aes_utf8
));
341 free((wchar_t *)(uintptr_t)aes
->aes_wcs
);
344 w
= (wchar_t *)malloc((len
+ 1) * sizeof(wchar_t));
346 __archive_errx(1, "No memory for aes_copy_wcs()");
347 wmemcpy(w
, wcs
, len
);
353 /****************************************************************************
357 ****************************************************************************/
359 struct archive_entry
*
360 archive_entry_clear(struct archive_entry
*entry
)
364 aes_clean(&entry
->ae_fflags_text
);
365 aes_clean(&entry
->ae_gname
);
366 aes_clean(&entry
->ae_hardlink
);
367 aes_clean(&entry
->ae_pathname
);
368 aes_clean(&entry
->ae_symlink
);
369 aes_clean(&entry
->ae_uname
);
370 archive_entry_acl_clear(entry
);
371 archive_entry_xattr_clear(entry
);
373 memset(entry
, 0, sizeof(*entry
));
377 struct archive_entry
*
378 archive_entry_clone(struct archive_entry
*entry
)
380 struct archive_entry
*entry2
;
381 struct ae_acl
*ap
, *ap2
;
384 /* Allocate new structure and copy over all of the fields. */
385 entry2
= (struct archive_entry
*)malloc(sizeof(*entry2
));
388 memset(entry2
, 0, sizeof(*entry2
));
389 entry2
->ae_stat
= entry
->ae_stat
;
390 entry2
->ae_fflags_set
= entry
->ae_fflags_set
;
391 entry2
->ae_fflags_clear
= entry
->ae_fflags_clear
;
393 aes_copy(&entry2
->ae_fflags_text
, &entry
->ae_fflags_text
);
394 aes_copy(&entry2
->ae_gname
, &entry
->ae_gname
);
395 aes_copy(&entry2
->ae_hardlink
, &entry
->ae_hardlink
);
396 aes_copy(&entry2
->ae_pathname
, &entry
->ae_pathname
);
397 aes_copy(&entry2
->ae_symlink
, &entry
->ae_symlink
);
398 entry2
->ae_hardlinkset
= entry
->ae_hardlinkset
;
399 entry2
->ae_symlinkset
= entry
->ae_symlinkset
;
400 aes_copy(&entry2
->ae_uname
, &entry
->ae_uname
);
402 /* Copy ACL data over. */
403 ap
= entry
->acl_head
;
405 ap2
= acl_new_entry(entry2
,
406 ap
->type
, ap
->permset
, ap
->tag
, ap
->id
);
408 aes_copy(&ap2
->name
, &ap
->name
);
412 /* Copy xattr data over. */
413 xp
= entry
->xattr_head
;
415 archive_entry_xattr_add_entry(entry2
,
416 xp
->name
, xp
->value
, xp
->size
);
424 archive_entry_free(struct archive_entry
*entry
)
426 archive_entry_clear(entry
);
430 struct archive_entry
*
431 archive_entry_new(void)
433 struct archive_entry
*entry
;
435 entry
= (struct archive_entry
*)malloc(sizeof(*entry
));
438 memset(entry
, 0, sizeof(*entry
));
443 * Functions for reading fields from an archive_entry.
447 archive_entry_atime(struct archive_entry
*entry
)
449 return (entry
->ae_stat
.aest_atime
);
453 archive_entry_atime_nsec(struct archive_entry
*entry
)
455 return (entry
->ae_stat
.aest_atime_nsec
);
459 archive_entry_ctime(struct archive_entry
*entry
)
461 return (entry
->ae_stat
.aest_ctime
);
465 archive_entry_ctime_nsec(struct archive_entry
*entry
)
467 return (entry
->ae_stat
.aest_ctime_nsec
);
471 archive_entry_dev(struct archive_entry
*entry
)
473 if (entry
->ae_stat
.aest_dev_is_broken_down
)
474 return ae_makedev(entry
->ae_stat
.aest_devmajor
,
475 entry
->ae_stat
.aest_devminor
);
477 return (entry
->ae_stat
.aest_dev
);
481 archive_entry_devmajor(struct archive_entry
*entry
)
483 if (entry
->ae_stat
.aest_dev_is_broken_down
)
484 return (entry
->ae_stat
.aest_devmajor
);
486 return major(entry
->ae_stat
.aest_dev
);
490 archive_entry_devminor(struct archive_entry
*entry
)
492 if (entry
->ae_stat
.aest_dev_is_broken_down
)
493 return (entry
->ae_stat
.aest_devminor
);
495 return minor(entry
->ae_stat
.aest_dev
);
499 archive_entry_filetype(struct archive_entry
*entry
)
501 return (AE_IFMT
& entry
->ae_stat
.aest_mode
);
505 archive_entry_fflags(struct archive_entry
*entry
,
506 unsigned long *set
, unsigned long *clear
)
508 *set
= entry
->ae_fflags_set
;
509 *clear
= entry
->ae_fflags_clear
;
513 * Note: if text was provided, this just returns that text. If you
514 * really need the text to be rebuilt in a canonical form, set the
515 * text, ask for the bitmaps, then set the bitmaps. (Setting the
516 * bitmaps clears any stored text.) This design is deliberate: if
517 * we're editing archives, we don't want to discard flags just because
518 * they aren't supported on the current system. The bitmap<->text
519 * conversions are platform-specific (see below).
522 archive_entry_fflags_text(struct archive_entry
*entry
)
527 f
= aes_get_mbs(&entry
->ae_fflags_text
);
531 if (entry
->ae_fflags_set
== 0 && entry
->ae_fflags_clear
== 0)
534 p
= ae_fflagstostr(entry
->ae_fflags_set
, entry
->ae_fflags_clear
);
538 aes_copy_mbs(&entry
->ae_fflags_text
, p
);
540 f
= aes_get_mbs(&entry
->ae_fflags_text
);
545 archive_entry_gid(struct archive_entry
*entry
)
547 return (entry
->ae_stat
.aest_gid
);
551 archive_entry_gname(struct archive_entry
*entry
)
553 return (aes_get_mbs(&entry
->ae_gname
));
557 archive_entry_gname_w(struct archive_entry
*entry
)
559 return (aes_get_wcs(&entry
->ae_gname
));
563 archive_entry_hardlink(struct archive_entry
*entry
)
565 if (!entry
->ae_hardlinkset
)
567 return (aes_get_mbs(&entry
->ae_hardlink
));
571 archive_entry_hardlink_w(struct archive_entry
*entry
)
573 if (!entry
->ae_hardlinkset
)
575 return (aes_get_wcs(&entry
->ae_hardlink
));
579 archive_entry_ino(struct archive_entry
*entry
)
581 return (entry
->ae_stat
.aest_ino
);
585 archive_entry_mode(struct archive_entry
*entry
)
587 return (entry
->ae_stat
.aest_mode
);
591 archive_entry_mtime(struct archive_entry
*entry
)
593 return (entry
->ae_stat
.aest_mtime
);
597 archive_entry_mtime_nsec(struct archive_entry
*entry
)
599 return (entry
->ae_stat
.aest_mtime_nsec
);
603 archive_entry_nlink(struct archive_entry
*entry
)
605 return (entry
->ae_stat
.aest_nlink
);
609 archive_entry_pathname(struct archive_entry
*entry
)
611 return (aes_get_mbs(&entry
->ae_pathname
));
615 archive_entry_pathname_w(struct archive_entry
*entry
)
617 return (aes_get_wcs(&entry
->ae_pathname
));
621 archive_entry_rdev(struct archive_entry
*entry
)
623 if (entry
->ae_stat
.aest_rdev_is_broken_down
)
624 return ae_makedev(entry
->ae_stat
.aest_rdevmajor
,
625 entry
->ae_stat
.aest_rdevminor
);
627 return (entry
->ae_stat
.aest_rdev
);
631 archive_entry_rdevmajor(struct archive_entry
*entry
)
633 if (entry
->ae_stat
.aest_rdev_is_broken_down
)
634 return (entry
->ae_stat
.aest_rdevmajor
);
636 return major(entry
->ae_stat
.aest_rdev
);
640 archive_entry_rdevminor(struct archive_entry
*entry
)
642 if (entry
->ae_stat
.aest_rdev_is_broken_down
)
643 return (entry
->ae_stat
.aest_rdevminor
);
645 return minor(entry
->ae_stat
.aest_rdev
);
649 archive_entry_size(struct archive_entry
*entry
)
651 return (entry
->ae_stat
.aest_size
);
655 archive_entry_sourcepath(struct archive_entry
*entry
)
657 return (aes_get_mbs(&entry
->ae_sourcepath
));
661 archive_entry_symlink(struct archive_entry
*entry
)
663 if (!entry
->ae_symlinkset
)
665 return (aes_get_mbs(&entry
->ae_symlink
));
669 archive_entry_symlink_w(struct archive_entry
*entry
)
671 if (!entry
->ae_symlinkset
)
673 return (aes_get_wcs(&entry
->ae_symlink
));
677 archive_entry_uid(struct archive_entry
*entry
)
679 return (entry
->ae_stat
.aest_uid
);
683 archive_entry_uname(struct archive_entry
*entry
)
685 return (aes_get_mbs(&entry
->ae_uname
));
689 archive_entry_uname_w(struct archive_entry
*entry
)
691 return (aes_get_wcs(&entry
->ae_uname
));
695 * Functions to set archive_entry properties.
699 archive_entry_set_filetype(struct archive_entry
*entry
, unsigned int type
)
701 entry
->stat_valid
= 0;
702 entry
->ae_stat
.aest_mode
&= ~AE_IFMT
;
703 entry
->ae_stat
.aest_mode
|= AE_IFMT
& type
;
707 archive_entry_set_fflags(struct archive_entry
*entry
,
708 unsigned long set
, unsigned long clear
)
710 aes_clean(&entry
->ae_fflags_text
);
711 entry
->ae_fflags_set
= set
;
712 entry
->ae_fflags_clear
= clear
;
716 archive_entry_copy_fflags_text(struct archive_entry
*entry
,
719 aes_copy_mbs(&entry
->ae_fflags_text
, flags
);
720 return (ae_strtofflags(flags
,
721 &entry
->ae_fflags_set
, &entry
->ae_fflags_clear
));
725 archive_entry_copy_fflags_text_w(struct archive_entry
*entry
,
726 const wchar_t *flags
)
728 aes_copy_wcs(&entry
->ae_fflags_text
, flags
);
729 return (ae_wcstofflags(flags
,
730 &entry
->ae_fflags_set
, &entry
->ae_fflags_clear
));
734 archive_entry_set_gid(struct archive_entry
*entry
, gid_t g
)
736 entry
->stat_valid
= 0;
737 entry
->ae_stat
.aest_gid
= g
;
741 archive_entry_set_gname(struct archive_entry
*entry
, const char *name
)
743 aes_set_mbs(&entry
->ae_gname
, name
);
747 archive_entry_copy_gname(struct archive_entry
*entry
, const char *name
)
749 aes_copy_mbs(&entry
->ae_gname
, name
);
753 archive_entry_copy_gname_w(struct archive_entry
*entry
, const wchar_t *name
)
755 aes_copy_wcs(&entry
->ae_gname
, name
);
759 archive_entry_update_gname_utf8(struct archive_entry
*entry
, const char *name
)
761 return (aes_update_utf8(&entry
->ae_gname
, name
));
765 archive_entry_set_ino(struct archive_entry
*entry
, unsigned long ino
)
767 entry
->stat_valid
= 0;
768 entry
->ae_stat
.aest_ino
= ino
;
772 archive_entry_set_hardlink(struct archive_entry
*entry
, const char *target
)
774 aes_set_mbs(&entry
->ae_hardlink
, target
);
776 entry
->ae_hardlinkset
= 1;
780 archive_entry_copy_hardlink(struct archive_entry
*entry
, const char *target
)
782 aes_copy_mbs(&entry
->ae_hardlink
, target
);
784 entry
->ae_hardlinkset
= 1;
788 archive_entry_copy_hardlink_w(struct archive_entry
*entry
, const wchar_t *target
)
790 aes_copy_wcs(&entry
->ae_hardlink
, target
);
792 entry
->ae_hardlinkset
= 1;
796 archive_entry_set_atime(struct archive_entry
*entry
, time_t t
, long ns
)
798 entry
->stat_valid
= 0;
799 entry
->ae_stat
.aest_atime
= t
;
800 entry
->ae_stat
.aest_atime_nsec
= ns
;
804 archive_entry_set_ctime(struct archive_entry
*entry
, time_t t
, long ns
)
806 entry
->stat_valid
= 0;
807 entry
->ae_stat
.aest_ctime
= t
;
808 entry
->ae_stat
.aest_ctime_nsec
= ns
;
812 archive_entry_set_dev(struct archive_entry
*entry
, dev_t d
)
814 entry
->stat_valid
= 0;
815 entry
->ae_stat
.aest_dev_is_broken_down
= 0;
816 entry
->ae_stat
.aest_dev
= d
;
820 archive_entry_set_devmajor(struct archive_entry
*entry
, dev_t m
)
822 entry
->stat_valid
= 0;
823 entry
->ae_stat
.aest_dev_is_broken_down
= 1;
824 entry
->ae_stat
.aest_devmajor
= m
;
828 archive_entry_set_devminor(struct archive_entry
*entry
, dev_t m
)
830 entry
->stat_valid
= 0;
831 entry
->ae_stat
.aest_dev_is_broken_down
= 1;
832 entry
->ae_stat
.aest_devminor
= m
;
835 /* Set symlink if symlink is already set, else set hardlink. */
837 archive_entry_set_link(struct archive_entry
*entry
, const char *target
)
839 if (entry
->ae_symlinkset
)
840 aes_set_mbs(&entry
->ae_symlink
, target
);
842 aes_set_mbs(&entry
->ae_hardlink
, target
);
845 /* Set symlink if symlink is already set, else set hardlink. */
847 archive_entry_copy_link(struct archive_entry
*entry
, const char *target
)
849 if (entry
->ae_symlinkset
)
850 aes_copy_mbs(&entry
->ae_symlink
, target
);
852 aes_copy_mbs(&entry
->ae_hardlink
, target
);
855 /* Set symlink if symlink is already set, else set hardlink. */
857 archive_entry_copy_link_w(struct archive_entry
*entry
, const wchar_t *target
)
859 if (entry
->ae_symlinkset
)
860 aes_copy_wcs(&entry
->ae_symlink
, target
);
862 aes_copy_wcs(&entry
->ae_hardlink
, target
);
866 archive_entry_update_link_utf8(struct archive_entry
*entry
, const char *target
)
868 if (entry
->ae_symlinkset
)
869 return (aes_update_utf8(&entry
->ae_symlink
, target
));
871 return (aes_update_utf8(&entry
->ae_hardlink
, target
));
875 archive_entry_set_mode(struct archive_entry
*entry
, mode_t m
)
877 entry
->stat_valid
= 0;
878 entry
->ae_stat
.aest_mode
= m
;
882 archive_entry_set_mtime(struct archive_entry
*entry
, time_t m
, long ns
)
884 entry
->stat_valid
= 0;
885 entry
->ae_stat
.aest_mtime
= m
;
886 entry
->ae_stat
.aest_mtime_nsec
= ns
;
890 archive_entry_set_nlink(struct archive_entry
*entry
, unsigned int nlink
)
892 entry
->stat_valid
= 0;
893 entry
->ae_stat
.aest_nlink
= nlink
;
897 archive_entry_set_pathname(struct archive_entry
*entry
, const char *name
)
899 aes_set_mbs(&entry
->ae_pathname
, name
);
903 archive_entry_copy_pathname(struct archive_entry
*entry
, const char *name
)
905 aes_copy_mbs(&entry
->ae_pathname
, name
);
909 archive_entry_copy_pathname_w(struct archive_entry
*entry
, const wchar_t *name
)
911 aes_copy_wcs(&entry
->ae_pathname
, name
);
915 archive_entry_update_pathname_utf8(struct archive_entry
*entry
, const char *name
)
917 return (aes_update_utf8(&entry
->ae_pathname
, name
));
921 archive_entry_set_perm(struct archive_entry
*entry
, mode_t p
)
923 entry
->stat_valid
= 0;
924 entry
->ae_stat
.aest_mode
&= AE_IFMT
;
925 entry
->ae_stat
.aest_mode
|= ~AE_IFMT
& p
;
929 archive_entry_set_rdev(struct archive_entry
*entry
, dev_t m
)
931 entry
->stat_valid
= 0;
932 entry
->ae_stat
.aest_rdev
= m
;
933 entry
->ae_stat
.aest_rdev_is_broken_down
= 0;
937 archive_entry_set_rdevmajor(struct archive_entry
*entry
, dev_t m
)
939 entry
->stat_valid
= 0;
940 entry
->ae_stat
.aest_rdev_is_broken_down
= 1;
941 entry
->ae_stat
.aest_rdevmajor
= m
;
945 archive_entry_set_rdevminor(struct archive_entry
*entry
, dev_t m
)
947 entry
->stat_valid
= 0;
948 entry
->ae_stat
.aest_rdev_is_broken_down
= 1;
949 entry
->ae_stat
.aest_rdevminor
= m
;
953 archive_entry_set_size(struct archive_entry
*entry
, int64_t s
)
955 entry
->stat_valid
= 0;
956 entry
->ae_stat
.aest_size
= s
;
960 archive_entry_copy_sourcepath(struct archive_entry
*entry
, const char *path
)
962 aes_set_mbs(&entry
->ae_sourcepath
, path
);
966 archive_entry_set_symlink(struct archive_entry
*entry
, const char *linkname
)
968 aes_set_mbs(&entry
->ae_symlink
, linkname
);
969 if (linkname
!= NULL
)
970 entry
->ae_symlinkset
= 1;
974 archive_entry_copy_symlink(struct archive_entry
*entry
, const char *linkname
)
976 aes_copy_mbs(&entry
->ae_symlink
, linkname
);
977 if (linkname
!= NULL
)
978 entry
->ae_symlinkset
= 1;
982 archive_entry_copy_symlink_w(struct archive_entry
*entry
, const wchar_t *linkname
)
984 aes_copy_wcs(&entry
->ae_symlink
, linkname
);
985 if (linkname
!= NULL
)
986 entry
->ae_symlinkset
= 1;
990 archive_entry_set_uid(struct archive_entry
*entry
, uid_t u
)
992 entry
->stat_valid
= 0;
993 entry
->ae_stat
.aest_uid
= u
;
997 archive_entry_set_uname(struct archive_entry
*entry
, const char *name
)
999 aes_set_mbs(&entry
->ae_uname
, name
);
1003 archive_entry_copy_uname(struct archive_entry
*entry
, const char *name
)
1005 aes_copy_mbs(&entry
->ae_uname
, name
);
1009 archive_entry_copy_uname_w(struct archive_entry
*entry
, const wchar_t *name
)
1011 aes_copy_wcs(&entry
->ae_uname
, name
);
1015 archive_entry_update_uname_utf8(struct archive_entry
*entry
, const char *name
)
1017 return (aes_update_utf8(&entry
->ae_uname
, name
));
1021 * ACL management. The following would, of course, be a lot simpler
1022 * if: 1) the last draft of POSIX.1e were a really thorough and
1023 * complete standard that addressed the needs of ACL archiving and 2)
1024 * everyone followed it faithfully. Alas, neither is true, so the
1025 * following is a lot more complex than might seem necessary to the
1030 archive_entry_acl_clear(struct archive_entry
*entry
)
1034 while (entry
->acl_head
!= NULL
) {
1035 ap
= entry
->acl_head
->next
;
1036 aes_clean(&entry
->acl_head
->name
);
1037 free(entry
->acl_head
);
1038 entry
->acl_head
= ap
;
1040 if (entry
->acl_text_w
!= NULL
) {
1041 free(entry
->acl_text_w
);
1042 entry
->acl_text_w
= NULL
;
1044 entry
->acl_p
= NULL
;
1045 entry
->acl_state
= 0; /* Not counting. */
1049 * Add a single ACL entry to the internal list of ACL data.
1052 archive_entry_acl_add_entry(struct archive_entry
*entry
,
1053 int type
, int permset
, int tag
, int id
, const char *name
)
1057 if (acl_special(entry
, type
, permset
, tag
) == 0)
1059 ap
= acl_new_entry(entry
, type
, permset
, tag
, id
);
1064 if (name
!= NULL
&& *name
!= '\0')
1065 aes_copy_mbs(&ap
->name
, name
);
1067 aes_clean(&ap
->name
);
1071 * As above, but with a wide-character name.
1074 archive_entry_acl_add_entry_w(struct archive_entry
*entry
,
1075 int type
, int permset
, int tag
, int id
, const wchar_t *name
)
1077 archive_entry_acl_add_entry_w_len(entry
, type
, permset
, tag
, id
, name
, wcslen(name
));
1081 archive_entry_acl_add_entry_w_len(struct archive_entry
*entry
,
1082 int type
, int permset
, int tag
, int id
, const wchar_t *name
, size_t len
)
1086 if (acl_special(entry
, type
, permset
, tag
) == 0)
1088 ap
= acl_new_entry(entry
, type
, permset
, tag
, id
);
1093 if (name
!= NULL
&& *name
!= L
'\0' && len
> 0)
1094 aes_copy_wcs_len(&ap
->name
, name
, len
);
1096 aes_clean(&ap
->name
);
1100 * If this ACL entry is part of the standard POSIX permissions set,
1101 * store the permissions in the stat structure and return zero.
1104 acl_special(struct archive_entry
*entry
, int type
, int permset
, int tag
)
1106 if (type
== ARCHIVE_ENTRY_ACL_TYPE_ACCESS
) {
1108 case ARCHIVE_ENTRY_ACL_USER_OBJ
:
1109 entry
->ae_stat
.aest_mode
&= ~0700;
1110 entry
->ae_stat
.aest_mode
|= (permset
& 7) << 6;
1112 case ARCHIVE_ENTRY_ACL_GROUP_OBJ
:
1113 entry
->ae_stat
.aest_mode
&= ~0070;
1114 entry
->ae_stat
.aest_mode
|= (permset
& 7) << 3;
1116 case ARCHIVE_ENTRY_ACL_OTHER
:
1117 entry
->ae_stat
.aest_mode
&= ~0007;
1118 entry
->ae_stat
.aest_mode
|= permset
& 7;
1126 * Allocate and populate a new ACL entry with everything but the
1129 static struct ae_acl
*
1130 acl_new_entry(struct archive_entry
*entry
,
1131 int type
, int permset
, int tag
, int id
)
1135 if (type
!= ARCHIVE_ENTRY_ACL_TYPE_ACCESS
&&
1136 type
!= ARCHIVE_ENTRY_ACL_TYPE_DEFAULT
)
1138 if (entry
->acl_text_w
!= NULL
) {
1139 free(entry
->acl_text_w
);
1140 entry
->acl_text_w
= NULL
;
1143 /* XXX TODO: More sanity-checks on the arguments XXX */
1145 /* If there's a matching entry already in the list, overwrite it. */
1146 for (ap
= entry
->acl_head
; ap
!= NULL
; ap
= ap
->next
) {
1147 if (ap
->type
== type
&& ap
->tag
== tag
&& ap
->id
== id
) {
1148 ap
->permset
= permset
;
1153 /* Add a new entry to the list. */
1154 ap
= (struct ae_acl
*)malloc(sizeof(*ap
));
1157 memset(ap
, 0, sizeof(*ap
));
1158 ap
->next
= entry
->acl_head
;
1159 entry
->acl_head
= ap
;
1163 ap
->permset
= permset
;
1168 * Return a count of entries matching "want_type".
1171 archive_entry_acl_count(struct archive_entry
*entry
, int want_type
)
1177 ap
= entry
->acl_head
;
1178 while (ap
!= NULL
) {
1179 if ((ap
->type
& want_type
) != 0)
1184 if (count
> 0 && ((want_type
& ARCHIVE_ENTRY_ACL_TYPE_ACCESS
) != 0))
1190 * Prepare for reading entries from the ACL data. Returns a count
1191 * of entries matching "want_type", or zero if there are no
1192 * non-extended ACL entries of that type.
1195 archive_entry_acl_reset(struct archive_entry
*entry
, int want_type
)
1199 count
= archive_entry_acl_count(entry
, want_type
);
1202 * If the only entries are the three standard ones,
1203 * then don't return any ACL data. (In this case,
1204 * client can just use chmod(2) to set permissions.)
1206 if ((want_type
& ARCHIVE_ENTRY_ACL_TYPE_ACCESS
) != 0)
1212 entry
->acl_state
= ARCHIVE_ENTRY_ACL_USER_OBJ
;
1214 entry
->acl_state
= 0;
1215 entry
->acl_p
= entry
->acl_head
;
1220 * Return the next ACL entry in the list. Fake entries for the
1221 * standard permissions and include them in the returned list.
1225 archive_entry_acl_next(struct archive_entry
*entry
, int want_type
, int *type
,
1226 int *permset
, int *tag
, int *id
, const char **name
)
1232 * The acl_state is either zero (no entries available), -1
1233 * (reading from list), or an entry type (retrieve that type
1234 * from ae_stat.aest_mode).
1236 if (entry
->acl_state
== 0)
1237 return (ARCHIVE_WARN
);
1239 /* The first three access entries are special. */
1240 if ((want_type
& ARCHIVE_ENTRY_ACL_TYPE_ACCESS
) != 0) {
1241 switch (entry
->acl_state
) {
1242 case ARCHIVE_ENTRY_ACL_USER_OBJ
:
1243 *permset
= (entry
->ae_stat
.aest_mode
>> 6) & 7;
1244 *type
= ARCHIVE_ENTRY_ACL_TYPE_ACCESS
;
1245 *tag
= ARCHIVE_ENTRY_ACL_USER_OBJ
;
1246 entry
->acl_state
= ARCHIVE_ENTRY_ACL_GROUP_OBJ
;
1247 return (ARCHIVE_OK
);
1248 case ARCHIVE_ENTRY_ACL_GROUP_OBJ
:
1249 *permset
= (entry
->ae_stat
.aest_mode
>> 3) & 7;
1250 *type
= ARCHIVE_ENTRY_ACL_TYPE_ACCESS
;
1251 *tag
= ARCHIVE_ENTRY_ACL_GROUP_OBJ
;
1252 entry
->acl_state
= ARCHIVE_ENTRY_ACL_OTHER
;
1253 return (ARCHIVE_OK
);
1254 case ARCHIVE_ENTRY_ACL_OTHER
:
1255 *permset
= entry
->ae_stat
.aest_mode
& 7;
1256 *type
= ARCHIVE_ENTRY_ACL_TYPE_ACCESS
;
1257 *tag
= ARCHIVE_ENTRY_ACL_OTHER
;
1258 entry
->acl_state
= -1;
1259 entry
->acl_p
= entry
->acl_head
;
1260 return (ARCHIVE_OK
);
1266 while (entry
->acl_p
!= NULL
&& (entry
->acl_p
->type
& want_type
) == 0)
1267 entry
->acl_p
= entry
->acl_p
->next
;
1268 if (entry
->acl_p
== NULL
) {
1269 entry
->acl_state
= 0;
1275 return (ARCHIVE_EOF
); /* End of ACL entries. */
1277 *type
= entry
->acl_p
->type
;
1278 *permset
= entry
->acl_p
->permset
;
1279 *tag
= entry
->acl_p
->tag
;
1280 *id
= entry
->acl_p
->id
;
1281 *name
= aes_get_mbs(&entry
->acl_p
->name
);
1282 entry
->acl_p
= entry
->acl_p
->next
;
1283 return (ARCHIVE_OK
);
1287 * Generate a text version of the ACL. The flags parameter controls
1288 * the style of the generated ACL.
1291 archive_entry_acl_text_w(struct archive_entry
*entry
, int flags
)
1295 const wchar_t *wname
;
1296 const wchar_t *prefix
;
1302 if (entry
->acl_text_w
!= NULL
) {
1303 free (entry
->acl_text_w
);
1304 entry
->acl_text_w
= NULL
;
1310 ap
= entry
->acl_head
;
1311 while (ap
!= NULL
) {
1312 if ((ap
->type
& flags
) != 0) {
1314 if ((flags
& ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT
) &&
1315 (ap
->type
& ARCHIVE_ENTRY_ACL_TYPE_DEFAULT
))
1316 length
+= 8; /* "default:" */
1317 length
+= 5; /* tag name */
1318 length
+= 1; /* colon */
1319 wname
= aes_get_wcs(&ap
->name
);
1321 length
+= wcslen(wname
);
1323 length
+= sizeof(uid_t
) * 3 + 1;
1324 length
++; /* colon */
1325 length
+= 3; /* rwx */
1326 length
+= 1; /* colon */
1327 length
+= max(sizeof(uid_t
), sizeof(gid_t
)) * 3 + 1;
1328 length
++; /* newline */
1333 if (count
> 0 && ((flags
& ARCHIVE_ENTRY_ACL_TYPE_ACCESS
) != 0)) {
1334 length
+= 10; /* "user::rwx\n" */
1335 length
+= 11; /* "group::rwx\n" */
1336 length
+= 11; /* "other::rwx\n" */
1342 /* Now, allocate the string and actually populate it. */
1343 wp
= entry
->acl_text_w
= (wchar_t *)malloc(length
* sizeof(wchar_t));
1345 __archive_errx(1, "No memory to generate the text version of the ACL");
1347 if ((flags
& ARCHIVE_ENTRY_ACL_TYPE_ACCESS
) != 0) {
1348 append_entry_w(&wp
, NULL
, ARCHIVE_ENTRY_ACL_USER_OBJ
, NULL
,
1349 entry
->ae_stat
.aest_mode
& 0700, -1);
1351 append_entry_w(&wp
, NULL
, ARCHIVE_ENTRY_ACL_GROUP_OBJ
, NULL
,
1352 entry
->ae_stat
.aest_mode
& 0070, -1);
1354 append_entry_w(&wp
, NULL
, ARCHIVE_ENTRY_ACL_OTHER
, NULL
,
1355 entry
->ae_stat
.aest_mode
& 0007, -1);
1358 ap
= entry
->acl_head
;
1359 while (ap
!= NULL
) {
1360 if ((ap
->type
& ARCHIVE_ENTRY_ACL_TYPE_ACCESS
) != 0) {
1361 wname
= aes_get_wcs(&ap
->name
);
1363 if (flags
& ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID
)
1367 append_entry_w(&wp
, NULL
, ap
->tag
, wname
,
1376 if ((flags
& ARCHIVE_ENTRY_ACL_TYPE_DEFAULT
) != 0) {
1377 if (flags
& ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT
)
1378 prefix
= L
"default:";
1381 ap
= entry
->acl_head
;
1383 while (ap
!= NULL
) {
1384 if ((ap
->type
& ARCHIVE_ENTRY_ACL_TYPE_DEFAULT
) != 0) {
1385 wname
= aes_get_wcs(&ap
->name
);
1388 if (flags
& ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID
)
1392 append_entry_w(&wp
, prefix
, ap
->tag
,
1393 wname
, ap
->permset
, id
);
1400 return (entry
->acl_text_w
);
1404 append_id_w(wchar_t **wp
, int id
)
1409 append_id_w(wp
, id
/ 10);
1410 *(*wp
)++ = L
"0123456789"[id
% 10];
1414 append_entry_w(wchar_t **wp
, const wchar_t *prefix
, int tag
,
1415 const wchar_t *wname
, int perm
, int id
)
1417 if (prefix
!= NULL
) {
1418 wcscpy(*wp
, prefix
);
1422 case ARCHIVE_ENTRY_ACL_USER_OBJ
:
1426 case ARCHIVE_ENTRY_ACL_USER
:
1427 wcscpy(*wp
, L
"user");
1429 case ARCHIVE_ENTRY_ACL_GROUP_OBJ
:
1433 case ARCHIVE_ENTRY_ACL_GROUP
:
1434 wcscpy(*wp
, L
"group");
1436 case ARCHIVE_ENTRY_ACL_MASK
:
1437 wcscpy(*wp
, L
"mask");
1441 case ARCHIVE_ENTRY_ACL_OTHER
:
1442 wcscpy(*wp
, L
"other");
1449 if (wname
!= NULL
) {
1452 } else if (tag
== ARCHIVE_ENTRY_ACL_USER
1453 || tag
== ARCHIVE_ENTRY_ACL_GROUP
) {
1454 append_id_w(wp
, id
);
1458 *(*wp
)++ = (perm
& 0444) ? L
'r' : L
'-';
1459 *(*wp
)++ = (perm
& 0222) ? L
'w' : L
'-';
1460 *(*wp
)++ = (perm
& 0111) ? L
'x' : L
'-';
1463 append_id_w(wp
, id
);
1469 * Parse a textual ACL. This automatically recognizes and supports
1470 * extensions described above. The 'type' argument is used to
1471 * indicate the type that should be used for any entries not
1472 * explicitly marked as "default:".
1475 __archive_entry_acl_parse_w(struct archive_entry
*entry
,
1476 const wchar_t *text
, int default_type
)
1479 const wchar_t *start
;
1484 int type
, tag
, permset
, id
;
1488 while (text
!= NULL
&& *text
!= L
'\0') {
1490 * Parse the fields out of the next entry,
1491 * advance 'text' to start of next entry.
1495 const wchar_t *start
, *end
;
1496 next_field_w(&text
, &start
, &end
, &sep
);
1498 field
[fields
].start
= start
;
1499 field
[fields
].end
= end
;
1502 } while (sep
== L
':');
1505 return (ARCHIVE_WARN
);
1507 /* Check for a numeric ID in field 1 or 3. */
1509 isint_w(field
[1].start
, field
[1].end
, &id
);
1510 /* Field 3 is optional. */
1511 if (id
== -1 && fields
> 3)
1512 isint_w(field
[3].start
, field
[3].end
, &id
);
1514 /* Parse the permissions from field 2. */
1517 while (p
< field
[2].end
) {
1520 permset
|= ARCHIVE_ENTRY_ACL_READ
;
1523 permset
|= ARCHIVE_ENTRY_ACL_WRITE
;
1526 permset
|= ARCHIVE_ENTRY_ACL_EXECUTE
;
1531 return (ARCHIVE_WARN
);
1536 * Solaris extension: "defaultuser::rwx" is the
1537 * default ACL corresponding to "user::rwx", etc.
1539 if (field
[0].end
-field
[0].start
> 7
1540 && wmemcmp(field
[0].start
, L
"default", 7) == 0) {
1541 type
= ARCHIVE_ENTRY_ACL_TYPE_DEFAULT
;
1542 field
[0].start
+= 7;
1544 type
= default_type
;
1546 if (prefix_w(field
[0].start
, field
[0].end
, L
"user")) {
1547 if (id
!= -1 || field
[1].start
< field
[1].end
)
1548 tag
= ARCHIVE_ENTRY_ACL_USER
;
1550 tag
= ARCHIVE_ENTRY_ACL_USER_OBJ
;
1551 } else if (prefix_w(field
[0].start
, field
[0].end
, L
"group")) {
1552 if (id
!= -1 || field
[1].start
< field
[1].end
)
1553 tag
= ARCHIVE_ENTRY_ACL_GROUP
;
1555 tag
= ARCHIVE_ENTRY_ACL_GROUP_OBJ
;
1556 } else if (prefix_w(field
[0].start
, field
[0].end
, L
"other")) {
1557 if (id
!= -1 || field
[1].start
< field
[1].end
)
1558 return (ARCHIVE_WARN
);
1559 tag
= ARCHIVE_ENTRY_ACL_OTHER
;
1560 } else if (prefix_w(field
[0].start
, field
[0].end
, L
"mask")) {
1561 if (id
!= -1 || field
[1].start
< field
[1].end
)
1562 return (ARCHIVE_WARN
);
1563 tag
= ARCHIVE_ENTRY_ACL_MASK
;
1565 return (ARCHIVE_WARN
);
1567 /* Add entry to the internal list. */
1568 archive_entry_acl_add_entry_w_len(entry
, type
, permset
,
1569 tag
, id
, field
[1].start
, field
[1].end
- field
[1].start
);
1571 return (ARCHIVE_OK
);
1575 * extended attribute handling
1579 archive_entry_xattr_clear(struct archive_entry
*entry
)
1581 struct ae_xattr
*xp
;
1583 while (entry
->xattr_head
!= NULL
) {
1584 xp
= entry
->xattr_head
->next
;
1585 free(entry
->xattr_head
->name
);
1586 free(entry
->xattr_head
->value
);
1587 free(entry
->xattr_head
);
1588 entry
->xattr_head
= xp
;
1591 entry
->xattr_head
= NULL
;
1595 archive_entry_xattr_add_entry(struct archive_entry
*entry
,
1596 const char *name
, const void *value
, size_t size
)
1598 struct ae_xattr
*xp
;
1600 for (xp
= entry
->xattr_head
; xp
!= NULL
; xp
= xp
->next
)
1603 if ((xp
= (struct ae_xattr
*)malloc(sizeof(struct ae_xattr
))) == NULL
)
1607 xp
->name
= strdup(name
);
1608 if ((xp
->value
= malloc(size
)) != NULL
) {
1609 memcpy(xp
->value
, value
, size
);
1614 xp
->next
= entry
->xattr_head
;
1615 entry
->xattr_head
= xp
;
1620 * returns number of the extended attribute entries
1623 archive_entry_xattr_count(struct archive_entry
*entry
)
1625 struct ae_xattr
*xp
;
1628 for (xp
= entry
->xattr_head
; xp
!= NULL
; xp
= xp
->next
)
1635 archive_entry_xattr_reset(struct archive_entry
* entry
)
1637 entry
->xattr_p
= entry
->xattr_head
;
1639 return archive_entry_xattr_count(entry
);
1643 archive_entry_xattr_next(struct archive_entry
* entry
,
1644 const char **name
, const void **value
, size_t *size
)
1646 if (entry
->xattr_p
) {
1647 *name
= entry
->xattr_p
->name
;
1648 *value
= entry
->xattr_p
->value
;
1649 *size
= entry
->xattr_p
->size
;
1651 entry
->xattr_p
= entry
->xattr_p
->next
;
1653 return (ARCHIVE_OK
);
1658 return (ARCHIVE_WARN
);
1663 * end of xattr handling
1667 * Parse a string to a positive decimal integer. Returns true if
1668 * the string is non-empty and consists only of decimal digits,
1672 isint_w(const wchar_t *start
, const wchar_t *end
, int *result
)
1677 while (start
< end
) {
1678 if (*start
< '0' || *start
> '9')
1680 if (n
> (INT_MAX
/ 10))
1693 * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]". *wp is updated
1694 * to point to just after the separator. *start points to the first
1695 * character of the matched text and *end just after the last
1696 * character of the matched identifier. In particular *end - *start
1697 * is the length of the field body, not including leading or trailing
1701 next_field_w(const wchar_t **wp
, const wchar_t **start
,
1702 const wchar_t **end
, wchar_t *sep
)
1704 /* Skip leading whitespace to find start of field. */
1705 while (**wp
== L
' ' || **wp
== L
'\t' || **wp
== L
'\n') {
1710 /* Scan for the separator. */
1711 while (**wp
!= L
'\0' && **wp
!= L
',' && **wp
!= L
':' &&
1717 /* Trim trailing whitespace to locate end of field. */
1719 while (**end
== L
' ' || **end
== L
'\t' || **end
== L
'\n') {
1724 /* Adjust scanner location. */
1730 * Return true if the characters [start...end) are a prefix of 'test'.
1731 * This makes it easy to handle the obvious abbreviations: 'u' for 'user', etc.
1734 prefix_w(const wchar_t *start
, const wchar_t *end
, const wchar_t *test
)
1739 if (*start
++ != *test
++)
1742 while (start
< end
&& *start
++ == *test
++)
1753 * Following code is modified from UC Berkeley sources, and
1754 * is subject to the following copyright notice.
1758 * Copyright (c) 1993
1759 * The Regents of the University of California. All rights reserved.
1761 * Redistribution and use in source and binary forms, with or without
1762 * modification, are permitted provided that the following conditions
1764 * 1. Redistributions of source code must retain the above copyright
1765 * notice, this list of conditions and the following disclaimer.
1766 * 2. Redistributions in binary form must reproduce the above copyright
1767 * notice, this list of conditions and the following disclaimer in the
1768 * documentation and/or other materials provided with the distribution.
1769 * 4. Neither the name of the University nor the names of its contributors
1770 * may be used to endorse or promote products derived from this software
1771 * without specific prior written permission.
1773 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
1774 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1775 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1776 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
1777 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1778 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1779 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1780 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1781 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1782 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1786 static struct flag
{
1788 const wchar_t *wname
;
1790 unsigned long clear
;
1792 /* Preferred (shorter) names per flag first, all prefixed by "no" */
1794 { "nosappnd", L
"nosappnd", SF_APPEND
, 0 },
1795 { "nosappend", L
"nosappend", SF_APPEND
, 0 },
1797 #ifdef EXT2_APPEND_FL /* 'a' */
1798 { "nosappnd", L
"nosappnd", EXT2_APPEND_FL
, 0 },
1799 { "nosappend", L
"nosappend", EXT2_APPEND_FL
, 0 },
1802 { "noarch", L
"noarch", SF_ARCHIVED
, 0 },
1803 { "noarchived", L
"noarchived", SF_ARCHIVED
, 0 },
1806 { "noschg", L
"noschg", SF_IMMUTABLE
, 0 },
1807 { "noschange", L
"noschange", SF_IMMUTABLE
, 0 },
1808 { "nosimmutable", L
"nosimmutable", SF_IMMUTABLE
, 0 },
1810 #ifdef EXT2_IMMUTABLE_FL /* 'i' */
1811 { "noschg", L
"noschg", EXT2_IMMUTABLE_FL
, 0 },
1812 { "noschange", L
"noschange", EXT2_IMMUTABLE_FL
, 0 },
1813 { "nosimmutable", L
"nosimmutable", EXT2_IMMUTABLE_FL
, 0 },
1816 { "nosunlnk", L
"nosunlnk", SF_NOUNLINK
, 0 },
1817 { "nosunlink", L
"nosunlink", SF_NOUNLINK
, 0 },
1820 { "nosnapshot", L
"nosnapshot", SF_SNAPSHOT
, 0 },
1823 { "nouappnd", L
"nouappnd", UF_APPEND
, 0 },
1824 { "nouappend", L
"nouappend", UF_APPEND
, 0 },
1827 { "nouchg", L
"nouchg", UF_IMMUTABLE
, 0 },
1828 { "nouchange", L
"nouchange", UF_IMMUTABLE
, 0 },
1829 { "nouimmutable", L
"nouimmutable", UF_IMMUTABLE
, 0 },
1832 { "nodump", L
"nodump", 0, UF_NODUMP
},
1834 #ifdef EXT2_NODUMP_FL /* 'd' */
1835 { "nodump", L
"nodump", 0, EXT2_NODUMP_FL
},
1838 { "noopaque", L
"noopaque", UF_OPAQUE
, 0 },
1841 { "nouunlnk", L
"nouunlnk", UF_NOUNLINK
, 0 },
1842 { "nouunlink", L
"nouunlink", UF_NOUNLINK
, 0 },
1844 #ifdef EXT2_COMPR_FL /* 'c' */
1845 { "nocompress", L
"nocompress", EXT2_COMPR_FL
, 0 },
1848 #ifdef EXT2_NOATIME_FL /* 'A' */
1849 { "noatime", L
"noatime", 0, EXT2_NOATIME_FL
},
1851 { NULL
, NULL
, 0, 0 }
1856 * Convert file flags to a comma-separated string. If no flags
1857 * are set, return the empty string.
1860 ae_fflagstostr(unsigned long bitset
, unsigned long bitclear
)
1868 bits
= bitset
| bitclear
;
1870 for (flag
= flags
; flag
->name
!= NULL
; flag
++)
1871 if (bits
& (flag
->set
| flag
->clear
)) {
1872 length
+= strlen(flag
->name
) + 1;
1873 bits
&= ~(flag
->set
| flag
->clear
);
1878 string
= (char *)malloc(length
);
1883 for (flag
= flags
; flag
->name
!= NULL
; flag
++) {
1884 if (bitset
& flag
->set
|| bitclear
& flag
->clear
) {
1885 sp
= flag
->name
+ 2;
1886 } else if (bitset
& flag
->clear
|| bitclear
& flag
->set
) {
1890 bitset
&= ~(flag
->set
| flag
->clear
);
1891 bitclear
&= ~(flag
->set
| flag
->clear
);
1894 while ((*dp
++ = *sp
++) != '\0')
1905 * Take string of arguments and return file flags. This
1906 * version works a little differently than strtofflags(3).
1907 * In particular, it always tests every token, skipping any
1908 * unrecognized tokens. It returns a pointer to the first
1909 * unrecognized token, or NULL if every token was recognized.
1910 * This version is also const-correct and does not modify the
1914 ae_strtofflags(const char *s
, unsigned long *setp
, unsigned long *clrp
)
1916 const char *start
, *end
;
1918 unsigned long set
, clear
;
1924 /* Find start of first token. */
1925 while (*start
== '\t' || *start
== ' ' || *start
== ',')
1927 while (*start
!= '\0') {
1928 /* Locate end of token. */
1930 while (*end
!= '\0' && *end
!= '\t' &&
1931 *end
!= ' ' && *end
!= ',')
1933 for (flag
= flags
; flag
->name
!= NULL
; flag
++) {
1934 if (memcmp(start
, flag
->name
, end
- start
) == 0) {
1935 /* Matched "noXXXX", so reverse the sense. */
1939 } else if (memcmp(start
, flag
->name
+ 2, end
- start
)
1941 /* Matched "XXXX", so don't reverse. */
1943 clear
|= flag
->clear
;
1947 /* Ignore unknown flag names. */
1948 if (flag
->name
== NULL
&& failed
== NULL
)
1951 /* Find start of next token. */
1953 while (*start
== '\t' || *start
== ' ' || *start
== ',')
1963 /* Return location of first failure. */
1969 * Take string of arguments and return file flags. This
1970 * version works a little differently than strtofflags(3).
1971 * In particular, it always tests every token, skipping any
1972 * unrecognized tokens. It returns a pointer to the first
1973 * unrecognized token, or NULL if every token was recognized.
1974 * This version is also const-correct and does not modify the
1977 static const wchar_t *
1978 ae_wcstofflags(const wchar_t *s
, unsigned long *setp
, unsigned long *clrp
)
1980 const wchar_t *start
, *end
;
1982 unsigned long set
, clear
;
1983 const wchar_t *failed
;
1988 /* Find start of first token. */
1989 while (*start
== L
'\t' || *start
== L
' ' || *start
== L
',')
1991 while (*start
!= L
'\0') {
1992 /* Locate end of token. */
1994 while (*end
!= L
'\0' && *end
!= L
'\t' &&
1995 *end
!= L
' ' && *end
!= L
',')
1997 for (flag
= flags
; flag
->wname
!= NULL
; flag
++) {
1998 if (wmemcmp(start
, flag
->wname
, end
- start
) == 0) {
1999 /* Matched "noXXXX", so reverse the sense. */
2003 } else if (wmemcmp(start
, flag
->wname
+ 2, end
- start
)
2005 /* Matched "XXXX", so don't reverse. */
2007 clear
|= flag
->clear
;
2011 /* Ignore unknown flag names. */
2012 if (flag
->wname
== NULL
&& failed
== NULL
)
2015 /* Find start of next token. */
2017 while (*start
== L
'\t' || *start
== L
' ' || *start
== L
',')
2027 /* Return location of first failure. */
2035 main(int argc
, char **argv
)
2037 struct archive_entry
*entry
= archive_entry_new();
2038 unsigned long set
, clear
;
2039 const wchar_t *remainder
;
2041 remainder
= archive_entry_copy_fflags_text_w(entry
, L
"nosappnd dump archive,,,,,,,");
2042 archive_entry_fflags(entry
, &set
, &clear
);
2044 wprintf(L
"set=0x%lX clear=0x%lX remainder='%ls'\n", set
, clear
, remainder
);
2046 wprintf(L
"new flags='%s'\n", archive_entry_fflags_text(entry
));