2 * Copyright (c) 2003-2010 Tim Kientzle
3 * Copyright (c) 2012 Michihiro NAKAJIMA
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer
11 * in this position and unchanged.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 #include "archive_platform.h"
29 __FBSDID("$FreeBSD$");
31 #if !defined(_WIN32) || defined(__CYGWIN__)
33 #ifdef HAVE_SYS_TYPES_H
34 #include <sys/types.h>
39 #ifdef HAVE_SYS_EXTATTR_H
40 #include <sys/extattr.h>
43 #include <sys/xattr.h>
44 #elif HAVE_ATTR_XATTR_H
45 #include <attr/xattr.h>
50 #ifdef HAVE_SYS_IOCTL_H
51 #include <sys/ioctl.h>
53 #ifdef HAVE_SYS_STAT_H
56 #ifdef HAVE_SYS_TIME_H
59 #ifdef HAVE_SYS_UTIME_H
60 #include <sys/utime.h>
62 #ifdef HAVE_COPYFILE_H
74 #ifdef HAVE_LANGINFO_H
77 #ifdef HAVE_LINUX_FS_H
78 #include <linux/fs.h> /* for Linux file flags */
81 * Some Linux distributions have both linux/ext2_fs.h and ext2fs/ext2_fs.h.
82 * As the include guards don't agree, the order of include is important.
84 #ifdef HAVE_LINUX_EXT2_FS_H
85 #include <linux/ext2_fs.h> /* for Linux file flags */
87 #if defined(HAVE_EXT2FS_EXT2_FS_H) && !defined(__CYGWIN__)
88 #include <ext2fs/ext2_fs.h> /* Linux file flags, broken on Cygwin */
109 #ifdef F_GETTIMES /* Tru64 specific */
110 #include <sys/fcntl1.h>
114 * Macro to cast st_mtime and time_t to an int64 so that 2 numbers can reliably be compared.
116 * It assumes that the input is an integer type of no more than 64 bits.
117 * If the number is less than zero, t must be a signed type, so it fits in
118 * int64_t. Otherwise, it's a nonnegative value so we can cast it to uint64_t
119 * without loss. But it could be a large unsigned value, so we have to clip it
122 #define to_int64_time(t) \
123 ((t) < 0 ? (int64_t)(t) : (uint64_t)(t) > (uint64_t)INT64_MAX ? INT64_MAX : (int64_t)(t))
126 #include <TargetConditionals.h>
127 #if TARGET_OS_MAC && !TARGET_OS_EMBEDDED && HAVE_QUARANTINE_H
128 #include <quarantine.h>
129 #define HAVE_QUARANTINE 1
137 /* TODO: Support Mac OS 'quarantine' feature. This is really just a
138 * standard tag to mark files that have been downloaded as "tainted".
139 * On Mac OS, we should mark the extracted files as tainted if the
140 * archive being read was tainted. Windows has a similar feature; we
141 * should investigate ways to support this generically. */
144 #include "archive_acl_private.h"
145 #include "archive_string.h"
146 #include "archive_endian.h"
147 #include "archive_entry.h"
148 #include "archive_private.h"
149 #include "archive_write_disk_private.h"
158 /* Ignore non-int O_NOFOLLOW constant. */
159 /* gnulib's fcntl.h does this on AIX, but it seems practical everywhere */
160 #if defined O_NOFOLLOW && !(INT_MIN <= O_NOFOLLOW && O_NOFOLLOW <= INT_MAX)
169 struct fixup_entry *next;
170 struct archive_acl acl;
176 unsigned long atime_nanos;
177 unsigned long birthtime_nanos;
178 unsigned long mtime_nanos;
179 unsigned long ctime_nanos;
180 unsigned long fflags_set;
181 size_t mac_metadata_size;
183 int fixup; /* bitmask of what needs fixing */
188 * We use a bitmask to track which operations remain to be done for
189 * this file. In particular, this helps us avoid unnecessary
190 * operations when it's possible to take care of one step as a
191 * side-effect of another. For example, mkdir() can specify the mode
192 * for the newly-created object but symlink() cannot. This means we
193 * can skip chmod() if mkdir() succeeded, but we must explicitly
194 * chmod() if we're trying to create a directory that already exists
195 * (mkdir() failed) or if we're restoring a symlink. Similarly, we
196 * need to verify UID/GID before trying to restore SUID/SGID bits;
197 * that verification can occur explicitly through a stat() call or
198 * implicitly because of a successful chown() call.
200 #define TODO_MODE_FORCE 0x40000000
201 #define TODO_MODE_BASE 0x20000000
202 #define TODO_SUID 0x10000000
203 #define TODO_SUID_CHECK 0x08000000
204 #define TODO_SGID 0x04000000
205 #define TODO_SGID_CHECK 0x02000000
206 #define TODO_APPLEDOUBLE 0x01000000
207 #define TODO_MODE (TODO_MODE_BASE|TODO_SUID|TODO_SGID)
208 #define TODO_TIMES ARCHIVE_EXTRACT_TIME
209 #define TODO_OWNER ARCHIVE_EXTRACT_OWNER
210 #define TODO_FFLAGS ARCHIVE_EXTRACT_FFLAGS
211 #define TODO_ACLS ARCHIVE_EXTRACT_ACL
212 #define TODO_XATTR ARCHIVE_EXTRACT_XATTR
213 #define TODO_MAC_METADATA ARCHIVE_EXTRACT_MAC_METADATA
214 #define TODO_HFS_COMPRESSION ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED
216 struct archive_write_disk {
217 struct archive archive;
220 struct fixup_entry *fixup_list;
221 struct fixup_entry *current_fixup;
224 int64_t skip_file_dev;
225 int64_t skip_file_ino;
228 int64_t (*lookup_gid)(void *private, const char *gname, int64_t gid);
229 void (*cleanup_gid)(void *private);
230 void *lookup_gid_data;
231 int64_t (*lookup_uid)(void *private, const char *uname, int64_t uid);
232 void (*cleanup_uid)(void *private);
233 void *lookup_uid_data;
236 * Full path of last file to satisfy symlink checks.
238 struct archive_string path_safe;
241 * Cached stat data from disk for the current entry.
242 * If this is valid, pst points to st. Otherwise,
248 /* Information about the object being restored right now. */
249 struct archive_entry *entry; /* Entry being extracted. */
250 char *name; /* Name of entry, possibly edited. */
251 struct archive_string _name_data; /* backing store for 'name' */
252 /* Tasks remaining for this object. */
254 /* Tasks deferred until end-of-archive. */
256 /* Options requested by the client. */
258 /* Handle for the file we're restoring. */
260 /* Current offset for writing data to the file. */
262 /* Last offset actually written to disk. */
264 /* Total bytes actually written to files. */
265 int64_t total_bytes_written;
266 /* Maximum size of file, -1 if unknown. */
268 /* Dir we were in before this restore; only for deep paths. */
270 /* Mode we should use for this entry; affected by _PERM and umask. */
272 /* UID/GID to use in restoring this entry. */
278 /* Xattr "com.apple.decmpfs". */
279 uint32_t decmpfs_attr_size;
280 unsigned char *decmpfs_header_p;
281 /* ResourceFork set options used for fsetxattr. */
282 int rsrc_xattr_options;
283 /* Xattr "com.apple.ResourceFork". */
284 unsigned char *resource_fork;
285 size_t resource_fork_allocated_size;
286 unsigned int decmpfs_block_count;
287 uint32_t *decmpfs_block_info;
288 /* Buffer for compressed data. */
289 unsigned char *compressed_buffer;
290 size_t compressed_buffer_size;
291 size_t compressed_buffer_remaining;
292 /* The offset of the ResourceFork where compressed data will
294 uint32_t compressed_rsrc_position;
295 uint32_t compressed_rsrc_position_v;
296 /* Buffer for uncompressed data. */
297 char *uncompressed_buffer;
298 size_t block_remaining_bytes;
299 size_t file_remaining_bytes;
303 int decmpfs_compression_level;
308 * Default mode for dirs created automatically (will be modified by umask).
309 * Note that POSIX specifies 0777 for implicitly-created dirs, "modified
310 * by the process' file creation mask."
312 #define DEFAULT_DIR_MODE 0777
314 * Dir modes are restored in two steps: During the extraction, the permissions
315 * in the archive are modified to match the following limits. During
316 * the post-extract fixup pass, the permissions from the archive are
319 #define MINIMUM_DIR_MODE 0700
320 #define MAXIMUM_DIR_MODE 0775
323 * Maximum uncompressed size of a decmpfs block.
325 #define MAX_DECMPFS_BLOCK_SIZE (64 * 1024)
327 * HFS+ compression type.
329 #define CMP_XATTR 3/* Compressed data in xattr. */
330 #define CMP_RESOURCE_FORK 4/* Compressed data in resource fork. */
332 * HFS+ compression resource fork.
334 #define RSRC_H_SIZE 260 /* Base size of Resource fork header. */
335 #define RSRC_F_SIZE 50 /* Size of Resource fork footer. */
336 /* Size to write compressed data to resource fork. */
337 #define COMPRESSED_W_SIZE (64 * 1024)
338 /* decmpfs definitions. */
339 #define MAX_DECMPFS_XATTR_SIZE 3802
340 #ifndef DECMPFS_XATTR_NAME
341 #define DECMPFS_XATTR_NAME "com.apple.decmpfs"
343 #define DECMPFS_MAGIC 0x636d7066
344 #define DECMPFS_COMPRESSION_MAGIC 0
345 #define DECMPFS_COMPRESSION_TYPE 4
346 #define DECMPFS_UNCOMPRESSED_SIZE 8
347 #define DECMPFS_HEADER_SIZE 16
349 #define HFS_BLOCKS(s) ((s) >> 12)
351 static void fsobj_error(int *, struct archive_string *, int, const char *,
353 static int check_symlinks_fsobj(char *, int *, struct archive_string *,
355 static int check_symlinks(struct archive_write_disk *);
356 static int create_filesystem_object(struct archive_write_disk *);
357 static struct fixup_entry *current_fixup(struct archive_write_disk *,
358 const char *pathname);
359 #if defined(HAVE_FCHDIR) && defined(PATH_MAX)
360 static void edit_deep_directories(struct archive_write_disk *ad);
362 static int cleanup_pathname_fsobj(char *, int *, struct archive_string *,
364 static int cleanup_pathname(struct archive_write_disk *);
365 static int create_dir(struct archive_write_disk *, char *);
366 static int create_parent_dir(struct archive_write_disk *, char *);
367 static ssize_t hfs_write_data_block(struct archive_write_disk *,
368 const char *, size_t);
369 static int fixup_appledouble(struct archive_write_disk *, const char *);
370 static int older(struct stat *, struct archive_entry *);
371 static int restore_entry(struct archive_write_disk *);
372 static int set_mac_metadata(struct archive_write_disk *, const char *,
373 const void *, size_t);
374 static int set_xattrs(struct archive_write_disk *);
375 static int clear_nochange_fflags(struct archive_write_disk *);
376 static int set_fflags(struct archive_write_disk *);
377 static int set_fflags_platform(struct archive_write_disk *, int fd,
378 const char *name, mode_t mode,
379 unsigned long fflags_set, unsigned long fflags_clear);
380 static int set_ownership(struct archive_write_disk *);
381 static int set_mode(struct archive_write_disk *, int mode);
382 static int set_time(int, int, const char *, time_t, long, time_t, long);
383 static int set_times(struct archive_write_disk *, int, int, const char *,
384 time_t, long, time_t, long, time_t, long, time_t, long);
385 static int set_times_from_entry(struct archive_write_disk *);
386 static struct fixup_entry *sort_dir_list(struct fixup_entry *p);
387 static ssize_t write_data_block(struct archive_write_disk *,
388 const char *, size_t);
390 static struct archive_vtable *archive_write_disk_vtable(void);
392 static int _archive_write_disk_close(struct archive *);
393 static int _archive_write_disk_free(struct archive *);
394 static int _archive_write_disk_header(struct archive *,
395 struct archive_entry *);
396 static int64_t _archive_write_disk_filter_bytes(struct archive *, int);
397 static int _archive_write_disk_finish_entry(struct archive *);
398 static ssize_t _archive_write_disk_data(struct archive *, const void *,
400 static ssize_t _archive_write_disk_data_block(struct archive *, const void *,
404 lazy_stat(struct archive_write_disk *a)
406 if (a->pst != NULL) {
407 /* Already have stat() data available. */
411 if (a->fd >= 0 && fstat(a->fd, &a->st) == 0) {
417 * XXX At this point, symlinks should not be hit, otherwise
418 * XXX a race occurred. Do we want to check explicitly for that?
420 if (lstat(a->name, &a->st) == 0) {
424 archive_set_error(&a->archive, errno, "Couldn't stat file");
425 return (ARCHIVE_WARN);
428 static struct archive_vtable *
429 archive_write_disk_vtable(void)
431 static struct archive_vtable av;
432 static int inited = 0;
435 av.archive_close = _archive_write_disk_close;
436 av.archive_filter_bytes = _archive_write_disk_filter_bytes;
437 av.archive_free = _archive_write_disk_free;
438 av.archive_write_header = _archive_write_disk_header;
439 av.archive_write_finish_entry
440 = _archive_write_disk_finish_entry;
441 av.archive_write_data = _archive_write_disk_data;
442 av.archive_write_data_block = _archive_write_disk_data_block;
449 _archive_write_disk_filter_bytes(struct archive *_a, int n)
451 struct archive_write_disk *a = (struct archive_write_disk *)_a;
452 (void)n; /* UNUSED */
453 if (n == -1 || n == 0)
454 return (a->total_bytes_written);
460 archive_write_disk_set_options(struct archive *_a, int flags)
462 struct archive_write_disk *a = (struct archive_write_disk *)_a;
470 * Extract this entry to disk.
472 * TODO: Validate hardlinks. According to the standards, we're
473 * supposed to check each extracted hardlink and squawk if it refers
474 * to a file that we didn't restore. I'm not entirely convinced this
475 * is a good idea, but more importantly: Is there any way to validate
476 * hardlinks without keeping a complete list of filenames from the
477 * entire archive?? Ugh.
481 _archive_write_disk_header(struct archive *_a, struct archive_entry *entry)
483 struct archive_write_disk *a = (struct archive_write_disk *)_a;
484 struct fixup_entry *fe;
487 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
488 ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
489 "archive_write_disk_header");
490 archive_clear_error(&a->archive);
491 if (a->archive.state & ARCHIVE_STATE_DATA) {
492 r = _archive_write_disk_finish_entry(&a->archive);
493 if (r == ARCHIVE_FATAL)
497 /* Set up for this particular entry. */
499 a->current_fixup = NULL;
502 archive_entry_free(a->entry);
505 a->entry = archive_entry_clone(entry);
510 a->uid = a->user_uid;
511 a->mode = archive_entry_mode(a->entry);
512 if (archive_entry_size_is_set(a->entry))
513 a->filesize = archive_entry_size(a->entry);
516 archive_strcpy(&(a->_name_data), archive_entry_pathname(a->entry));
517 a->name = a->_name_data.s;
518 archive_clear_error(&a->archive);
521 * Clean up the requested path. This is necessary for correct
522 * dir restores; the dir restore logic otherwise gets messed
523 * up by nonsense like "dir/.".
525 ret = cleanup_pathname(a);
526 if (ret != ARCHIVE_OK)
530 * Query the umask so we get predictable mode settings.
531 * This gets done on every call to _write_header in case the
532 * user edits their umask during the extraction for some
535 umask(a->user_umask = umask(0));
537 /* Figure out what we need to do for this entry. */
538 a->todo = TODO_MODE_BASE;
539 if (a->flags & ARCHIVE_EXTRACT_PERM) {
540 a->todo |= TODO_MODE_FORCE; /* Be pushy about permissions. */
542 * SGID requires an extra "check" step because we
543 * cannot easily predict the GID that the system will
544 * assign. (Different systems assign GIDs to files
545 * based on a variety of criteria, including process
546 * credentials and the gid of the enclosing
547 * directory.) We can only restore the SGID bit if
548 * the file has the right GID, and we only know the
549 * GID if we either set it (see set_ownership) or if
550 * we've actually called stat() on the file after it
551 * was restored. Since there are several places at
552 * which we might verify the GID, we need a TODO bit
555 if (a->mode & S_ISGID)
556 a->todo |= TODO_SGID | TODO_SGID_CHECK;
558 * Verifying the SUID is simpler, but can still be
559 * done in multiple ways, hence the separate "check" bit.
561 if (a->mode & S_ISUID)
562 a->todo |= TODO_SUID | TODO_SUID_CHECK;
565 * User didn't request full permissions, so don't
566 * restore SUID, SGID bits and obey umask.
571 a->mode &= ~a->user_umask;
573 if (a->flags & ARCHIVE_EXTRACT_OWNER)
574 a->todo |= TODO_OWNER;
575 if (a->flags & ARCHIVE_EXTRACT_TIME)
576 a->todo |= TODO_TIMES;
577 if (a->flags & ARCHIVE_EXTRACT_ACL) {
578 #if ARCHIVE_ACL_DARWIN
580 * On MacOS, platform ACLs get stored in mac_metadata, too.
581 * If we intend to extract mac_metadata and it is present
582 * we skip extracting libarchive NFSv4 ACLs.
584 size_t metadata_size;
586 if ((a->flags & ARCHIVE_EXTRACT_MAC_METADATA) == 0 ||
587 archive_entry_mac_metadata(a->entry,
588 &metadata_size) == NULL || metadata_size == 0)
590 #if ARCHIVE_ACL_LIBRICHACL
592 * RichACLs are stored in an extended attribute.
593 * If we intend to extract extended attributes and have this
594 * attribute we skip extracting libarchive NFSv4 ACLs.
596 short extract_acls = 1;
597 if (a->flags & ARCHIVE_EXTRACT_XATTR && (
598 archive_entry_acl_types(a->entry) &
599 ARCHIVE_ENTRY_ACL_TYPE_NFS4)) {
600 const char *attr_name;
601 const void *attr_value;
603 int i = archive_entry_xattr_reset(a->entry);
605 archive_entry_xattr_next(a->entry, &attr_name,
606 &attr_value, &attr_size);
607 if (attr_name != NULL && attr_value != NULL &&
608 attr_size > 0 && strcmp(attr_name,
609 "trusted.richacl") == 0) {
617 #if ARCHIVE_ACL_DARWIN || ARCHIVE_ACL_LIBRICHACL
620 if (archive_entry_filetype(a->entry) == AE_IFDIR)
621 a->deferred |= TODO_ACLS;
623 a->todo |= TODO_ACLS;
624 #if ARCHIVE_ACL_DARWIN || ARCHIVE_ACL_LIBRICHACL
628 if (a->flags & ARCHIVE_EXTRACT_MAC_METADATA) {
629 if (archive_entry_filetype(a->entry) == AE_IFDIR)
630 a->deferred |= TODO_MAC_METADATA;
632 a->todo |= TODO_MAC_METADATA;
634 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
635 if ((a->flags & ARCHIVE_EXTRACT_NO_HFS_COMPRESSION) == 0) {
636 unsigned long set, clear;
637 archive_entry_fflags(a->entry, &set, &clear);
638 if ((set & ~clear) & UF_COMPRESSED) {
639 a->todo |= TODO_HFS_COMPRESSION;
640 a->decmpfs_block_count = (unsigned)-1;
643 if ((a->flags & ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED) != 0 &&
644 (a->mode & AE_IFMT) == AE_IFREG && a->filesize > 0) {
645 a->todo |= TODO_HFS_COMPRESSION;
646 a->decmpfs_block_count = (unsigned)-1;
651 /* Check if the current file name is a type of the
652 * resource fork file. */
653 p = strrchr(a->name, '/');
658 if (p[0] == '.' && p[1] == '_') {
659 /* Do not compress "._XXX" files. */
660 a->todo &= ~TODO_HFS_COMPRESSION;
662 a->todo |= TODO_APPLEDOUBLE;
667 if (a->flags & ARCHIVE_EXTRACT_XATTR) {
668 #if ARCHIVE_XATTR_DARWIN
670 * On MacOS, extended attributes get stored in mac_metadata,
671 * too. If we intend to extract mac_metadata and it is present
672 * we skip extracting extended attributes.
674 size_t metadata_size;
676 if ((a->flags & ARCHIVE_EXTRACT_MAC_METADATA) == 0 ||
677 archive_entry_mac_metadata(a->entry,
678 &metadata_size) == NULL || metadata_size == 0)
680 a->todo |= TODO_XATTR;
682 if (a->flags & ARCHIVE_EXTRACT_FFLAGS)
683 a->todo |= TODO_FFLAGS;
684 if (a->flags & ARCHIVE_EXTRACT_SECURE_SYMLINKS) {
685 ret = check_symlinks(a);
686 if (ret != ARCHIVE_OK)
689 #if defined(HAVE_FCHDIR) && defined(PATH_MAX)
690 /* If path exceeds PATH_MAX, shorten the path. */
691 edit_deep_directories(a);
694 ret = restore_entry(a);
696 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
698 * Check if the filesystem the file is restoring on supports
699 * HFS+ Compression. If not, cancel HFS+ Compression.
701 if (a->todo | TODO_HFS_COMPRESSION) {
703 * NOTE: UF_COMPRESSED is ignored even if the filesystem
704 * supports HFS+ Compression because the file should
705 * have at least an extended attribute "com.apple.decmpfs"
706 * before the flag is set to indicate that the file have
707 * been compressed. If the filesystem does not support
708 * HFS+ Compression the system call will fail.
710 if (a->fd < 0 || fchflags(a->fd, UF_COMPRESSED) != 0)
711 a->todo &= ~TODO_HFS_COMPRESSION;
716 * TODO: There are rumours that some extended attributes must
717 * be restored before file data is written. If this is true,
718 * then we either need to write all extended attributes both
719 * before and after restoring the data, or find some rule for
720 * determining which must go first and which last. Due to the
721 * many ways people are using xattrs, this may prove to be an
722 * intractable problem.
726 /* If we changed directory above, restore it here. */
727 if (a->restore_pwd >= 0) {
728 r = fchdir(a->restore_pwd);
730 archive_set_error(&a->archive, errno,
734 close(a->restore_pwd);
740 * Fixup uses the unedited pathname from archive_entry_pathname(),
741 * because it is relative to the base dir and the edited path
742 * might be relative to some intermediate dir as a result of the
743 * deep restore logic.
745 if (a->deferred & TODO_MODE) {
746 fe = current_fixup(a, archive_entry_pathname(entry));
748 return (ARCHIVE_FATAL);
749 fe->fixup |= TODO_MODE_BASE;
753 if ((a->deferred & TODO_TIMES)
754 && (archive_entry_mtime_is_set(entry)
755 || archive_entry_atime_is_set(entry))) {
756 fe = current_fixup(a, archive_entry_pathname(entry));
758 return (ARCHIVE_FATAL);
760 fe->fixup |= TODO_TIMES;
761 if (archive_entry_atime_is_set(entry)) {
762 fe->atime = archive_entry_atime(entry);
763 fe->atime_nanos = archive_entry_atime_nsec(entry);
765 /* If atime is unset, use start time. */
766 fe->atime = a->start_time;
769 if (archive_entry_mtime_is_set(entry)) {
770 fe->mtime = archive_entry_mtime(entry);
771 fe->mtime_nanos = archive_entry_mtime_nsec(entry);
773 /* If mtime is unset, use start time. */
774 fe->mtime = a->start_time;
777 if (archive_entry_birthtime_is_set(entry)) {
778 fe->birthtime = archive_entry_birthtime(entry);
779 fe->birthtime_nanos = archive_entry_birthtime_nsec(
782 /* If birthtime is unset, use mtime. */
783 fe->birthtime = fe->mtime;
784 fe->birthtime_nanos = fe->mtime_nanos;
788 if (a->deferred & TODO_ACLS) {
789 fe = current_fixup(a, archive_entry_pathname(entry));
791 return (ARCHIVE_FATAL);
792 fe->fixup |= TODO_ACLS;
793 archive_acl_copy(&fe->acl, archive_entry_acl(entry));
796 if (a->deferred & TODO_MAC_METADATA) {
797 const void *metadata;
798 size_t metadata_size;
799 metadata = archive_entry_mac_metadata(a->entry, &metadata_size);
800 if (metadata != NULL && metadata_size > 0) {
801 fe = current_fixup(a, archive_entry_pathname(entry));
803 return (ARCHIVE_FATAL);
804 fe->mac_metadata = malloc(metadata_size);
805 if (fe->mac_metadata != NULL) {
806 memcpy(fe->mac_metadata, metadata,
808 fe->mac_metadata_size = metadata_size;
809 fe->fixup |= TODO_MAC_METADATA;
814 if (a->deferred & TODO_FFLAGS) {
815 fe = current_fixup(a, archive_entry_pathname(entry));
817 return (ARCHIVE_FATAL);
818 fe->fixup |= TODO_FFLAGS;
819 /* TODO: Complete this.. defer fflags from below. */
822 /* We've created the object and are ready to pour data into it. */
823 if (ret >= ARCHIVE_WARN)
824 a->archive.state = ARCHIVE_STATE_DATA;
826 * If it's not open, tell our client not to try writing.
827 * In particular, dirs, links, etc, don't get written to.
830 archive_entry_set_size(entry, 0);
838 archive_write_disk_set_skip_file(struct archive *_a, la_int64_t d, la_int64_t i)
840 struct archive_write_disk *a = (struct archive_write_disk *)_a;
841 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
842 ARCHIVE_STATE_ANY, "archive_write_disk_set_skip_file");
843 a->skip_file_set = 1;
844 a->skip_file_dev = d;
845 a->skip_file_ino = i;
850 write_data_block(struct archive_write_disk *a, const char *buff, size_t size)
852 uint64_t start_size = size;
853 ssize_t bytes_written = 0;
854 ssize_t block_size = 0, bytes_to_write;
859 if (a->filesize == 0 || a->fd < 0) {
860 archive_set_error(&a->archive, 0,
861 "Attempt to write to an empty file");
862 return (ARCHIVE_WARN);
865 if (a->flags & ARCHIVE_EXTRACT_SPARSE) {
866 #if HAVE_STRUCT_STAT_ST_BLKSIZE
868 if ((r = lazy_stat(a)) != ARCHIVE_OK)
870 block_size = a->pst->st_blksize;
872 /* XXX TODO XXX Is there a more appropriate choice here ? */
873 /* This needn't match the filesystem allocation size. */
874 block_size = 16*1024;
878 /* If this write would run beyond the file size, truncate it. */
879 if (a->filesize >= 0 && (int64_t)(a->offset + size) > a->filesize)
880 start_size = size = (size_t)(a->filesize - a->offset);
882 /* Write the data. */
884 if (block_size == 0) {
885 bytes_to_write = size;
887 /* We're sparsifying the file. */
891 /* Skip leading zero bytes. */
892 for (p = buff, end = buff + size; p < end; ++p) {
896 a->offset += p - buff;
902 /* Calculate next block boundary after offset. */
904 = (a->offset / block_size + 1) * block_size;
906 /* If the adjusted write would cross block boundary,
907 * truncate it to the block boundary. */
908 bytes_to_write = size;
909 if (a->offset + bytes_to_write > block_end)
910 bytes_to_write = block_end - a->offset;
912 /* Seek if necessary to the specified offset. */
913 if (a->offset != a->fd_offset) {
914 if (lseek(a->fd, a->offset, SEEK_SET) < 0) {
915 archive_set_error(&a->archive, errno,
917 return (ARCHIVE_FATAL);
919 a->fd_offset = a->offset;
921 bytes_written = write(a->fd, buff, bytes_to_write);
922 if (bytes_written < 0) {
923 archive_set_error(&a->archive, errno, "Write failed");
924 return (ARCHIVE_WARN);
926 buff += bytes_written;
927 size -= bytes_written;
928 a->total_bytes_written += bytes_written;
929 a->offset += bytes_written;
930 a->fd_offset = a->offset;
932 return (start_size - size);
935 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_SYS_XATTR_H)\
936 && defined(HAVE_ZLIB_H)
939 * Set UF_COMPRESSED file flag.
940 * This have to be called after hfs_write_decmpfs() because if the
941 * file does not have "com.apple.decmpfs" xattr the flag is ignored.
944 hfs_set_compressed_fflag(struct archive_write_disk *a)
948 if ((r = lazy_stat(a)) != ARCHIVE_OK)
951 a->st.st_flags |= UF_COMPRESSED;
952 if (fchflags(a->fd, a->st.st_flags) != 0) {
953 archive_set_error(&a->archive, errno,
954 "Failed to set UF_COMPRESSED file flag");
955 return (ARCHIVE_WARN);
961 * HFS+ Compression decmpfs
963 * +------------------------------+ +0
964 * | Magic(LE 4 bytes) |
965 * +------------------------------+
966 * | Type(LE 4 bytes) |
967 * +------------------------------+
968 * | Uncompressed size(LE 8 bytes)|
969 * +------------------------------+ +16
971 * | Compressed data |
972 * | (Placed only if Type == 3) |
974 * +------------------------------+ +3802 = MAX_DECMPFS_XATTR_SIZE
976 * Type is 3: decmpfs has compressed data.
977 * Type is 4: Resource Fork has compressed data.
980 * Write "com.apple.decmpfs"
983 hfs_write_decmpfs(struct archive_write_disk *a)
986 uint32_t compression_type;
988 r = fsetxattr(a->fd, DECMPFS_XATTR_NAME, a->decmpfs_header_p,
989 a->decmpfs_attr_size, 0, 0);
991 archive_set_error(&a->archive, errno,
992 "Cannot restore xattr:%s", DECMPFS_XATTR_NAME);
993 compression_type = archive_le32dec(
994 &a->decmpfs_header_p[DECMPFS_COMPRESSION_TYPE]);
995 if (compression_type == CMP_RESOURCE_FORK)
996 fremovexattr(a->fd, XATTR_RESOURCEFORK_NAME,
997 XATTR_SHOWCOMPRESSION);
998 return (ARCHIVE_WARN);
1000 return (ARCHIVE_OK);
1004 * HFS+ Compression Resource Fork
1006 * +-----------------------------+
1007 * | Header(260 bytes) |
1008 * +-----------------------------+
1009 * | Block count(LE 4 bytes) |
1010 * +-----------------------------+ --+
1011 * +-- | Offset (LE 4 bytes) | |
1012 * | | [distance from Block count] | | Block 0
1013 * | +-----------------------------+ |
1014 * | | Compressed size(LE 4 bytes) | |
1015 * | +-----------------------------+ --+
1017 * | | .................. |
1019 * | +-----------------------------+ --+
1020 * | | Offset (LE 4 bytes) | |
1021 * | +-----------------------------+ | Block (Block count -1)
1022 * | | Compressed size(LE 4 bytes) | |
1023 * +-> +-----------------------------+ --+
1024 * | Compressed data(n bytes) | Block 0
1025 * +-----------------------------+
1027 * | .................. |
1029 * +-----------------------------+
1030 * | Compressed data(n bytes) | Block (Block count -1)
1031 * +-----------------------------+
1032 * | Footer(50 bytes) |
1033 * +-----------------------------+
1037 * Write the header of "com.apple.ResourceFork"
1040 hfs_write_resource_fork(struct archive_write_disk *a, unsigned char *buff,
1041 size_t bytes, uint32_t position)
1045 ret = fsetxattr(a->fd, XATTR_RESOURCEFORK_NAME, buff, bytes,
1046 position, a->rsrc_xattr_options);
1048 archive_set_error(&a->archive, errno,
1049 "Cannot restore xattr: %s at %u pos %u bytes",
1050 XATTR_RESOURCEFORK_NAME,
1053 return (ARCHIVE_WARN);
1055 a->rsrc_xattr_options &= ~XATTR_CREATE;
1056 return (ARCHIVE_OK);
1060 hfs_write_compressed_data(struct archive_write_disk *a, size_t bytes_compressed)
1064 ret = hfs_write_resource_fork(a, a->compressed_buffer,
1065 bytes_compressed, a->compressed_rsrc_position);
1066 if (ret == ARCHIVE_OK)
1067 a->compressed_rsrc_position += bytes_compressed;
1072 hfs_write_resource_fork_header(struct archive_write_disk *a)
1074 unsigned char *buff;
1075 uint32_t rsrc_bytes;
1076 uint32_t rsrc_header_bytes;
1079 * Write resource fork header + block info.
1081 buff = a->resource_fork;
1082 rsrc_bytes = a->compressed_rsrc_position - RSRC_F_SIZE;
1084 RSRC_H_SIZE + /* Header base size. */
1085 4 + /* Block count. */
1086 (a->decmpfs_block_count * 8);/* Block info */
1087 archive_be32enc(buff, 0x100);
1088 archive_be32enc(buff + 4, rsrc_bytes);
1089 archive_be32enc(buff + 8, rsrc_bytes - 256);
1090 archive_be32enc(buff + 12, 0x32);
1091 memset(buff + 16, 0, 240);
1092 archive_be32enc(buff + 256, rsrc_bytes - 260);
1093 return hfs_write_resource_fork(a, buff, rsrc_header_bytes, 0);
1097 hfs_set_resource_fork_footer(unsigned char *buff, size_t buff_size)
1099 static const char rsrc_footer[RSRC_F_SIZE] = {
1100 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1101 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1102 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1103 0x00, 0x1c, 0x00, 0x32, 0x00, 0x00, 'c', 'm',
1104 'p', 'f', 0x00, 0x00, 0x00, 0x0a, 0x00, 0x01,
1105 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1108 if (buff_size < sizeof(rsrc_footer))
1110 memcpy(buff, rsrc_footer, sizeof(rsrc_footer));
1111 return (sizeof(rsrc_footer));
1115 hfs_reset_compressor(struct archive_write_disk *a)
1119 if (a->stream_valid)
1120 ret = deflateReset(&a->stream);
1122 ret = deflateInit(&a->stream, a->decmpfs_compression_level);
1125 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1126 "Failed to initialize compressor");
1127 return (ARCHIVE_FATAL);
1129 a->stream_valid = 1;
1131 return (ARCHIVE_OK);
1135 hfs_decompress(struct archive_write_disk *a)
1137 uint32_t *block_info;
1138 unsigned int block_count;
1139 uint32_t data_pos, data_size;
1141 ssize_t bytes_written, bytes_to_write;
1144 block_info = (uint32_t *)(a->resource_fork + RSRC_H_SIZE);
1145 block_count = archive_le32dec(block_info++);
1146 while (block_count--) {
1147 data_pos = RSRC_H_SIZE + archive_le32dec(block_info++);
1148 data_size = archive_le32dec(block_info++);
1149 r = fgetxattr(a->fd, XATTR_RESOURCEFORK_NAME,
1150 a->compressed_buffer, data_size, data_pos, 0);
1151 if (r != data_size) {
1152 archive_set_error(&a->archive,
1153 (r < 0)?errno:ARCHIVE_ERRNO_MISC,
1154 "Failed to read resource fork");
1155 return (ARCHIVE_WARN);
1157 if (a->compressed_buffer[0] == 0xff) {
1158 bytes_to_write = data_size -1;
1159 b = a->compressed_buffer + 1;
1161 uLong dest_len = MAX_DECMPFS_BLOCK_SIZE;
1164 zr = uncompress((Bytef *)a->uncompressed_buffer,
1165 &dest_len, a->compressed_buffer, data_size);
1167 archive_set_error(&a->archive,
1169 "Failed to decompress resource fork");
1170 return (ARCHIVE_WARN);
1172 bytes_to_write = dest_len;
1173 b = (unsigned char *)a->uncompressed_buffer;
1176 bytes_written = write(a->fd, b, bytes_to_write);
1177 if (bytes_written < 0) {
1178 archive_set_error(&a->archive, errno,
1180 return (ARCHIVE_WARN);
1182 bytes_to_write -= bytes_written;
1184 } while (bytes_to_write > 0);
1186 r = fremovexattr(a->fd, XATTR_RESOURCEFORK_NAME, 0);
1188 archive_set_error(&a->archive, errno,
1189 "Failed to remove resource fork");
1190 return (ARCHIVE_WARN);
1192 return (ARCHIVE_OK);
1196 hfs_drive_compressor(struct archive_write_disk *a, const char *buff,
1199 unsigned char *buffer_compressed;
1200 size_t bytes_compressed;
1204 ret = hfs_reset_compressor(a);
1205 if (ret != ARCHIVE_OK)
1208 if (a->compressed_buffer == NULL) {
1211 block_size = COMPRESSED_W_SIZE + RSRC_F_SIZE +
1212 + compressBound(MAX_DECMPFS_BLOCK_SIZE);
1213 a->compressed_buffer = malloc(block_size);
1214 if (a->compressed_buffer == NULL) {
1215 archive_set_error(&a->archive, ENOMEM,
1216 "Can't allocate memory for Resource Fork");
1217 return (ARCHIVE_FATAL);
1219 a->compressed_buffer_size = block_size;
1220 a->compressed_buffer_remaining = block_size;
1223 buffer_compressed = a->compressed_buffer +
1224 a->compressed_buffer_size - a->compressed_buffer_remaining;
1225 a->stream.next_in = (Bytef *)(uintptr_t)(const void *)buff;
1226 a->stream.avail_in = size;
1227 a->stream.next_out = buffer_compressed;
1228 a->stream.avail_out = a->compressed_buffer_remaining;
1230 ret = deflate(&a->stream, Z_FINISH);
1236 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1237 "Failed to compress data");
1238 return (ARCHIVE_FAILED);
1240 } while (ret == Z_OK);
1241 bytes_compressed = a->compressed_buffer_remaining - a->stream.avail_out;
1244 * If the compressed size is larger than the original size,
1245 * throw away compressed data, use uncompressed data instead.
1247 if (bytes_compressed > size) {
1248 buffer_compressed[0] = 0xFF;/* uncompressed marker. */
1249 memcpy(buffer_compressed + 1, buff, size);
1250 bytes_compressed = size + 1;
1252 a->compressed_buffer_remaining -= bytes_compressed;
1255 * If the compressed size is smaller than MAX_DECMPFS_XATTR_SIZE
1256 * and the block count in the file is only one, store compressed
1257 * data to decmpfs xattr instead of the resource fork.
1259 if (a->decmpfs_block_count == 1 &&
1260 (a->decmpfs_attr_size + bytes_compressed)
1261 <= MAX_DECMPFS_XATTR_SIZE) {
1262 archive_le32enc(&a->decmpfs_header_p[DECMPFS_COMPRESSION_TYPE],
1264 memcpy(a->decmpfs_header_p + DECMPFS_HEADER_SIZE,
1265 buffer_compressed, bytes_compressed);
1266 a->decmpfs_attr_size += bytes_compressed;
1267 a->compressed_buffer_remaining = a->compressed_buffer_size;
1269 * Finish HFS+ Compression.
1270 * - Write the decmpfs xattr.
1271 * - Set the UF_COMPRESSED file flag.
1273 ret = hfs_write_decmpfs(a);
1274 if (ret == ARCHIVE_OK)
1275 ret = hfs_set_compressed_fflag(a);
1279 /* Update block info. */
1280 archive_le32enc(a->decmpfs_block_info++,
1281 a->compressed_rsrc_position_v - RSRC_H_SIZE);
1282 archive_le32enc(a->decmpfs_block_info++, bytes_compressed);
1283 a->compressed_rsrc_position_v += bytes_compressed;
1286 * Write the compressed data to the resource fork.
1288 bytes_used = a->compressed_buffer_size - a->compressed_buffer_remaining;
1289 while (bytes_used >= COMPRESSED_W_SIZE) {
1290 ret = hfs_write_compressed_data(a, COMPRESSED_W_SIZE);
1291 if (ret != ARCHIVE_OK)
1293 bytes_used -= COMPRESSED_W_SIZE;
1294 if (bytes_used > COMPRESSED_W_SIZE)
1295 memmove(a->compressed_buffer,
1296 a->compressed_buffer + COMPRESSED_W_SIZE,
1299 memcpy(a->compressed_buffer,
1300 a->compressed_buffer + COMPRESSED_W_SIZE,
1303 a->compressed_buffer_remaining = a->compressed_buffer_size - bytes_used;
1306 * If the current block is the last block, write the remaining
1307 * compressed data and the resource fork footer.
1309 if (a->file_remaining_bytes == 0) {
1313 /* Append the resource footer. */
1314 rsrc_size = hfs_set_resource_fork_footer(
1315 a->compressed_buffer + bytes_used,
1316 a->compressed_buffer_remaining);
1317 ret = hfs_write_compressed_data(a, bytes_used + rsrc_size);
1318 a->compressed_buffer_remaining = a->compressed_buffer_size;
1320 /* If the compressed size is not enough smaller than
1321 * the uncompressed size. cancel HFS+ compression.
1322 * TODO: study a behavior of ditto utility and improve
1323 * the condition to fall back into no HFS+ compression. */
1324 bk = HFS_BLOCKS(a->compressed_rsrc_position);
1326 if (bk > HFS_BLOCKS(a->filesize))
1327 return hfs_decompress(a);
1329 * Write the resourcefork header.
1331 if (ret == ARCHIVE_OK)
1332 ret = hfs_write_resource_fork_header(a);
1334 * Finish HFS+ Compression.
1335 * - Write the decmpfs xattr.
1336 * - Set the UF_COMPRESSED file flag.
1338 if (ret == ARCHIVE_OK)
1339 ret = hfs_write_decmpfs(a);
1340 if (ret == ARCHIVE_OK)
1341 ret = hfs_set_compressed_fflag(a);
1347 hfs_write_decmpfs_block(struct archive_write_disk *a, const char *buff,
1350 const char *buffer_to_write;
1351 size_t bytes_to_write;
1354 if (a->decmpfs_block_count == (unsigned)-1) {
1357 unsigned int block_count;
1359 if (a->decmpfs_header_p == NULL) {
1360 new_block = malloc(MAX_DECMPFS_XATTR_SIZE
1361 + sizeof(uint32_t));
1362 if (new_block == NULL) {
1363 archive_set_error(&a->archive, ENOMEM,
1364 "Can't allocate memory for decmpfs");
1365 return (ARCHIVE_FATAL);
1367 a->decmpfs_header_p = new_block;
1369 a->decmpfs_attr_size = DECMPFS_HEADER_SIZE;
1370 archive_le32enc(&a->decmpfs_header_p[DECMPFS_COMPRESSION_MAGIC],
1372 archive_le32enc(&a->decmpfs_header_p[DECMPFS_COMPRESSION_TYPE],
1374 archive_le64enc(&a->decmpfs_header_p[DECMPFS_UNCOMPRESSED_SIZE],
1377 /* Calculate a block count of the file. */
1379 (a->filesize + MAX_DECMPFS_BLOCK_SIZE -1) /
1380 MAX_DECMPFS_BLOCK_SIZE;
1382 * Allocate buffer for resource fork.
1383 * Set up related pointers;
1386 RSRC_H_SIZE + /* header */
1387 4 + /* Block count */
1388 (block_count * sizeof(uint32_t) * 2) +
1389 RSRC_F_SIZE; /* footer */
1390 if (new_size > a->resource_fork_allocated_size) {
1391 new_block = realloc(a->resource_fork, new_size);
1392 if (new_block == NULL) {
1393 archive_set_error(&a->archive, ENOMEM,
1394 "Can't allocate memory for ResourceFork");
1395 return (ARCHIVE_FATAL);
1397 a->resource_fork_allocated_size = new_size;
1398 a->resource_fork = new_block;
1401 /* Allocate uncompressed buffer */
1402 if (a->uncompressed_buffer == NULL) {
1403 new_block = malloc(MAX_DECMPFS_BLOCK_SIZE);
1404 if (new_block == NULL) {
1405 archive_set_error(&a->archive, ENOMEM,
1406 "Can't allocate memory for decmpfs");
1407 return (ARCHIVE_FATAL);
1409 a->uncompressed_buffer = new_block;
1411 a->block_remaining_bytes = MAX_DECMPFS_BLOCK_SIZE;
1412 a->file_remaining_bytes = a->filesize;
1413 a->compressed_buffer_remaining = a->compressed_buffer_size;
1416 * Set up a resource fork.
1418 a->rsrc_xattr_options = XATTR_CREATE;
1419 /* Get the position where we are going to set a bunch
1421 a->decmpfs_block_info =
1422 (uint32_t *)(a->resource_fork + RSRC_H_SIZE);
1423 /* Set the block count to the resource fork. */
1424 archive_le32enc(a->decmpfs_block_info++, block_count);
1425 /* Get the position where we are going to set compressed
1427 a->compressed_rsrc_position =
1428 RSRC_H_SIZE + 4 + (block_count * 8);
1429 a->compressed_rsrc_position_v = a->compressed_rsrc_position;
1430 a->decmpfs_block_count = block_count;
1433 /* Ignore redundant bytes. */
1434 if (a->file_remaining_bytes == 0)
1435 return ((ssize_t)size);
1437 /* Do not overrun a block size. */
1438 if (size > a->block_remaining_bytes)
1439 bytes_to_write = a->block_remaining_bytes;
1441 bytes_to_write = size;
1442 /* Do not overrun the file size. */
1443 if (bytes_to_write > a->file_remaining_bytes)
1444 bytes_to_write = a->file_remaining_bytes;
1446 /* For efficiency, if a copy length is full of the uncompressed
1447 * buffer size, do not copy writing data to it. */
1448 if (bytes_to_write == MAX_DECMPFS_BLOCK_SIZE)
1449 buffer_to_write = buff;
1451 memcpy(a->uncompressed_buffer +
1452 MAX_DECMPFS_BLOCK_SIZE - a->block_remaining_bytes,
1453 buff, bytes_to_write);
1454 buffer_to_write = a->uncompressed_buffer;
1456 a->block_remaining_bytes -= bytes_to_write;
1457 a->file_remaining_bytes -= bytes_to_write;
1459 if (a->block_remaining_bytes == 0 || a->file_remaining_bytes == 0) {
1460 ret = hfs_drive_compressor(a, buffer_to_write,
1461 MAX_DECMPFS_BLOCK_SIZE - a->block_remaining_bytes);
1464 a->block_remaining_bytes = MAX_DECMPFS_BLOCK_SIZE;
1466 /* Ignore redundant bytes. */
1467 if (a->file_remaining_bytes == 0)
1468 return ((ssize_t)size);
1469 return (bytes_to_write);
1473 hfs_write_data_block(struct archive_write_disk *a, const char *buff,
1476 uint64_t start_size = size;
1477 ssize_t bytes_written = 0;
1478 ssize_t bytes_to_write;
1481 return (ARCHIVE_OK);
1483 if (a->filesize == 0 || a->fd < 0) {
1484 archive_set_error(&a->archive, 0,
1485 "Attempt to write to an empty file");
1486 return (ARCHIVE_WARN);
1489 /* If this write would run beyond the file size, truncate it. */
1490 if (a->filesize >= 0 && (int64_t)(a->offset + size) > a->filesize)
1491 start_size = size = (size_t)(a->filesize - a->offset);
1493 /* Write the data. */
1495 bytes_to_write = size;
1496 /* Seek if necessary to the specified offset. */
1497 if (a->offset < a->fd_offset) {
1498 /* Can't support backward move. */
1499 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1501 return (ARCHIVE_FATAL);
1502 } else if (a->offset > a->fd_offset) {
1503 int64_t skip = a->offset - a->fd_offset;
1504 char nullblock[1024];
1506 memset(nullblock, 0, sizeof(nullblock));
1508 if (skip > (int64_t)sizeof(nullblock))
1509 bytes_written = hfs_write_decmpfs_block(
1510 a, nullblock, sizeof(nullblock));
1512 bytes_written = hfs_write_decmpfs_block(
1513 a, nullblock, skip);
1514 if (bytes_written < 0) {
1515 archive_set_error(&a->archive, errno,
1517 return (ARCHIVE_WARN);
1519 skip -= bytes_written;
1522 a->fd_offset = a->offset;
1525 hfs_write_decmpfs_block(a, buff, bytes_to_write);
1526 if (bytes_written < 0)
1527 return (bytes_written);
1528 buff += bytes_written;
1529 size -= bytes_written;
1530 a->total_bytes_written += bytes_written;
1531 a->offset += bytes_written;
1532 a->fd_offset = a->offset;
1534 return (start_size - size);
1538 hfs_write_data_block(struct archive_write_disk *a, const char *buff,
1541 return (write_data_block(a, buff, size));
1546 _archive_write_disk_data_block(struct archive *_a,
1547 const void *buff, size_t size, int64_t offset)
1549 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1552 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1553 ARCHIVE_STATE_DATA, "archive_write_data_block");
1556 if (a->todo & TODO_HFS_COMPRESSION)
1557 r = hfs_write_data_block(a, buff, size);
1559 r = write_data_block(a, buff, size);
1562 if ((size_t)r < size) {
1563 archive_set_error(&a->archive, 0,
1564 "Too much data: Truncating file at %ju bytes",
1565 (uintmax_t)a->filesize);
1566 return (ARCHIVE_WARN);
1568 #if ARCHIVE_VERSION_NUMBER < 3999000
1569 return (ARCHIVE_OK);
1576 _archive_write_disk_data(struct archive *_a, const void *buff, size_t size)
1578 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1580 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1581 ARCHIVE_STATE_DATA, "archive_write_data");
1583 if (a->todo & TODO_HFS_COMPRESSION)
1584 return (hfs_write_data_block(a, buff, size));
1585 return (write_data_block(a, buff, size));
1589 _archive_write_disk_finish_entry(struct archive *_a)
1591 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1592 int ret = ARCHIVE_OK;
1594 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1595 ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
1596 "archive_write_finish_entry");
1597 if (a->archive.state & ARCHIVE_STATE_HEADER)
1598 return (ARCHIVE_OK);
1599 archive_clear_error(&a->archive);
1601 /* Pad or truncate file to the right size. */
1603 /* There's no file. */
1604 } else if (a->filesize < 0) {
1605 /* File size is unknown, so we can't set the size. */
1606 } else if (a->fd_offset == a->filesize) {
1607 /* Last write ended at exactly the filesize; we're done. */
1608 /* Hopefully, this is the common case. */
1609 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
1610 } else if (a->todo & TODO_HFS_COMPRESSION) {
1614 if (a->file_remaining_bytes)
1615 memset(null_d, 0, sizeof(null_d));
1616 while (a->file_remaining_bytes) {
1617 if (a->file_remaining_bytes > sizeof(null_d))
1618 r = hfs_write_data_block(
1619 a, null_d, sizeof(null_d));
1621 r = hfs_write_data_block(
1622 a, null_d, a->file_remaining_bytes);
1629 if (ftruncate(a->fd, a->filesize) == -1 &&
1631 archive_set_error(&a->archive, errno,
1632 "File size could not be restored");
1633 return (ARCHIVE_FAILED);
1637 * Not all platforms implement the XSI option to
1638 * extend files via ftruncate. Stat() the file again
1639 * to see what happened.
1642 if ((ret = lazy_stat(a)) != ARCHIVE_OK)
1644 /* We can use lseek()/write() to extend the file if
1645 * ftruncate didn't work or isn't available. */
1646 if (a->st.st_size < a->filesize) {
1647 const char nul = '\0';
1648 if (lseek(a->fd, a->filesize - 1, SEEK_SET) < 0) {
1649 archive_set_error(&a->archive, errno,
1651 return (ARCHIVE_FATAL);
1653 if (write(a->fd, &nul, 1) < 0) {
1654 archive_set_error(&a->archive, errno,
1655 "Write to restore size failed");
1656 return (ARCHIVE_FATAL);
1662 /* Restore metadata. */
1665 * This is specific to Mac OS X.
1666 * If the current file is an AppleDouble file, it should be
1667 * linked with the data fork file and remove it.
1669 if (a->todo & TODO_APPLEDOUBLE) {
1670 int r2 = fixup_appledouble(a, a->name);
1671 if (r2 == ARCHIVE_EOF) {
1672 /* The current file has been successfully linked
1673 * with the data fork file and removed. So there
1674 * is nothing to do on the current file. */
1675 goto finish_metadata;
1677 if (r2 < ret) ret = r2;
1681 * Look up the "real" UID only if we're going to need it.
1682 * TODO: the TODO_SGID condition can be dropped here, can't it?
1684 if (a->todo & (TODO_OWNER | TODO_SUID | TODO_SGID)) {
1685 a->uid = archive_write_disk_uid(&a->archive,
1686 archive_entry_uname(a->entry),
1687 archive_entry_uid(a->entry));
1689 /* Look up the "real" GID only if we're going to need it. */
1690 /* TODO: the TODO_SUID condition can be dropped here, can't it? */
1691 if (a->todo & (TODO_OWNER | TODO_SGID | TODO_SUID)) {
1692 a->gid = archive_write_disk_gid(&a->archive,
1693 archive_entry_gname(a->entry),
1694 archive_entry_gid(a->entry));
1698 * Restore ownership before set_mode tries to restore suid/sgid
1699 * bits. If we set the owner, we know what it is and can skip
1700 * a stat() call to examine the ownership of the file on disk.
1702 if (a->todo & TODO_OWNER) {
1703 int r2 = set_ownership(a);
1704 if (r2 < ret) ret = r2;
1709 * If we're not root, we won't be setting any security
1710 * attributes that may be wiped by the set_mode() routine
1711 * below. We also can't set xattr on non-owner-writable files,
1712 * which may be the state after set_mode(). Perform
1713 * set_xattrs() first based on these constraints.
1715 if (a->user_uid != 0 &&
1716 (a->todo & TODO_XATTR)) {
1717 int r2 = set_xattrs(a);
1718 if (r2 < ret) ret = r2;
1722 * set_mode must precede ACLs on systems such as Solaris and
1723 * FreeBSD where setting the mode implicitly clears extended ACLs
1725 if (a->todo & TODO_MODE) {
1726 int r2 = set_mode(a, a->mode);
1727 if (r2 < ret) ret = r2;
1731 * Security-related extended attributes (such as
1732 * security.capability on Linux) have to be restored last,
1733 * since they're implicitly removed by other file changes.
1734 * We do this last only when root.
1736 if (a->user_uid == 0 &&
1737 (a->todo & TODO_XATTR)) {
1738 int r2 = set_xattrs(a);
1739 if (r2 < ret) ret = r2;
1743 * Some flags prevent file modification; they must be restored after
1744 * file contents are written.
1746 if (a->todo & TODO_FFLAGS) {
1747 int r2 = set_fflags(a);
1748 if (r2 < ret) ret = r2;
1752 * Time must follow most other metadata;
1753 * otherwise atime will get changed.
1755 if (a->todo & TODO_TIMES) {
1756 int r2 = set_times_from_entry(a);
1757 if (r2 < ret) ret = r2;
1761 * Mac extended metadata includes ACLs.
1763 if (a->todo & TODO_MAC_METADATA) {
1764 const void *metadata;
1765 size_t metadata_size;
1766 metadata = archive_entry_mac_metadata(a->entry, &metadata_size);
1767 if (metadata != NULL && metadata_size > 0) {
1768 int r2 = set_mac_metadata(a, archive_entry_pathname(
1769 a->entry), metadata, metadata_size);
1770 if (r2 < ret) ret = r2;
1775 * ACLs must be restored after timestamps because there are
1776 * ACLs that prevent attribute changes (including time).
1778 if (a->todo & TODO_ACLS) {
1780 r2 = archive_write_disk_set_acls(&a->archive, a->fd,
1781 archive_entry_pathname(a->entry),
1782 archive_entry_acl(a->entry),
1783 archive_entry_mode(a->entry));
1784 if (r2 < ret) ret = r2;
1788 /* If there's an fd, we can close it now. */
1793 /* If there's an entry, we can release it now. */
1794 archive_entry_free(a->entry);
1796 a->archive.state = ARCHIVE_STATE_HEADER;
1801 archive_write_disk_set_group_lookup(struct archive *_a,
1803 la_int64_t (*lookup_gid)(void *private, const char *gname, la_int64_t gid),
1804 void (*cleanup_gid)(void *private))
1806 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1807 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1808 ARCHIVE_STATE_ANY, "archive_write_disk_set_group_lookup");
1810 if (a->cleanup_gid != NULL && a->lookup_gid_data != NULL)
1811 (a->cleanup_gid)(a->lookup_gid_data);
1813 a->lookup_gid = lookup_gid;
1814 a->cleanup_gid = cleanup_gid;
1815 a->lookup_gid_data = private_data;
1816 return (ARCHIVE_OK);
1820 archive_write_disk_set_user_lookup(struct archive *_a,
1822 int64_t (*lookup_uid)(void *private, const char *uname, int64_t uid),
1823 void (*cleanup_uid)(void *private))
1825 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1826 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1827 ARCHIVE_STATE_ANY, "archive_write_disk_set_user_lookup");
1829 if (a->cleanup_uid != NULL && a->lookup_uid_data != NULL)
1830 (a->cleanup_uid)(a->lookup_uid_data);
1832 a->lookup_uid = lookup_uid;
1833 a->cleanup_uid = cleanup_uid;
1834 a->lookup_uid_data = private_data;
1835 return (ARCHIVE_OK);
1839 archive_write_disk_gid(struct archive *_a, const char *name, la_int64_t id)
1841 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1842 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1843 ARCHIVE_STATE_ANY, "archive_write_disk_gid");
1845 return (a->lookup_gid)(a->lookup_gid_data, name, id);
1850 archive_write_disk_uid(struct archive *_a, const char *name, la_int64_t id)
1852 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1853 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1854 ARCHIVE_STATE_ANY, "archive_write_disk_uid");
1856 return (a->lookup_uid)(a->lookup_uid_data, name, id);
1861 * Create a new archive_write_disk object and initialize it with global state.
1864 archive_write_disk_new(void)
1866 struct archive_write_disk *a;
1868 a = (struct archive_write_disk *)calloc(1, sizeof(*a));
1871 a->archive.magic = ARCHIVE_WRITE_DISK_MAGIC;
1872 /* We're ready to write a header immediately. */
1873 a->archive.state = ARCHIVE_STATE_HEADER;
1874 a->archive.vtable = archive_write_disk_vtable();
1875 a->start_time = time(NULL);
1876 /* Query and restore the umask. */
1877 umask(a->user_umask = umask(0));
1879 a->user_uid = geteuid();
1880 #endif /* HAVE_GETEUID */
1881 if (archive_string_ensure(&a->path_safe, 512) == NULL) {
1886 a->decmpfs_compression_level = 5;
1888 return (&a->archive);
1893 * If pathname is longer than PATH_MAX, chdir to a suitable
1894 * intermediate dir and edit the path down to a shorter suffix. Note
1895 * that this routine never returns an error; if the chdir() attempt
1896 * fails for any reason, we just go ahead with the long pathname. The
1897 * object creation is likely to fail, but any error will get handled
1900 #if defined(HAVE_FCHDIR) && defined(PATH_MAX)
1902 edit_deep_directories(struct archive_write_disk *a)
1905 char *tail = a->name;
1907 /* If path is short, avoid the open() below. */
1908 if (strlen(tail) < PATH_MAX)
1911 /* Try to record our starting dir. */
1912 a->restore_pwd = open(".", O_RDONLY | O_BINARY | O_CLOEXEC);
1913 __archive_ensure_cloexec_flag(a->restore_pwd);
1914 if (a->restore_pwd < 0)
1917 /* As long as the path is too long... */
1918 while (strlen(tail) >= PATH_MAX) {
1919 /* Locate a dir prefix shorter than PATH_MAX. */
1920 tail += PATH_MAX - 8;
1921 while (tail > a->name && *tail != '/')
1923 /* Exit if we find a too-long path component. */
1924 if (tail <= a->name)
1926 /* Create the intermediate dir and chdir to it. */
1927 *tail = '\0'; /* Terminate dir portion */
1928 ret = create_dir(a, a->name);
1929 if (ret == ARCHIVE_OK && chdir(a->name) != 0)
1930 ret = ARCHIVE_FAILED;
1931 *tail = '/'; /* Restore the / we removed. */
1932 if (ret != ARCHIVE_OK)
1935 /* The chdir() succeeded; we've now shortened the path. */
1943 * The main restore function.
1946 restore_entry(struct archive_write_disk *a)
1948 int ret = ARCHIVE_OK, en;
1950 if (a->flags & ARCHIVE_EXTRACT_UNLINK && !S_ISDIR(a->mode)) {
1952 * TODO: Fix this. Apparently, there are platforms
1953 * that still allow root to hose the entire filesystem
1954 * by unlinking a dir. The S_ISDIR() test above
1955 * prevents us from using unlink() here if the new
1956 * object is a dir, but that doesn't mean the old
1957 * object isn't a dir.
1959 if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS)
1960 (void)clear_nochange_fflags(a);
1961 if (unlink(a->name) == 0) {
1962 /* We removed it, reset cached stat. */
1964 } else if (errno == ENOENT) {
1965 /* File didn't exist, that's just as good. */
1966 } else if (rmdir(a->name) == 0) {
1967 /* It was a dir, but now it's gone. */
1970 /* We tried, but couldn't get rid of it. */
1971 archive_set_error(&a->archive, errno,
1972 "Could not unlink");
1973 return(ARCHIVE_FAILED);
1977 /* Try creating it first; if this fails, we'll try to recover. */
1978 en = create_filesystem_object(a);
1980 if ((en == ENOTDIR || en == ENOENT)
1981 && !(a->flags & ARCHIVE_EXTRACT_NO_AUTODIR)) {
1982 /* If the parent dir doesn't exist, try creating it. */
1983 create_parent_dir(a, a->name);
1984 /* Now try to create the object again. */
1985 en = create_filesystem_object(a);
1988 if ((en == ENOENT) && (archive_entry_hardlink(a->entry) != NULL)) {
1989 archive_set_error(&a->archive, en,
1990 "Hard-link target '%s' does not exist.",
1991 archive_entry_hardlink(a->entry));
1992 return (ARCHIVE_FAILED);
1995 if ((en == EISDIR || en == EEXIST)
1996 && (a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) {
1997 /* If we're not overwriting, we're done. */
1998 if (S_ISDIR(a->mode)) {
1999 /* Don't overwrite any settings on existing directories. */
2002 archive_entry_unset_size(a->entry);
2003 return (ARCHIVE_OK);
2007 * Some platforms return EISDIR if you call
2008 * open(O_WRONLY | O_EXCL | O_CREAT) on a directory, some
2009 * return EEXIST. POSIX is ambiguous, requiring EISDIR
2010 * for open(O_WRONLY) on a dir and EEXIST for open(O_EXCL | O_CREAT)
2011 * on an existing item.
2014 /* A dir is in the way of a non-dir, rmdir it. */
2015 if (rmdir(a->name) != 0) {
2016 archive_set_error(&a->archive, errno,
2017 "Can't remove already-existing dir");
2018 return (ARCHIVE_FAILED);
2022 en = create_filesystem_object(a);
2023 } else if (en == EEXIST) {
2025 * We know something is in the way, but we don't know what;
2026 * we need to find out before we go any further.
2030 * The SECURE_SYMLINKS logic has already removed a
2031 * symlink to a dir if the client wants that. So
2032 * follow the symlink if we're creating a dir.
2034 if (S_ISDIR(a->mode))
2035 r = la_stat(a->name, &a->st);
2037 * If it's not a dir (or it's a broken symlink),
2038 * then don't follow it.
2040 if (r != 0 || !S_ISDIR(a->mode))
2041 r = lstat(a->name, &a->st);
2043 archive_set_error(&a->archive, errno,
2044 "Can't stat existing object");
2045 return (ARCHIVE_FAILED);
2049 * NO_OVERWRITE_NEWER doesn't apply to directories.
2051 if ((a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER)
2052 && !S_ISDIR(a->st.st_mode)) {
2053 if (!older(&(a->st), a->entry)) {
2054 archive_entry_unset_size(a->entry);
2055 return (ARCHIVE_OK);
2059 /* If it's our archive, we're done. */
2060 if (a->skip_file_set &&
2061 a->st.st_dev == (dev_t)a->skip_file_dev &&
2062 a->st.st_ino == (ino_t)a->skip_file_ino) {
2063 archive_set_error(&a->archive, 0,
2064 "Refusing to overwrite archive");
2065 return (ARCHIVE_FAILED);
2068 if (!S_ISDIR(a->st.st_mode)) {
2069 /* A non-dir is in the way, unlink it. */
2070 if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS)
2071 (void)clear_nochange_fflags(a);
2072 if (unlink(a->name) != 0) {
2073 archive_set_error(&a->archive, errno,
2074 "Can't unlink already-existing object");
2075 return (ARCHIVE_FAILED);
2079 en = create_filesystem_object(a);
2080 } else if (!S_ISDIR(a->mode)) {
2081 /* A dir is in the way of a non-dir, rmdir it. */
2082 if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS)
2083 (void)clear_nochange_fflags(a);
2084 if (rmdir(a->name) != 0) {
2085 archive_set_error(&a->archive, errno,
2086 "Can't replace existing directory with non-directory");
2087 return (ARCHIVE_FAILED);
2090 en = create_filesystem_object(a);
2093 * There's a dir in the way of a dir. Don't
2094 * waste time with rmdir()/mkdir(), just fix
2095 * up the permissions on the existing dir.
2096 * Note that we don't change perms on existing
2097 * dirs unless _EXTRACT_PERM is specified.
2099 if ((a->mode != a->st.st_mode)
2100 && (a->todo & TODO_MODE_FORCE))
2101 a->deferred |= (a->todo & TODO_MODE);
2102 /* Ownership doesn't need deferred fixup. */
2103 en = 0; /* Forget the EEXIST. */
2108 /* Everything failed; give up here. */
2109 if ((&a->archive)->error == NULL)
2110 archive_set_error(&a->archive, en, "Can't create '%s'",
2112 return (ARCHIVE_FAILED);
2115 a->pst = NULL; /* Cached stat data no longer valid. */
2120 * Returns 0 if creation succeeds, or else returns errno value from
2121 * the failed system call. Note: This function should only ever perform
2122 * a single system call.
2125 create_filesystem_object(struct archive_write_disk *a)
2127 /* Create the entry. */
2128 const char *linkname;
2129 mode_t final_mode, mode;
2131 /* these for check_symlinks_fsobj */
2132 char *linkname_copy; /* non-const copy of linkname */
2134 struct archive_string error_string;
2137 /* We identify hard/symlinks according to the link names. */
2138 /* Since link(2) and symlink(2) don't handle modes, we're done here. */
2139 linkname = archive_entry_hardlink(a->entry);
2140 if (linkname != NULL) {
2144 archive_string_init(&error_string);
2145 linkname_copy = strdup(linkname);
2146 if (linkname_copy == NULL) {
2150 * TODO: consider using the cleaned-up path as the link
2153 r = cleanup_pathname_fsobj(linkname_copy, &error_number,
2154 &error_string, a->flags);
2155 if (r != ARCHIVE_OK) {
2156 archive_set_error(&a->archive, error_number, "%s",
2158 free(linkname_copy);
2159 archive_string_free(&error_string);
2161 * EPERM is more appropriate than error_number for our
2166 r = check_symlinks_fsobj(linkname_copy, &error_number,
2167 &error_string, a->flags);
2168 if (r != ARCHIVE_OK) {
2169 archive_set_error(&a->archive, error_number, "%s",
2171 free(linkname_copy);
2172 archive_string_free(&error_string);
2174 * EPERM is more appropriate than error_number for our
2179 free(linkname_copy);
2180 archive_string_free(&error_string);
2181 r = link(linkname, a->name) ? errno : 0;
2183 * New cpio and pax formats allow hardlink entries
2184 * to carry data, so we may have to open the file
2185 * for hardlink entries.
2187 * If the hardlink was successfully created and
2188 * the archive doesn't have carry data for it,
2189 * consider it to be non-authoritative for meta data.
2190 * This is consistent with GNU tar and BSD pax.
2191 * If the hardlink does carry data, let the last
2192 * archive entry decide ownership.
2194 if (r == 0 && a->filesize <= 0) {
2197 } else if (r == 0 && a->filesize > 0) {
2199 r = lstat(a->name, &st);
2201 r = la_stat(a->name, &st);
2205 else if ((st.st_mode & AE_IFMT) == AE_IFREG) {
2206 a->fd = open(a->name, O_WRONLY | O_TRUNC |
2207 O_BINARY | O_CLOEXEC | O_NOFOLLOW);
2208 __archive_ensure_cloexec_flag(a->fd);
2216 linkname = archive_entry_symlink(a->entry);
2217 if (linkname != NULL) {
2219 return symlink(linkname, a->name) ? errno : 0;
2226 * The remaining system calls all set permissions, so let's
2227 * try to take advantage of that to avoid an extra chmod()
2228 * call. (Recall that umask is set to zero right now!)
2231 /* Mode we want for the final restored object (w/o file type bits). */
2232 final_mode = a->mode & 07777;
2234 * The mode that will actually be restored in this step. Note
2235 * that SUID, SGID, etc, require additional work to ensure
2236 * security, so we never restore them at this point.
2238 mode = final_mode & 0777 & ~a->user_umask;
2241 * Always create writable such that [f]setxattr() works if we're not
2244 if (a->user_uid != 0 &&
2245 a->todo & (TODO_HFS_COMPRESSION | TODO_XATTR)) {
2249 switch (a->mode & AE_IFMT) {
2251 /* POSIX requires that we fall through here. */
2254 a->fd = open(a->name,
2255 O_WRONLY | O_CREAT | O_EXCL | O_BINARY | O_CLOEXEC, mode);
2256 __archive_ensure_cloexec_flag(a->fd);
2261 /* Note: we use AE_IFCHR for the case label, and
2262 * S_IFCHR for the mknod() call. This is correct. */
2263 r = mknod(a->name, mode | S_IFCHR,
2264 archive_entry_rdev(a->entry));
2267 /* TODO: Find a better way to warn about our inability
2268 * to restore a char device node. */
2270 #endif /* HAVE_MKNOD */
2273 r = mknod(a->name, mode | S_IFBLK,
2274 archive_entry_rdev(a->entry));
2277 /* TODO: Find a better way to warn about our inability
2278 * to restore a block device node. */
2280 #endif /* HAVE_MKNOD */
2282 mode = (mode | MINIMUM_DIR_MODE) & MAXIMUM_DIR_MODE;
2283 r = mkdir(a->name, mode);
2285 /* Defer setting dir times. */
2286 a->deferred |= (a->todo & TODO_TIMES);
2287 a->todo &= ~TODO_TIMES;
2288 /* Never use an immediate chmod(). */
2289 /* We can't avoid the chmod() entirely if EXTRACT_PERM
2290 * because of SysV SGID inheritance. */
2291 if ((mode != final_mode)
2292 || (a->flags & ARCHIVE_EXTRACT_PERM))
2293 a->deferred |= (a->todo & TODO_MODE);
2294 a->todo &= ~TODO_MODE;
2299 r = mkfifo(a->name, mode);
2302 /* TODO: Find a better way to warn about our inability
2303 * to restore a fifo. */
2305 #endif /* HAVE_MKFIFO */
2308 /* All the system calls above set errno on failure. */
2312 /* If we managed to set the final mode, we've avoided a chmod(). */
2313 if (mode == final_mode)
2314 a->todo &= ~TODO_MODE;
2319 * Cleanup function for archive_extract. Mostly, this involves processing
2320 * the fixup list, which is used to address a number of problems:
2321 * * Dir permissions might prevent us from restoring a file in that
2322 * dir, so we restore the dir with minimum 0700 permissions first,
2323 * then correct the mode at the end.
2324 * * Similarly, the act of restoring a file touches the directory
2325 * and changes the timestamp on the dir, so we have to touch-up dir
2326 * timestamps at the end as well.
2327 * * Some file flags can interfere with the restore by, for example,
2328 * preventing the creation of hardlinks to those files.
2329 * * Mac OS extended metadata includes ACLs, so must be deferred on dirs.
2331 * Note that tar/cpio do not require that archives be in a particular
2332 * order; there is no way to know when the last file has been restored
2333 * within a directory, so there's no way to optimize the memory usage
2334 * here by fixing up the directory any earlier than the
2337 * XXX TODO: Directory ACLs should be restored here, for the same
2338 * reason we set directory perms here. XXX
2341 _archive_write_disk_close(struct archive *_a)
2343 struct archive_write_disk *a = (struct archive_write_disk *)_a;
2344 struct fixup_entry *next, *p;
2347 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
2348 ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
2349 "archive_write_disk_close");
2350 ret = _archive_write_disk_finish_entry(&a->archive);
2352 /* Sort dir list so directories are fixed up in depth-first order. */
2353 p = sort_dir_list(a->fixup_list);
2356 a->pst = NULL; /* Mark stat cache as out-of-date. */
2357 if (p->fixup & TODO_TIMES) {
2358 set_times(a, -1, p->mode, p->name,
2359 p->atime, p->atime_nanos,
2360 p->birthtime, p->birthtime_nanos,
2361 p->mtime, p->mtime_nanos,
2362 p->ctime, p->ctime_nanos);
2364 if (p->fixup & TODO_MODE_BASE)
2365 chmod(p->name, p->mode);
2366 if (p->fixup & TODO_ACLS)
2367 archive_write_disk_set_acls(&a->archive, -1, p->name,
2369 if (p->fixup & TODO_FFLAGS)
2370 set_fflags_platform(a, -1, p->name,
2371 p->mode, p->fflags_set, 0);
2372 if (p->fixup & TODO_MAC_METADATA)
2373 set_mac_metadata(a, p->name, p->mac_metadata,
2374 p->mac_metadata_size);
2376 archive_acl_clear(&p->acl);
2377 free(p->mac_metadata);
2382 a->fixup_list = NULL;
2387 _archive_write_disk_free(struct archive *_a)
2389 struct archive_write_disk *a;
2392 return (ARCHIVE_OK);
2393 archive_check_magic(_a, ARCHIVE_WRITE_DISK_MAGIC,
2394 ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_disk_free");
2395 a = (struct archive_write_disk *)_a;
2396 ret = _archive_write_disk_close(&a->archive);
2397 archive_write_disk_set_group_lookup(&a->archive, NULL, NULL, NULL);
2398 archive_write_disk_set_user_lookup(&a->archive, NULL, NULL, NULL);
2399 archive_entry_free(a->entry);
2400 archive_string_free(&a->_name_data);
2401 archive_string_free(&a->archive.error_string);
2402 archive_string_free(&a->path_safe);
2403 a->archive.magic = 0;
2404 __archive_clean(&a->archive);
2405 free(a->decmpfs_header_p);
2406 free(a->resource_fork);
2407 free(a->compressed_buffer);
2408 free(a->uncompressed_buffer);
2409 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_SYS_XATTR_H)\
2410 && defined(HAVE_ZLIB_H)
2411 if (a->stream_valid) {
2412 switch (deflateEnd(&a->stream)) {
2416 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2417 "Failed to clean up compressor");
2418 ret = ARCHIVE_FATAL;
2428 * Simple O(n log n) merge sort to order the fixup list. In
2429 * particular, we want to restore dir timestamps depth-first.
2431 static struct fixup_entry *
2432 sort_dir_list(struct fixup_entry *p)
2434 struct fixup_entry *a, *b, *t;
2438 /* A one-item list is already sorted. */
2439 if (p->next == NULL)
2442 /* Step 1: split the list. */
2446 /* Step a twice, t once. */
2452 /* Now, t is at the mid-point, so break the list here. */
2457 /* Step 2: Recursively sort the two sub-lists. */
2458 a = sort_dir_list(a);
2459 b = sort_dir_list(b);
2461 /* Step 3: Merge the returned lists. */
2462 /* Pick the first element for the merged list. */
2463 if (strcmp(a->name, b->name) > 0) {
2471 /* Always put the later element on the list first. */
2472 while (a != NULL && b != NULL) {
2473 if (strcmp(a->name, b->name) > 0) {
2483 /* Only one list is non-empty, so just splice it on. */
2493 * Returns a new, initialized fixup entry.
2495 * TODO: Reduce the memory requirements for this list by using a tree
2496 * structure rather than a simple list of names.
2498 static struct fixup_entry *
2499 new_fixup(struct archive_write_disk *a, const char *pathname)
2501 struct fixup_entry *fe;
2503 fe = (struct fixup_entry *)calloc(1, sizeof(struct fixup_entry));
2505 archive_set_error(&a->archive, ENOMEM,
2506 "Can't allocate memory for a fixup");
2509 fe->next = a->fixup_list;
2512 fe->name = strdup(pathname);
2517 * Returns a fixup structure for the current entry.
2519 static struct fixup_entry *
2520 current_fixup(struct archive_write_disk *a, const char *pathname)
2522 if (a->current_fixup == NULL)
2523 a->current_fixup = new_fixup(a, pathname);
2524 return (a->current_fixup);
2527 /* Error helper for new *_fsobj functions */
2529 fsobj_error(int *a_eno, struct archive_string *a_estr,
2530 int err, const char *errstr, const char *path)
2535 archive_string_sprintf(a_estr, "%s%s", errstr, path);
2539 * TODO: Someday, integrate this with the deep dir support; they both
2540 * scan the path and both can be optimized by comparing against other
2543 /* TODO: Extend this to support symlinks on Windows Vista and later. */
2546 * Checks the given path to see if any elements along it are symlinks. Returns
2547 * ARCHIVE_OK if there are none, otherwise puts an error in errmsg.
2550 check_symlinks_fsobj(char *path, int *a_eno, struct archive_string *a_estr,
2553 #if !defined(HAVE_LSTAT)
2554 /* Platform doesn't have lstat, so we can't look for symlinks. */
2555 (void)path; /* UNUSED */
2556 (void)error_number; /* UNUSED */
2557 (void)error_string; /* UNUSED */
2558 (void)flags; /* UNUSED */
2559 return (ARCHIVE_OK);
2561 int res = ARCHIVE_OK;
2570 /* Nothing to do here if name is empty */
2572 return (ARCHIVE_OK);
2575 * Guard against symlink tricks. Reject any archive entry whose
2576 * destination would be altered by a symlink.
2578 * Walk the filename in chunks separated by '/'. For each segment:
2579 * - if it doesn't exist, continue
2580 * - if it's symlink, abort or remove it
2581 * - if it's a directory and it's not the last chunk, cd into it
2583 * head points to the current (relative) path
2584 * tail points to the temporary \0 terminating the segment we're
2585 * currently examining
2586 * c holds what used to be in *tail
2587 * last is 1 if this is the last tail
2589 restore_pwd = open(".", O_RDONLY | O_BINARY | O_CLOEXEC);
2590 __archive_ensure_cloexec_flag(restore_pwd);
2591 if (restore_pwd < 0) {
2592 fsobj_error(a_eno, a_estr, errno,
2593 "Could not open ", path);
2594 return (ARCHIVE_FATAL);
2599 /* TODO: reintroduce a safe cache here? */
2600 /* Skip the root directory if the path is absolute. */
2601 if(tail == path && tail[0] == '/')
2603 /* Keep going until we've checked the entire name.
2604 * head, tail, path all alias the same string, which is
2605 * temporarily zeroed at tail, so be careful restoring the
2606 * stashed (c=tail[0]) for error messages.
2607 * Exiting the loop with break is okay; continue is not.
2611 * Skip the separator we just consumed, plus any adjacent ones
2613 while (*tail == '/')
2615 /* Skip the next path element. */
2616 while (*tail != '\0' && *tail != '/')
2618 /* is this the last path component? */
2619 last = (tail[0] == '\0') || (tail[0] == '/' && tail[1] == '\0');
2620 /* temporarily truncate the string here */
2623 /* Check that we haven't hit a symlink. */
2624 r = lstat(head, &st);
2627 /* We've hit a dir that doesn't exist; stop now. */
2628 if (errno == ENOENT) {
2632 * Treat any other error as fatal - best to be
2634 * Note: This effectively disables deep
2635 * directory support when security checks are
2636 * enabled. Otherwise, very long pathnames that
2637 * trigger an error here could evade the
2639 * TODO: We could do better, but it would
2640 * probably require merging the symlink checks
2641 * with the deep-directory editing.
2643 fsobj_error(a_eno, a_estr, errno,
2644 "Could not stat ", path);
2645 res = ARCHIVE_FAILED;
2648 } else if (S_ISDIR(st.st_mode)) {
2650 if (chdir(head) != 0) {
2652 fsobj_error(a_eno, a_estr, errno,
2653 "Could not chdir ", path);
2654 res = (ARCHIVE_FATAL);
2657 /* Our view is now from inside this dir: */
2660 } else if (S_ISLNK(st.st_mode)) {
2663 * Last element is symlink; remove it
2664 * so we can overwrite it with the
2665 * item being extracted.
2669 fsobj_error(a_eno, a_estr, errno,
2670 "Could not remove symlink ",
2672 res = ARCHIVE_FAILED;
2676 * Even if we did remove it, a warning
2677 * is in order. The warning is silly,
2678 * though, if we're just replacing one
2679 * symlink with another symlink.
2683 * FIXME: not sure how important this is to
2687 if (!S_ISLNK(path)) {
2688 fsobj_error(a_eno, a_estr, 0,
2689 "Removing symlink ", path);
2692 /* Symlink gone. No more problem! */
2695 } else if (flags & ARCHIVE_EXTRACT_UNLINK) {
2696 /* User asked us to remove problems. */
2697 if (unlink(head) != 0) {
2699 fsobj_error(a_eno, a_estr, 0,
2700 "Cannot remove intervening "
2702 res = ARCHIVE_FAILED;
2707 ARCHIVE_EXTRACT_SECURE_SYMLINKS) == 0) {
2709 * We are not the last element and we want to
2710 * follow symlinks if they are a directory.
2712 * This is needed to extract hardlinks over
2715 r = la_stat(head, &st);
2718 if (errno == ENOENT) {
2721 fsobj_error(a_eno, a_estr,
2723 "Could not stat ", path);
2724 res = (ARCHIVE_FAILED);
2727 } else if (S_ISDIR(st.st_mode)) {
2728 if (chdir(head) != 0) {
2730 fsobj_error(a_eno, a_estr,
2732 "Could not chdir ", path);
2733 res = (ARCHIVE_FATAL);
2737 * Our view is now from inside
2743 fsobj_error(a_eno, a_estr, 0,
2744 "Cannot extract through "
2746 res = ARCHIVE_FAILED;
2751 fsobj_error(a_eno, a_estr, 0,
2752 "Cannot extract through symlink ", path);
2753 res = ARCHIVE_FAILED;
2757 /* be sure to always maintain this */
2759 if (tail[0] != '\0')
2760 tail++; /* Advance to the next segment. */
2762 /* Catches loop exits via break */
2765 /* If we changed directory above, restore it here. */
2766 if (restore_pwd >= 0) {
2767 r = fchdir(restore_pwd);
2769 fsobj_error(a_eno, a_estr, errno,
2770 "chdir() failure", "");
2775 res = (ARCHIVE_FATAL);
2779 /* TODO: reintroduce a safe cache here? */
2785 * Check a->name for symlinks, returning ARCHIVE_OK if its clean, otherwise
2786 * calls archive_set_error and returns ARCHIVE_{FATAL,FAILED}
2789 check_symlinks(struct archive_write_disk *a)
2791 struct archive_string error_string;
2794 archive_string_init(&error_string);
2795 rc = check_symlinks_fsobj(a->name, &error_number, &error_string,
2797 if (rc != ARCHIVE_OK) {
2798 archive_set_error(&a->archive, error_number, "%s",
2801 archive_string_free(&error_string);
2802 a->pst = NULL; /* to be safe */
2807 #if defined(__CYGWIN__)
2809 * 1. Convert a path separator from '\' to '/' .
2810 * We shouldn't check multibyte character directly because some
2811 * character-set have been using the '\' character for a part of
2812 * its multibyte character code.
2813 * 2. Replace unusable characters in Windows with underscore('_').
2814 * See also : http://msdn.microsoft.com/en-us/library/aa365247.aspx
2817 cleanup_pathname_win(char *path)
2822 int mb, complete, utf8;
2827 utf8 = (strcmp(nl_langinfo(CODESET), "UTF-8") == 0)? 1: 0;
2828 for (p = path; *p != '\0'; p++) {
2831 /* If previous byte is smaller than 128,
2832 * this is not second byte of multibyte characters,
2833 * so we can replace '\' with '/'. */
2837 complete = 0;/* uncompleted. */
2838 } else if (*(unsigned char *)p > 127)
2842 /* Rewrite the path name if its next character is unusable. */
2843 if (*p == ':' || *p == '*' || *p == '?' || *p == '"' ||
2844 *p == '<' || *p == '>' || *p == '|')
2851 * Convert path separator in wide-character.
2854 while (*p != '\0' && alen) {
2855 l = mbtowc(&wc, p, alen);
2856 if (l == (size_t)-1) {
2857 while (*p != '\0') {
2864 if (l == 1 && wc == L'\\')
2873 * Canonicalize the pathname. In particular, this strips duplicate
2874 * '/' characters, '.' elements, and trailing '/'. It also raises an
2875 * error for an empty path, a trailing '..', (if _SECURE_NODOTDOT is
2876 * set) any '..' in the path or (if ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS
2877 * is set) if the path is absolute.
2880 cleanup_pathname_fsobj(char *path, int *a_eno, struct archive_string *a_estr,
2884 char separator = '\0';
2888 fsobj_error(a_eno, a_estr, ARCHIVE_ERRNO_MISC,
2889 "Invalid empty ", "pathname");
2890 return (ARCHIVE_FAILED);
2893 #if defined(__CYGWIN__)
2894 cleanup_pathname_win(path);
2896 /* Skip leading '/'. */
2898 if (flags & ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS) {
2899 fsobj_error(a_eno, a_estr, ARCHIVE_ERRNO_MISC,
2900 "Path is ", "absolute");
2901 return (ARCHIVE_FAILED);
2907 /* Scan the pathname one element at a time. */
2909 /* src points to first char after '/' */
2910 if (src[0] == '\0') {
2912 } else if (src[0] == '/') {
2913 /* Found '//', ignore second one. */
2916 } else if (src[0] == '.') {
2917 if (src[1] == '\0') {
2918 /* Ignore trailing '.' */
2920 } else if (src[1] == '/') {
2924 } else if (src[1] == '.') {
2925 if (src[2] == '/' || src[2] == '\0') {
2926 /* Conditionally warn about '..' */
2928 & ARCHIVE_EXTRACT_SECURE_NODOTDOT) {
2929 fsobj_error(a_eno, a_estr,
2931 "Path contains ", "'..'");
2932 return (ARCHIVE_FAILED);
2936 * Note: Under no circumstances do we
2937 * remove '..' elements. In
2938 * particular, restoring
2939 * '/foo/../bar/' should create the
2940 * 'foo' dir as a side-effect.
2945 /* Copy current element, including leading '/'. */
2948 while (*src != '\0' && *src != '/') {
2955 /* Skip '/' separator. */
2959 * We've just copied zero or more path elements, not including the
2964 * Nothing got copied. The path must have been something
2965 * like '.' or '/' or './' or '/././././/./'.
2972 /* Terminate the result. */
2974 return (ARCHIVE_OK);
2978 cleanup_pathname(struct archive_write_disk *a)
2980 struct archive_string error_string;
2983 archive_string_init(&error_string);
2984 rc = cleanup_pathname_fsobj(a->name, &error_number, &error_string,
2986 if (rc != ARCHIVE_OK) {
2987 archive_set_error(&a->archive, error_number, "%s",
2990 archive_string_free(&error_string);
2995 * Create the parent directory of the specified path, assuming path
2996 * is already in mutable storage.
2999 create_parent_dir(struct archive_write_disk *a, char *path)
3004 /* Remove tail element to obtain parent name. */
3005 slash = strrchr(path, '/');
3007 return (ARCHIVE_OK);
3009 r = create_dir(a, path);
3015 * Create the specified dir, recursing to create parents as necessary.
3017 * Returns ARCHIVE_OK if the path exists when we're done here.
3018 * Otherwise, returns ARCHIVE_FAILED.
3019 * Assumes path is in mutable storage; path is unchanged on exit.
3022 create_dir(struct archive_write_disk *a, char *path)
3025 struct fixup_entry *le;
3027 mode_t mode_final, mode;
3030 /* Check for special names and just skip them. */
3031 slash = strrchr(path, '/');
3037 if (base[0] == '\0' ||
3038 (base[0] == '.' && base[1] == '\0') ||
3039 (base[0] == '.' && base[1] == '.' && base[2] == '\0')) {
3040 /* Don't bother trying to create null path, '.', or '..'. */
3041 if (slash != NULL) {
3043 r = create_dir(a, path);
3047 return (ARCHIVE_OK);
3051 * Yes, this should be stat() and not lstat(). Using lstat()
3052 * here loses the ability to extract through symlinks. Also note
3053 * that this should not use the a->st cache.
3055 if (la_stat(path, &st) == 0) {
3056 if (S_ISDIR(st.st_mode))
3057 return (ARCHIVE_OK);
3058 if ((a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) {
3059 archive_set_error(&a->archive, EEXIST,
3060 "Can't create directory '%s'", path);
3061 return (ARCHIVE_FAILED);
3063 if (unlink(path) != 0) {
3064 archive_set_error(&a->archive, errno,
3065 "Can't create directory '%s': "
3066 "Conflicting file cannot be removed",
3068 return (ARCHIVE_FAILED);
3070 } else if (errno != ENOENT && errno != ENOTDIR) {
3072 archive_set_error(&a->archive, errno,
3073 "Can't test directory '%s'", path);
3074 return (ARCHIVE_FAILED);
3075 } else if (slash != NULL) {
3077 r = create_dir(a, path);
3079 if (r != ARCHIVE_OK)
3084 * Mode we want for the final restored directory. Per POSIX,
3085 * implicitly-created dirs must be created obeying the umask.
3086 * There's no mention whether this is different for privileged
3087 * restores (which the rest of this code handles by pretending
3088 * umask=0). I've chosen here to always obey the user's umask for
3089 * implicit dirs, even if _EXTRACT_PERM was specified.
3091 mode_final = DEFAULT_DIR_MODE & ~a->user_umask;
3092 /* Mode we want on disk during the restore process. */
3094 mode |= MINIMUM_DIR_MODE;
3095 mode &= MAXIMUM_DIR_MODE;
3096 if (mkdir(path, mode) == 0) {
3097 if (mode != mode_final) {
3098 le = new_fixup(a, path);
3100 return (ARCHIVE_FATAL);
3101 le->fixup |=TODO_MODE_BASE;
3102 le->mode = mode_final;
3104 return (ARCHIVE_OK);
3108 * Without the following check, a/b/../b/c/d fails at the
3109 * second visit to 'b', so 'd' can't be created. Note that we
3110 * don't add it to the fixup list here, as it's already been
3113 if (la_stat(path, &st) == 0 && S_ISDIR(st.st_mode))
3114 return (ARCHIVE_OK);
3116 archive_set_error(&a->archive, errno, "Failed to create dir '%s'",
3118 return (ARCHIVE_FAILED);
3122 * Note: Although we can skip setting the user id if the desired user
3123 * id matches the current user, we cannot skip setting the group, as
3124 * many systems set the gid based on the containing directory. So
3125 * we have to perform a chown syscall if we want to set the SGID
3126 * bit. (The alternative is to stat() and then possibly chown(); it's
3127 * more efficient to skip the stat() and just always chown().) Note
3128 * that a successful chown() here clears the TODO_SGID_CHECK bit, which
3129 * allows set_mode to skip the stat() check for the GID.
3132 set_ownership(struct archive_write_disk *a)
3134 #if !defined(__CYGWIN__) && !defined(__linux__)
3136 * On Linux, a process may have the CAP_CHOWN capability.
3137 * On Windows there is no 'root' user with uid 0.
3138 * Elsewhere we can skip calling chown if we are not root and the desired
3139 * user id does not match the current user.
3141 if (a->user_uid != 0 && a->user_uid != a->uid) {
3142 archive_set_error(&a->archive, errno,
3143 "Can't set UID=%jd", (intmax_t)a->uid);
3144 return (ARCHIVE_WARN);
3149 /* If we have an fd, we can avoid a race. */
3150 if (a->fd >= 0 && fchown(a->fd, a->uid, a->gid) == 0) {
3151 /* We've set owner and know uid/gid are correct. */
3152 a->todo &= ~(TODO_OWNER | TODO_SGID_CHECK | TODO_SUID_CHECK);
3153 return (ARCHIVE_OK);
3157 /* We prefer lchown() but will use chown() if that's all we have. */
3158 /* Of course, if we have neither, this will always fail. */
3160 if (lchown(a->name, a->uid, a->gid) == 0) {
3161 /* We've set owner and know uid/gid are correct. */
3162 a->todo &= ~(TODO_OWNER | TODO_SGID_CHECK | TODO_SUID_CHECK);
3163 return (ARCHIVE_OK);
3166 if (!S_ISLNK(a->mode) && chown(a->name, a->uid, a->gid) == 0) {
3167 /* We've set owner and know uid/gid are correct. */
3168 a->todo &= ~(TODO_OWNER | TODO_SGID_CHECK | TODO_SUID_CHECK);
3169 return (ARCHIVE_OK);
3173 archive_set_error(&a->archive, errno,
3174 "Can't set user=%jd/group=%jd for %s",
3175 (intmax_t)a->uid, (intmax_t)a->gid, a->name);
3176 return (ARCHIVE_WARN);
3180 * Note: Returns 0 on success, non-zero on failure.
3183 set_time(int fd, int mode, const char *name,
3184 time_t atime, long atime_nsec,
3185 time_t mtime, long mtime_nsec)
3187 /* Select the best implementation for this platform. */
3188 #if defined(HAVE_UTIMENSAT) && defined(HAVE_FUTIMENS)
3190 * utimensat() and futimens() are defined in
3191 * POSIX.1-2008. They support ns resolution and setting times
3192 * on fds and symlinks.
3194 struct timespec ts[2];
3195 (void)mode; /* UNUSED */
3196 ts[0].tv_sec = atime;
3197 ts[0].tv_nsec = atime_nsec;
3198 ts[1].tv_sec = mtime;
3199 ts[1].tv_nsec = mtime_nsec;
3201 return futimens(fd, ts);
3202 return utimensat(AT_FDCWD, name, ts, AT_SYMLINK_NOFOLLOW);
3206 * The utimes()-family functions support µs-resolution and
3207 * setting times fds and symlinks. utimes() is documented as
3208 * LEGACY by POSIX, futimes() and lutimes() are not described
3211 struct timeval times[2];
3213 times[0].tv_sec = atime;
3214 times[0].tv_usec = atime_nsec / 1000;
3215 times[1].tv_sec = mtime;
3216 times[1].tv_usec = mtime_nsec / 1000;
3220 return (futimes(fd, times));
3222 (void)fd; /* UNUSED */
3225 (void)mode; /* UNUSED */
3226 return (lutimes(name, times));
3230 return (utimes(name, times));
3233 #elif defined(HAVE_UTIME)
3235 * utime() is POSIX-standard but only supports 1s resolution and
3236 * does not support fds or symlinks.
3238 struct utimbuf times;
3239 (void)fd; /* UNUSED */
3240 (void)name; /* UNUSED */
3241 (void)atime_nsec; /* UNUSED */
3242 (void)mtime_nsec; /* UNUSED */
3243 times.actime = atime;
3244 times.modtime = mtime;
3246 return (ARCHIVE_OK);
3247 return (utime(name, ×));
3251 * We don't know how to set the time on this platform.
3253 (void)fd; /* UNUSED */
3254 (void)mode; /* UNUSED */
3255 (void)name; /* UNUSED */
3256 (void)atime_nsec; /* UNUSED */
3257 (void)mtime_nsec; /* UNUSED */
3258 return (ARCHIVE_WARN);
3264 set_time_tru64(int fd, int mode, const char *name,
3265 time_t atime, long atime_nsec,
3266 time_t mtime, long mtime_nsec,
3267 time_t ctime, long ctime_nsec)
3269 struct attr_timbuf tstamp;
3270 tstamp.atime.tv_sec = atime;
3271 tstamp.mtime.tv_sec = mtime;
3272 tstamp.ctime.tv_sec = ctime;
3273 #if defined (__hpux) && defined (__ia64)
3274 tstamp.atime.tv_nsec = atime_nsec;
3275 tstamp.mtime.tv_nsec = mtime_nsec;
3276 tstamp.ctime.tv_nsec = ctime_nsec;
3278 tstamp.atime.tv_usec = atime_nsec / 1000;
3279 tstamp.mtime.tv_usec = mtime_nsec / 1000;
3280 tstamp.ctime.tv_usec = ctime_nsec / 1000;
3282 return (fcntl(fd,F_SETTIMES,&tstamp));
3284 #endif /* F_SETTIMES */
3287 set_times(struct archive_write_disk *a,
3288 int fd, int mode, const char *name,
3289 time_t atime, long atime_nanos,
3290 time_t birthtime, long birthtime_nanos,
3291 time_t mtime, long mtime_nanos,
3292 time_t cctime, long ctime_nanos)
3294 /* Note: set_time doesn't use libarchive return conventions!
3295 * It uses syscall conventions. So 0 here instead of ARCHIVE_OK. */
3300 * on Tru64 try own fcntl first which can restore even the
3301 * ctime, fall back to default code path below if it fails
3302 * or if we are not running as root
3304 if (a->user_uid == 0 &&
3305 set_time_tru64(fd, mode, name,
3306 atime, atime_nanos, mtime,
3307 mtime_nanos, cctime, ctime_nanos) == 0) {
3308 return (ARCHIVE_OK);
3311 (void)cctime; /* UNUSED */
3312 (void)ctime_nanos; /* UNUSED */
3315 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
3317 * If you have struct stat.st_birthtime, we assume BSD
3318 * birthtime semantics, in which {f,l,}utimes() updates
3319 * birthtime to earliest mtime. So we set the time twice,
3320 * first using the birthtime, then using the mtime. If
3321 * birthtime == mtime, this isn't necessary, so we skip it.
3322 * If birthtime > mtime, then this won't work, so we skip it.
3324 if (birthtime < mtime
3325 || (birthtime == mtime && birthtime_nanos < mtime_nanos))
3326 r1 = set_time(fd, mode, name,
3328 birthtime, birthtime_nanos);
3330 (void)birthtime; /* UNUSED */
3331 (void)birthtime_nanos; /* UNUSED */
3333 r2 = set_time(fd, mode, name,
3335 mtime, mtime_nanos);
3336 if (r1 != 0 || r2 != 0) {
3337 archive_set_error(&a->archive, errno,
3338 "Can't restore time");
3339 return (ARCHIVE_WARN);
3341 return (ARCHIVE_OK);
3345 set_times_from_entry(struct archive_write_disk *a)
3347 time_t atime, birthtime, mtime, cctime;
3348 long atime_nsec, birthtime_nsec, mtime_nsec, ctime_nsec;
3350 /* Suitable defaults. */
3351 atime = birthtime = mtime = cctime = a->start_time;
3352 atime_nsec = birthtime_nsec = mtime_nsec = ctime_nsec = 0;
3354 /* If no time was provided, we're done. */
3355 if (!archive_entry_atime_is_set(a->entry)
3356 #if HAVE_STRUCT_STAT_ST_BIRTHTIME
3357 && !archive_entry_birthtime_is_set(a->entry)
3359 && !archive_entry_mtime_is_set(a->entry))
3360 return (ARCHIVE_OK);
3362 if (archive_entry_atime_is_set(a->entry)) {
3363 atime = archive_entry_atime(a->entry);
3364 atime_nsec = archive_entry_atime_nsec(a->entry);
3366 if (archive_entry_birthtime_is_set(a->entry)) {
3367 birthtime = archive_entry_birthtime(a->entry);
3368 birthtime_nsec = archive_entry_birthtime_nsec(a->entry);
3370 if (archive_entry_mtime_is_set(a->entry)) {
3371 mtime = archive_entry_mtime(a->entry);
3372 mtime_nsec = archive_entry_mtime_nsec(a->entry);
3374 if (archive_entry_ctime_is_set(a->entry)) {
3375 cctime = archive_entry_ctime(a->entry);
3376 ctime_nsec = archive_entry_ctime_nsec(a->entry);
3379 return set_times(a, a->fd, a->mode, a->name,
3381 birthtime, birthtime_nsec,
3383 cctime, ctime_nsec);
3387 set_mode(struct archive_write_disk *a, int mode)
3390 mode &= 07777; /* Strip off file type bits. */
3392 if (a->todo & TODO_SGID_CHECK) {
3394 * If we don't know the GID is right, we must stat()
3395 * to verify it. We can't just check the GID of this
3396 * process, since systems sometimes set GID from
3397 * the enclosing dir or based on ACLs.
3399 if ((r = lazy_stat(a)) != ARCHIVE_OK)
3401 if (a->pst->st_gid != a->gid) {
3403 if (a->flags & ARCHIVE_EXTRACT_OWNER) {
3405 * This is only an error if you
3406 * requested owner restore. If you
3407 * didn't, we'll try to restore
3408 * sgid/suid, but won't consider it a
3409 * problem if we can't.
3411 archive_set_error(&a->archive, -1,
3412 "Can't restore SGID bit");
3416 /* While we're here, double-check the UID. */
3417 if (a->pst->st_uid != a->uid
3418 && (a->todo & TODO_SUID)) {
3420 if (a->flags & ARCHIVE_EXTRACT_OWNER) {
3421 archive_set_error(&a->archive, -1,
3422 "Can't restore SUID bit");
3426 a->todo &= ~TODO_SGID_CHECK;
3427 a->todo &= ~TODO_SUID_CHECK;
3428 } else if (a->todo & TODO_SUID_CHECK) {
3430 * If we don't know the UID is right, we can just check
3431 * the user, since all systems set the file UID from
3434 if (a->user_uid != a->uid) {
3436 if (a->flags & ARCHIVE_EXTRACT_OWNER) {
3437 archive_set_error(&a->archive, -1,
3438 "Can't make file SUID");
3442 a->todo &= ~TODO_SUID_CHECK;
3445 if (S_ISLNK(a->mode)) {
3448 * If this is a symlink, use lchmod(). If the
3449 * platform doesn't support lchmod(), just skip it. A
3450 * platform that doesn't provide a way to set
3451 * permissions on symlinks probably ignores
3452 * permissions on symlinks, so a failure here has no
3455 if (lchmod(a->name, mode) != 0) {
3459 #if ENOTSUP != EOPNOTSUPP
3463 * if lchmod is defined but the platform
3464 * doesn't support it, silently ignore
3469 archive_set_error(&a->archive, errno,
3470 "Can't set permissions to 0%o", (int)mode);
3475 } else if (!S_ISDIR(a->mode)) {
3477 * If it's not a symlink and not a dir, then use
3478 * fchmod() or chmod(), depending on whether we have
3479 * an fd. Dirs get their perms set during the
3480 * post-extract fixup, which is handled elsewhere.
3484 if (fchmod(a->fd, mode) != 0) {
3485 archive_set_error(&a->archive, errno,
3486 "Can't set permissions to 0%o", (int)mode);
3491 /* If this platform lacks fchmod(), then
3492 * we'll just use chmod(). */
3493 if (chmod(a->name, mode) != 0) {
3494 archive_set_error(&a->archive, errno,
3495 "Can't set permissions to 0%o", (int)mode);
3503 set_fflags(struct archive_write_disk *a)
3505 struct fixup_entry *le;
3506 unsigned long set, clear;
3508 mode_t mode = archive_entry_mode(a->entry);
3510 * Make 'critical_flags' hold all file flags that can't be
3511 * immediately restored. For example, on BSD systems,
3512 * SF_IMMUTABLE prevents hardlinks from being created, so
3513 * should not be set until after any hardlinks are created. To
3514 * preserve some semblance of portability, this uses #ifdef
3515 * extensively. Ugly, but it works.
3517 * Yes, Virginia, this does create a security race. It's mitigated
3518 * somewhat by the practice of creating dirs 0700 until the extract
3519 * is done, but it would be nice if we could do more than that.
3520 * People restoring critical file systems should be wary of
3521 * other programs that might try to muck with files as they're
3524 const int critical_flags = 0
3537 #if defined(FS_APPEND_FL)
3539 #elif defined(EXT2_APPEND_FL)
3542 #if defined(FS_IMMUTABLE_FL)
3544 #elif defined(EXT2_IMMUTABLE_FL)
3547 #ifdef FS_JOURNAL_DATA_FL
3548 | FS_JOURNAL_DATA_FL
3552 if (a->todo & TODO_FFLAGS) {
3553 archive_entry_fflags(a->entry, &set, &clear);
3556 * The first test encourages the compiler to eliminate
3557 * all of this if it's not necessary.
3559 if ((critical_flags != 0) && (set & critical_flags)) {
3560 le = current_fixup(a, a->name);
3562 return (ARCHIVE_FATAL);
3563 le->fixup |= TODO_FFLAGS;
3564 le->fflags_set = set;
3565 /* Store the mode if it's not already there. */
3566 if ((le->fixup & TODO_MODE) == 0)
3569 r = set_fflags_platform(a, a->fd,
3570 a->name, mode, set, clear);
3571 if (r != ARCHIVE_OK)
3575 return (ARCHIVE_OK);
3579 clear_nochange_fflags(struct archive_write_disk *a)
3581 mode_t mode = archive_entry_mode(a->entry);
3582 const int nochange_flags = 0
3595 #ifdef EXT2_APPEND_FL
3598 #ifdef EXT2_IMMUTABLE_FL
3603 return (set_fflags_platform(a, a->fd, a->name, mode, 0,
3608 #if ( defined(HAVE_LCHFLAGS) || defined(HAVE_CHFLAGS) || defined(HAVE_FCHFLAGS) ) && defined(HAVE_STRUCT_STAT_ST_FLAGS)
3610 * BSD reads flags using stat() and sets them with one of {f,l,}chflags()
3613 set_fflags_platform(struct archive_write_disk *a, int fd, const char *name,
3614 mode_t mode, unsigned long set, unsigned long clear)
3617 const int sf_mask = 0
3631 (void)mode; /* UNUSED */
3633 if (set == 0 && clear == 0)
3634 return (ARCHIVE_OK);
3637 * XXX Is the stat here really necessary? Or can I just use
3638 * the 'set' flags directly? In particular, I'm not sure
3639 * about the correct approach if we're overwriting an existing
3640 * file that already has flags on it. XXX
3642 if ((r = lazy_stat(a)) != ARCHIVE_OK)
3645 a->st.st_flags &= ~clear;
3646 a->st.st_flags |= set;
3648 /* Only super-user may change SF_* flags */
3650 if (a->user_uid != 0)
3651 a->st.st_flags &= ~sf_mask;
3653 #ifdef HAVE_FCHFLAGS
3654 /* If platform has fchflags() and we were given an fd, use it. */
3655 if (fd >= 0 && fchflags(fd, a->st.st_flags) == 0)
3656 return (ARCHIVE_OK);
3659 * If we can't use the fd to set the flags, we'll use the
3660 * pathname to set flags. We prefer lchflags() but will use
3661 * chflags() if we must.
3663 #ifdef HAVE_LCHFLAGS
3664 if (lchflags(name, a->st.st_flags) == 0)
3665 return (ARCHIVE_OK);
3666 #elif defined(HAVE_CHFLAGS)
3667 if (S_ISLNK(a->st.st_mode)) {
3668 archive_set_error(&a->archive, errno,
3669 "Can't set file flags on symlink.");
3670 return (ARCHIVE_WARN);
3672 if (chflags(name, a->st.st_flags) == 0)
3673 return (ARCHIVE_OK);
3675 archive_set_error(&a->archive, errno,
3676 "Failed to set file flags");
3677 return (ARCHIVE_WARN);
3680 #elif (defined(FS_IOC_GETFLAGS) && defined(FS_IOC_SETFLAGS) && \
3681 defined(HAVE_WORKING_FS_IOC_GETFLAGS)) || \
3682 (defined(EXT2_IOC_GETFLAGS) && defined(EXT2_IOC_SETFLAGS) && \
3683 defined(HAVE_WORKING_EXT2_IOC_GETFLAGS))
3685 * Linux uses ioctl() to read and write file flags.
3688 set_fflags_platform(struct archive_write_disk *a, int fd, const char *name,
3689 mode_t mode, unsigned long set, unsigned long clear)
3693 int newflags, oldflags;
3695 * Linux has no define for the flags that are only settable by
3696 * the root user. This code may seem a little complex, but
3697 * there seem to be some Linux systems that lack these
3698 * defines. (?) The code below degrades reasonably gracefully
3699 * if sf_mask is incomplete.
3701 const int sf_mask = 0
3702 #if defined(FS_IMMUTABLE_FL)
3704 #elif defined(EXT2_IMMUTABLE_FL)
3707 #if defined(FS_APPEND_FL)
3709 #elif defined(EXT2_APPEND_FL)
3712 #if defined(FS_JOURNAL_DATA_FL)
3713 | FS_JOURNAL_DATA_FL
3717 if (set == 0 && clear == 0)
3718 return (ARCHIVE_OK);
3719 /* Only regular files and dirs can have flags. */
3720 if (!S_ISREG(mode) && !S_ISDIR(mode))
3721 return (ARCHIVE_OK);
3723 /* If we weren't given an fd, open it ourselves. */
3725 myfd = open(name, O_RDONLY | O_NONBLOCK | O_BINARY | O_CLOEXEC);
3726 __archive_ensure_cloexec_flag(myfd);
3729 return (ARCHIVE_OK);
3732 * XXX As above, this would be way simpler if we didn't have
3733 * to read the current flags from disk. XXX
3737 /* Read the current file flags. */
3739 #ifdef FS_IOC_GETFLAGS
3747 /* Try setting the flags as given. */
3748 newflags = (oldflags & ~clear) | set;
3750 #ifdef FS_IOC_SETFLAGS
3760 /* If we couldn't set all the flags, try again with a subset. */
3761 newflags &= ~sf_mask;
3762 oldflags &= sf_mask;
3763 newflags |= oldflags;
3765 #ifdef FS_IOC_SETFLAGS
3773 /* We couldn't set the flags, so report the failure. */
3775 archive_set_error(&a->archive, errno,
3776 "Failed to set file flags");
3787 * Of course, some systems have neither BSD chflags() nor Linux' flags
3788 * support through ioctl().
3791 set_fflags_platform(struct archive_write_disk *a, int fd, const char *name,
3792 mode_t mode, unsigned long set, unsigned long clear)
3794 (void)a; /* UNUSED */
3795 (void)fd; /* UNUSED */
3796 (void)name; /* UNUSED */
3797 (void)mode; /* UNUSED */
3798 (void)set; /* UNUSED */
3799 (void)clear; /* UNUSED */
3800 return (ARCHIVE_OK);
3803 #endif /* __linux */
3805 #ifndef HAVE_COPYFILE_H
3806 /* Default is to simply drop Mac extended metadata. */
3808 set_mac_metadata(struct archive_write_disk *a, const char *pathname,
3809 const void *metadata, size_t metadata_size)
3811 (void)a; /* UNUSED */
3812 (void)pathname; /* UNUSED */
3813 (void)metadata; /* UNUSED */
3814 (void)metadata_size; /* UNUSED */
3815 return (ARCHIVE_OK);
3819 fixup_appledouble(struct archive_write_disk *a, const char *pathname)
3821 (void)a; /* UNUSED */
3822 (void)pathname; /* UNUSED */
3823 return (ARCHIVE_OK);
3828 * On Mac OS, we use copyfile() to unpack the metadata and
3829 * apply it to the target file.
3832 #if defined(HAVE_SYS_XATTR_H)
3834 copy_xattrs(struct archive_write_disk *a, int tmpfd, int dffd)
3837 char *xattr_names = NULL, *xattr_val = NULL;
3838 int ret = ARCHIVE_OK, xattr_i;
3840 xattr_size = flistxattr(tmpfd, NULL, 0, 0);
3841 if (xattr_size == -1) {
3842 archive_set_error(&a->archive, errno,
3843 "Failed to read metadata(xattr)");
3847 xattr_names = malloc(xattr_size);
3848 if (xattr_names == NULL) {
3849 archive_set_error(&a->archive, ENOMEM,
3850 "Can't allocate memory for metadata(xattr)");
3851 ret = ARCHIVE_FATAL;
3854 xattr_size = flistxattr(tmpfd, xattr_names, xattr_size, 0);
3855 if (xattr_size == -1) {
3856 archive_set_error(&a->archive, errno,
3857 "Failed to read metadata(xattr)");
3861 for (xattr_i = 0; xattr_i < xattr_size;
3862 xattr_i += strlen(xattr_names + xattr_i) + 1) {
3863 char *xattr_val_saved;
3867 s = fgetxattr(tmpfd, xattr_names + xattr_i, NULL, 0, 0, 0);
3869 archive_set_error(&a->archive, errno,
3870 "Failed to get metadata(xattr)");
3874 xattr_val_saved = xattr_val;
3875 xattr_val = realloc(xattr_val, s);
3876 if (xattr_val == NULL) {
3877 archive_set_error(&a->archive, ENOMEM,
3878 "Failed to get metadata(xattr)");
3880 free(xattr_val_saved);
3883 s = fgetxattr(tmpfd, xattr_names + xattr_i, xattr_val, s, 0, 0);
3885 archive_set_error(&a->archive, errno,
3886 "Failed to get metadata(xattr)");
3890 f = fsetxattr(dffd, xattr_names + xattr_i, xattr_val, s, 0, 0);
3892 archive_set_error(&a->archive, errno,
3893 "Failed to get metadata(xattr)");
3906 copy_acls(struct archive_write_disk *a, int tmpfd, int dffd)
3908 #ifndef HAVE_SYS_ACL_H
3911 acl_t acl, dfacl = NULL;
3912 int acl_r, ret = ARCHIVE_OK;
3914 acl = acl_get_fd(tmpfd);
3916 if (errno == ENOENT)
3917 /* There are not any ACLs. */
3919 archive_set_error(&a->archive, errno,
3920 "Failed to get metadata(acl)");
3924 dfacl = acl_dup(acl);
3925 acl_r = acl_set_fd(dffd, dfacl);
3927 archive_set_error(&a->archive, errno,
3928 "Failed to get metadata(acl)");
3942 create_tempdatafork(struct archive_write_disk *a, const char *pathname)
3944 struct archive_string tmpdatafork;
3947 archive_string_init(&tmpdatafork);
3948 archive_strcpy(&tmpdatafork, "tar.md.XXXXXX");
3949 tmpfd = mkstemp(tmpdatafork.s);
3951 archive_set_error(&a->archive, errno,
3952 "Failed to mkstemp");
3953 archive_string_free(&tmpdatafork);
3956 if (copyfile(pathname, tmpdatafork.s, 0,
3957 COPYFILE_UNPACK | COPYFILE_NOFOLLOW
3958 | COPYFILE_ACL | COPYFILE_XATTR) < 0) {
3959 archive_set_error(&a->archive, errno,
3960 "Failed to restore metadata");
3964 unlink(tmpdatafork.s);
3965 archive_string_free(&tmpdatafork);
3970 copy_metadata(struct archive_write_disk *a, const char *metadata,
3971 const char *datafork, int datafork_compressed)
3973 int ret = ARCHIVE_OK;
3975 if (datafork_compressed) {
3978 tmpfd = create_tempdatafork(a, metadata);
3980 return (ARCHIVE_WARN);
3983 * Do not open the data fork compressed by HFS+ compression
3984 * with at least a writing mode(O_RDWR or O_WRONLY). it
3985 * makes the data fork uncompressed.
3987 dffd = open(datafork, 0);
3989 archive_set_error(&a->archive, errno,
3990 "Failed to open the data fork for metadata");
3992 return (ARCHIVE_WARN);
3995 #if defined(HAVE_SYS_XATTR_H)
3996 ret = copy_xattrs(a, tmpfd, dffd);
3997 if (ret == ARCHIVE_OK)
3999 ret = copy_acls(a, tmpfd, dffd);
4003 if (copyfile(metadata, datafork, 0,
4004 COPYFILE_UNPACK | COPYFILE_NOFOLLOW
4005 | COPYFILE_ACL | COPYFILE_XATTR) < 0) {
4006 archive_set_error(&a->archive, errno,
4007 "Failed to restore metadata");
4015 set_mac_metadata(struct archive_write_disk *a, const char *pathname,
4016 const void *metadata, size_t metadata_size)
4018 struct archive_string tmp;
4021 int ret = ARCHIVE_OK;
4023 /* This would be simpler if copyfile() could just accept the
4024 * metadata as a block of memory; then we could sidestep this
4025 * silly dance of writing the data to disk just so that
4026 * copyfile() can read it back in again. */
4027 archive_string_init(&tmp);
4028 archive_strcpy(&tmp, pathname);
4029 archive_strcat(&tmp, ".XXXXXX");
4030 fd = mkstemp(tmp.s);
4033 archive_set_error(&a->archive, errno,
4034 "Failed to restore metadata");
4035 archive_string_free(&tmp);
4036 return (ARCHIVE_WARN);
4038 written = write(fd, metadata, metadata_size);
4040 if ((size_t)written != metadata_size) {
4041 archive_set_error(&a->archive, errno,
4042 "Failed to restore metadata");
4047 #if defined(UF_COMPRESSED)
4048 if ((a->todo & TODO_HFS_COMPRESSION) != 0 &&
4049 (ret = lazy_stat(a)) == ARCHIVE_OK)
4050 compressed = a->st.st_flags & UF_COMPRESSED;
4054 ret = copy_metadata(a, tmp.s, pathname, compressed);
4057 archive_string_free(&tmp);
4062 fixup_appledouble(struct archive_write_disk *a, const char *pathname)
4067 struct archive_string datafork;
4068 int fd = -1, ret = ARCHIVE_OK;
4070 archive_string_init(&datafork);
4071 /* Check if the current file name is a type of the resource
4073 p = strrchr(pathname, '/');
4078 if (p[0] != '.' || p[1] != '_')
4079 goto skip_appledouble;
4082 * Check if the data fork file exists.
4084 * TODO: Check if this write disk object has handled it.
4086 archive_strncpy(&datafork, pathname, p - pathname);
4087 archive_strcat(&datafork, p + 2);
4088 if (lstat(datafork.s, &st) == -1 ||
4089 (st.st_mode & AE_IFMT) != AE_IFREG)
4090 goto skip_appledouble;
4093 * Check if the file is in the AppleDouble form.
4095 fd = open(pathname, O_RDONLY | O_BINARY | O_CLOEXEC);
4096 __archive_ensure_cloexec_flag(fd);
4098 archive_set_error(&a->archive, errno,
4099 "Failed to open a restoring file");
4101 goto skip_appledouble;
4103 if (read(fd, buff, 8) == -1) {
4104 archive_set_error(&a->archive, errno,
4105 "Failed to read a restoring file");
4108 goto skip_appledouble;
4111 /* Check AppleDouble Magic Code. */
4112 if (archive_be32dec(buff) != 0x00051607)
4113 goto skip_appledouble;
4114 /* Check AppleDouble Version. */
4115 if (archive_be32dec(buff+4) != 0x00020000)
4116 goto skip_appledouble;
4118 ret = copy_metadata(a, pathname, datafork.s,
4119 #if defined(UF_COMPRESSED)
4120 st.st_flags & UF_COMPRESSED);
4124 if (ret == ARCHIVE_OK) {
4129 archive_string_free(&datafork);
4134 #if ARCHIVE_XATTR_LINUX || ARCHIVE_XATTR_DARWIN || ARCHIVE_XATTR_AIX
4136 * Restore extended attributes - Linux, Darwin and AIX implementations:
4137 * AIX' ea interface is syntaxwise identical to the Linux xattr interface.
4140 set_xattrs(struct archive_write_disk *a)
4142 struct archive_entry *entry = a->entry;
4143 struct archive_string errlist;
4144 int ret = ARCHIVE_OK;
4145 int i = archive_entry_xattr_reset(entry);
4148 archive_string_init(&errlist);
4156 archive_entry_xattr_next(entry, &name, &value, &size);
4160 #if ARCHIVE_XATTR_LINUX
4161 /* Linux: quietly skip POSIX.1e ACL extended attributes */
4162 if (strncmp(name, "system.", 7) == 0 &&
4163 (strcmp(name + 7, "posix_acl_access") == 0 ||
4164 strcmp(name + 7, "posix_acl_default") == 0))
4166 if (strncmp(name, "trusted.SGI_", 12) == 0 &&
4167 (strcmp(name + 12, "ACL_DEFAULT") == 0 ||
4168 strcmp(name + 12, "ACL_FILE") == 0))
4171 /* Linux: xfsroot namespace is obsolete and unsupported */
4172 if (strncmp(name, "xfsroot.", 8) == 0) {
4174 archive_strcat(&errlist, name);
4175 archive_strappend_char(&errlist, ' ');
4181 #if ARCHIVE_XATTR_LINUX
4182 e = fsetxattr(a->fd, name, value, size, 0);
4183 #elif ARCHIVE_XATTR_DARWIN
4184 e = fsetxattr(a->fd, name, value, size, 0, 0);
4185 #elif ARCHIVE_XATTR_AIX
4186 e = fsetea(a->fd, name, value, size, 0);
4189 #if ARCHIVE_XATTR_LINUX
4190 e = lsetxattr(archive_entry_pathname(entry),
4191 name, value, size, 0);
4192 #elif ARCHIVE_XATTR_DARWIN
4193 e = setxattr(archive_entry_pathname(entry),
4194 name, value, size, 0, XATTR_NOFOLLOW);
4195 #elif ARCHIVE_XATTR_AIX
4196 e = lsetea(archive_entry_pathname(entry),
4197 name, value, size, 0);
4202 archive_strcat(&errlist, name);
4203 archive_strappend_char(&errlist, ' ');
4204 if (errno != ENOTSUP && errno != ENOSYS)
4209 if (ret == ARCHIVE_WARN) {
4210 if (fail && errlist.length > 0) {
4212 errlist.s[errlist.length] = '\0';
4213 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
4214 "Cannot restore extended attributes: %s",
4217 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
4218 "Cannot restore extended "
4219 "attributes on this file system.");
4222 archive_string_free(&errlist);
4225 #elif ARCHIVE_XATTR_FREEBSD
4227 * Restore extended attributes - FreeBSD implementation
4230 set_xattrs(struct archive_write_disk *a)
4232 struct archive_entry *entry = a->entry;
4233 struct archive_string errlist;
4234 int ret = ARCHIVE_OK;
4235 int i = archive_entry_xattr_reset(entry);
4238 archive_string_init(&errlist);
4244 archive_entry_xattr_next(entry, &name, &value, &size);
4249 if (strncmp(name, "user.", 5) == 0) {
4250 /* "user." attributes go to user namespace */
4252 namespace = EXTATTR_NAMESPACE_USER;
4254 /* Other namespaces are unsupported */
4255 archive_strcat(&errlist, name);
4256 archive_strappend_char(&errlist, ' ');
4263 e = extattr_set_fd(a->fd, namespace, name,
4266 e = extattr_set_link(
4267 archive_entry_pathname(entry), namespace,
4270 if (e != (int)size) {
4271 archive_strcat(&errlist, name);
4272 archive_strappend_char(&errlist, ' ');
4274 if (errno != ENOTSUP && errno != ENOSYS)
4280 if (ret == ARCHIVE_WARN) {
4281 if (fail && errlist.length > 0) {
4283 errlist.s[errlist.length] = '\0';
4285 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
4286 "Cannot restore extended attributes: %s",
4289 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
4290 "Cannot restore extended "
4291 "attributes on this file system.");
4294 archive_string_free(&errlist);
4299 * Restore extended attributes - stub implementation for unsupported systems
4302 set_xattrs(struct archive_write_disk *a)
4304 static int warning_done = 0;
4306 /* If there aren't any extended attributes, then it's okay not
4307 * to extract them, otherwise, issue a single warning. */
4308 if (archive_entry_xattr_count(a->entry) != 0 && !warning_done) {
4310 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
4311 "Cannot restore extended attributes on this system");
4312 return (ARCHIVE_WARN);
4314 /* Warning was already emitted; suppress further warnings. */
4315 return (ARCHIVE_OK);
4320 * Test if file on disk is older than entry.
4323 older(struct stat *st, struct archive_entry *entry)
4325 /* First, test the seconds and return if we have a definite answer. */
4326 /* Definitely older. */
4327 if (to_int64_time(st->st_mtime) < to_int64_time(archive_entry_mtime(entry)))
4329 /* Definitely younger. */
4330 if (to_int64_time(st->st_mtime) > to_int64_time(archive_entry_mtime(entry)))
4332 /* If this platform supports fractional seconds, try those. */
4333 #if HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC
4334 /* Definitely older. */
4335 if (st->st_mtimespec.tv_nsec < archive_entry_mtime_nsec(entry))
4337 #elif HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
4338 /* Definitely older. */
4339 if (st->st_mtim.tv_nsec < archive_entry_mtime_nsec(entry))
4341 #elif HAVE_STRUCT_STAT_ST_MTIME_N
4343 if (st->st_mtime_n < archive_entry_mtime_nsec(entry))
4345 #elif HAVE_STRUCT_STAT_ST_UMTIME
4347 if (st->st_umtime * 1000 < archive_entry_mtime_nsec(entry))
4349 #elif HAVE_STRUCT_STAT_ST_MTIME_USEC
4351 if (st->st_mtime_usec * 1000 < archive_entry_mtime_nsec(entry))
4354 /* This system doesn't have high-res timestamps. */
4356 /* Same age or newer, so not older. */
4360 #ifndef ARCHIVE_ACL_SUPPORT
4362 archive_write_disk_set_acls(struct archive *a, int fd, const char *name,
4363 struct archive_acl *abstract_acl, __LA_MODE_T mode)
4365 (void)a; /* UNUSED */
4366 (void)fd; /* UNUSED */
4367 (void)name; /* UNUSED */
4368 (void)abstract_acl; /* UNUSED */
4369 (void)mode; /* UNUSED */
4370 return (ARCHIVE_OK);
4374 #endif /* !_WIN32 || __CYGWIN__ */