Upgrade libarchive, bsdcat(1), bsdcpio(1) and bsdtar(1). 1/2
[dragonfly.git] / contrib / libarchive / libarchive / archive_write_disk_posix.c
1 /*-
2  * Copyright (c) 2003-2010 Tim Kientzle
3  * Copyright (c) 2012 Michihiro NAKAJIMA
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
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.
15  *
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.
26  */
27
28 #include "archive_platform.h"
29 __FBSDID("$FreeBSD$");
30
31 #if !defined(_WIN32) || defined(__CYGWIN__)
32
33 #ifdef HAVE_SYS_TYPES_H
34 #include <sys/types.h>
35 #endif
36 #ifdef HAVE_SYS_ACL_H
37 #include <sys/acl.h>
38 #endif
39 #ifdef HAVE_SYS_EXTATTR_H
40 #include <sys/extattr.h>
41 #endif
42 #if HAVE_SYS_XATTR_H
43 #include <sys/xattr.h>
44 #elif HAVE_ATTR_XATTR_H
45 #include <attr/xattr.h>
46 #endif
47 #ifdef HAVE_SYS_EA_H
48 #include <sys/ea.h>
49 #endif
50 #ifdef HAVE_SYS_IOCTL_H
51 #include <sys/ioctl.h>
52 #endif
53 #ifdef HAVE_SYS_STAT_H
54 #include <sys/stat.h>
55 #endif
56 #ifdef HAVE_SYS_TIME_H
57 #include <sys/time.h>
58 #endif
59 #ifdef HAVE_SYS_UTIME_H
60 #include <sys/utime.h>
61 #endif
62 #ifdef HAVE_COPYFILE_H
63 #include <copyfile.h>
64 #endif
65 #ifdef HAVE_ERRNO_H
66 #include <errno.h>
67 #endif
68 #ifdef HAVE_FCNTL_H
69 #include <fcntl.h>
70 #endif
71 #ifdef HAVE_GRP_H
72 #include <grp.h>
73 #endif
74 #ifdef HAVE_LANGINFO_H
75 #include <langinfo.h>
76 #endif
77 #ifdef HAVE_LINUX_FS_H
78 #include <linux/fs.h>   /* for Linux file flags */
79 #endif
80 /*
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.
83  */
84 #ifdef HAVE_LINUX_EXT2_FS_H
85 #include <linux/ext2_fs.h>      /* for Linux file flags */
86 #endif
87 #if defined(HAVE_EXT2FS_EXT2_FS_H) && !defined(__CYGWIN__)
88 #include <ext2fs/ext2_fs.h>     /* Linux file flags, broken on Cygwin */
89 #endif
90 #ifdef HAVE_LIMITS_H
91 #include <limits.h>
92 #endif
93 #ifdef HAVE_PWD_H
94 #include <pwd.h>
95 #endif
96 #include <stdio.h>
97 #ifdef HAVE_STDLIB_H
98 #include <stdlib.h>
99 #endif
100 #ifdef HAVE_STRING_H
101 #include <string.h>
102 #endif
103 #ifdef HAVE_UNISTD_H
104 #include <unistd.h>
105 #endif
106 #ifdef HAVE_UTIME_H
107 #include <utime.h>
108 #endif
109 #ifdef F_GETTIMES /* Tru64 specific */
110 #include <sys/fcntl1.h>
111 #endif
112
113 /*
114  * Macro to cast st_mtime and time_t to an int64 so that 2 numbers can reliably be compared.
115  *
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
120  * to INT64_MAX.*
121  */
122 #define to_int64_time(t) \
123    ((t) < 0 ? (int64_t)(t) : (uint64_t)(t) > (uint64_t)INT64_MAX ? INT64_MAX : (int64_t)(t))
124
125 #if __APPLE__
126 #include <TargetConditionals.h>
127 #if TARGET_OS_MAC && !TARGET_OS_EMBEDDED && HAVE_QUARANTINE_H
128 #include <quarantine.h>
129 #define HAVE_QUARANTINE 1
130 #endif
131 #endif
132
133 #ifdef HAVE_ZLIB_H
134 #include <zlib.h>
135 #endif
136
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. */
142
143 #include "archive.h"
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"
150
151 #ifndef O_BINARY
152 #define O_BINARY 0
153 #endif
154 #ifndef O_CLOEXEC
155 #define O_CLOEXEC 0
156 #endif
157
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)
161 #undef O_NOFOLLOW
162 #endif
163
164 #ifndef O_NOFOLLOW
165 #define O_NOFOLLOW 0
166 #endif
167
168 #ifndef AT_FDCWD
169 #define AT_FDCWD -100
170 #endif
171
172 struct fixup_entry {
173         struct fixup_entry      *next;
174         struct archive_acl       acl;
175         mode_t                   mode;
176         int64_t                  atime;
177         int64_t                  birthtime;
178         int64_t                  mtime;
179         int64_t                  ctime;
180         unsigned long            atime_nanos;
181         unsigned long            birthtime_nanos;
182         unsigned long            mtime_nanos;
183         unsigned long            ctime_nanos;
184         unsigned long            fflags_set;
185         size_t                   mac_metadata_size;
186         void                    *mac_metadata;
187         int                      fixup; /* bitmask of what needs fixing */
188         char                    *name;
189 };
190
191 /*
192  * We use a bitmask to track which operations remain to be done for
193  * this file.  In particular, this helps us avoid unnecessary
194  * operations when it's possible to take care of one step as a
195  * side-effect of another.  For example, mkdir() can specify the mode
196  * for the newly-created object but symlink() cannot.  This means we
197  * can skip chmod() if mkdir() succeeded, but we must explicitly
198  * chmod() if we're trying to create a directory that already exists
199  * (mkdir() failed) or if we're restoring a symlink.  Similarly, we
200  * need to verify UID/GID before trying to restore SUID/SGID bits;
201  * that verification can occur explicitly through a stat() call or
202  * implicitly because of a successful chown() call.
203  */
204 #define TODO_MODE_FORCE         0x40000000
205 #define TODO_MODE_BASE          0x20000000
206 #define TODO_SUID               0x10000000
207 #define TODO_SUID_CHECK         0x08000000
208 #define TODO_SGID               0x04000000
209 #define TODO_SGID_CHECK         0x02000000
210 #define TODO_APPLEDOUBLE        0x01000000
211 #define TODO_MODE               (TODO_MODE_BASE|TODO_SUID|TODO_SGID)
212 #define TODO_TIMES              ARCHIVE_EXTRACT_TIME
213 #define TODO_OWNER              ARCHIVE_EXTRACT_OWNER
214 #define TODO_FFLAGS             ARCHIVE_EXTRACT_FFLAGS
215 #define TODO_ACLS               ARCHIVE_EXTRACT_ACL
216 #define TODO_XATTR              ARCHIVE_EXTRACT_XATTR
217 #define TODO_MAC_METADATA       ARCHIVE_EXTRACT_MAC_METADATA
218 #define TODO_HFS_COMPRESSION    ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED
219
220 struct archive_write_disk {
221         struct archive  archive;
222
223         mode_t                   user_umask;
224         struct fixup_entry      *fixup_list;
225         struct fixup_entry      *current_fixup;
226         int64_t                  user_uid;
227         int                      skip_file_set;
228         int64_t                  skip_file_dev;
229         int64_t                  skip_file_ino;
230         time_t                   start_time;
231
232         int64_t (*lookup_gid)(void *private, const char *gname, int64_t gid);
233         void  (*cleanup_gid)(void *private);
234         void                    *lookup_gid_data;
235         int64_t (*lookup_uid)(void *private, const char *uname, int64_t uid);
236         void  (*cleanup_uid)(void *private);
237         void                    *lookup_uid_data;
238
239         /*
240          * Full path of last file to satisfy symlink checks.
241          */
242         struct archive_string   path_safe;
243
244         /*
245          * Cached stat data from disk for the current entry.
246          * If this is valid, pst points to st.  Otherwise,
247          * pst is null.
248          */
249         struct stat              st;
250         struct stat             *pst;
251
252         /* Information about the object being restored right now. */
253         struct archive_entry    *entry; /* Entry being extracted. */
254         char                    *name; /* Name of entry, possibly edited. */
255         struct archive_string    _name_data; /* backing store for 'name' */
256         char                    *tmpname; /* Temporary name * */
257         struct archive_string    _tmpname_data; /* backing store for 'tmpname' */
258         /* Tasks remaining for this object. */
259         int                      todo;
260         /* Tasks deferred until end-of-archive. */
261         int                      deferred;
262         /* Options requested by the client. */
263         int                      flags;
264         /* Handle for the file we're restoring. */
265         int                      fd;
266         /* Current offset for writing data to the file. */
267         int64_t                  offset;
268         /* Last offset actually written to disk. */
269         int64_t                  fd_offset;
270         /* Total bytes actually written to files. */
271         int64_t                  total_bytes_written;
272         /* Maximum size of file, -1 if unknown. */
273         int64_t                  filesize;
274         /* Dir we were in before this restore; only for deep paths. */
275         int                      restore_pwd;
276         /* Mode we should use for this entry; affected by _PERM and umask. */
277         mode_t                   mode;
278         /* UID/GID to use in restoring this entry. */
279         int64_t                  uid;
280         int64_t                  gid;
281         /*
282          * HFS+ Compression.
283          */
284         /* Xattr "com.apple.decmpfs". */
285         uint32_t                 decmpfs_attr_size;
286         unsigned char           *decmpfs_header_p;
287         /* ResourceFork set options used for fsetxattr. */
288         int                      rsrc_xattr_options;
289         /* Xattr "com.apple.ResourceFork". */
290         unsigned char           *resource_fork;
291         size_t                   resource_fork_allocated_size;
292         unsigned int             decmpfs_block_count;
293         uint32_t                *decmpfs_block_info;
294         /* Buffer for compressed data. */
295         unsigned char           *compressed_buffer;
296         size_t                   compressed_buffer_size;
297         size_t                   compressed_buffer_remaining;
298         /* The offset of the ResourceFork where compressed data will
299          * be placed. */
300         uint32_t                 compressed_rsrc_position;
301         uint32_t                 compressed_rsrc_position_v;
302         /* Buffer for uncompressed data. */
303         char                    *uncompressed_buffer;
304         size_t                   block_remaining_bytes;
305         size_t                   file_remaining_bytes;
306 #ifdef HAVE_ZLIB_H
307         z_stream                 stream;
308         int                      stream_valid;
309         int                      decmpfs_compression_level;
310 #endif
311 };
312
313 /*
314  * Default mode for dirs created automatically (will be modified by umask).
315  * Note that POSIX specifies 0777 for implicitly-created dirs, "modified
316  * by the process' file creation mask."
317  */
318 #define DEFAULT_DIR_MODE 0777
319 /*
320  * Dir modes are restored in two steps:  During the extraction, the permissions
321  * in the archive are modified to match the following limits.  During
322  * the post-extract fixup pass, the permissions from the archive are
323  * applied.
324  */
325 #define MINIMUM_DIR_MODE 0700
326 #define MAXIMUM_DIR_MODE 0775
327
328 /*
329  * Maximum uncompressed size of a decmpfs block.
330  */
331 #define MAX_DECMPFS_BLOCK_SIZE  (64 * 1024)
332 /*
333  * HFS+ compression type.
334  */
335 #define CMP_XATTR               3/* Compressed data in xattr. */
336 #define CMP_RESOURCE_FORK       4/* Compressed data in resource fork. */
337 /*
338  * HFS+ compression resource fork.
339  */
340 #define RSRC_H_SIZE     260     /* Base size of Resource fork header. */
341 #define RSRC_F_SIZE     50      /* Size of Resource fork footer. */
342 /* Size to write compressed data to resource fork. */
343 #define COMPRESSED_W_SIZE       (64 * 1024)
344 /* decmpfs definitions. */
345 #define MAX_DECMPFS_XATTR_SIZE          3802
346 #ifndef DECMPFS_XATTR_NAME
347 #define DECMPFS_XATTR_NAME              "com.apple.decmpfs"
348 #endif
349 #define DECMPFS_MAGIC                   0x636d7066
350 #define DECMPFS_COMPRESSION_MAGIC       0
351 #define DECMPFS_COMPRESSION_TYPE        4
352 #define DECMPFS_UNCOMPRESSED_SIZE       8
353 #define DECMPFS_HEADER_SIZE             16
354
355 #define HFS_BLOCKS(s)   ((s) >> 12)
356
357
358 static int      la_opendirat(int, const char *);
359 static int      la_mktemp(struct archive_write_disk *);
360 static void     fsobj_error(int *, struct archive_string *, int, const char *,
361                     const char *);
362 static int      check_symlinks_fsobj(char *, int *, struct archive_string *,
363                     int);
364 static int      check_symlinks(struct archive_write_disk *);
365 static int      create_filesystem_object(struct archive_write_disk *);
366 static struct fixup_entry *current_fixup(struct archive_write_disk *,
367                     const char *pathname);
368 #if defined(HAVE_FCHDIR) && defined(PATH_MAX)
369 static void     edit_deep_directories(struct archive_write_disk *ad);
370 #endif
371 static int      cleanup_pathname_fsobj(char *, int *, struct archive_string *,
372                     int);
373 static int      cleanup_pathname(struct archive_write_disk *);
374 static int      create_dir(struct archive_write_disk *, char *);
375 static int      create_parent_dir(struct archive_write_disk *, char *);
376 static ssize_t  hfs_write_data_block(struct archive_write_disk *,
377                     const char *, size_t);
378 static int      fixup_appledouble(struct archive_write_disk *, const char *);
379 static int      older(struct stat *, struct archive_entry *);
380 static int      restore_entry(struct archive_write_disk *);
381 static int      set_mac_metadata(struct archive_write_disk *, const char *,
382                                  const void *, size_t);
383 static int      set_xattrs(struct archive_write_disk *);
384 static int      clear_nochange_fflags(struct archive_write_disk *);
385 static int      set_fflags(struct archive_write_disk *);
386 static int      set_fflags_platform(struct archive_write_disk *, int fd,
387                     const char *name, mode_t mode,
388                     unsigned long fflags_set, unsigned long fflags_clear);
389 static int      set_ownership(struct archive_write_disk *);
390 static int      set_mode(struct archive_write_disk *, int mode);
391 static int      set_time(int, int, const char *, time_t, long, time_t, long);
392 static int      set_times(struct archive_write_disk *, int, int, const char *,
393                     time_t, long, time_t, long, time_t, long, time_t, long);
394 static int      set_times_from_entry(struct archive_write_disk *);
395 static struct fixup_entry *sort_dir_list(struct fixup_entry *p);
396 static ssize_t  write_data_block(struct archive_write_disk *,
397                     const char *, size_t);
398
399 static struct archive_vtable *archive_write_disk_vtable(void);
400
401 static int      _archive_write_disk_close(struct archive *);
402 static int      _archive_write_disk_free(struct archive *);
403 static int      _archive_write_disk_header(struct archive *,
404                     struct archive_entry *);
405 static int64_t  _archive_write_disk_filter_bytes(struct archive *, int);
406 static int      _archive_write_disk_finish_entry(struct archive *);
407 static ssize_t  _archive_write_disk_data(struct archive *, const void *,
408                     size_t);
409 static ssize_t  _archive_write_disk_data_block(struct archive *, const void *,
410                     size_t, int64_t);
411
412 static int
413 la_mktemp(struct archive_write_disk *a)
414 {
415         int oerrno, fd;
416         mode_t mode;
417
418         archive_string_empty(&a->_tmpname_data);
419         archive_string_sprintf(&a->_tmpname_data, "%s.XXXXXX", a->name);
420         a->tmpname = a->_tmpname_data.s;
421
422         fd = __archive_mkstemp(a->tmpname);
423         if (fd == -1)
424                 return -1;
425
426         mode = a->mode & 0777 & ~a->user_umask;
427         if (fchmod(fd, mode) == -1) {
428                 oerrno = errno;
429                 close(fd);
430                 errno = oerrno;
431                 return -1;
432         }
433         return fd;
434 }
435
436 static int
437 la_opendirat(int fd, const char *path) {
438         const int flags = O_CLOEXEC
439 #if defined(O_BINARY)
440             | O_BINARY
441 #endif
442 #if defined(O_DIRECTORY)
443             | O_DIRECTORY
444 #endif
445 #if defined(O_PATH)
446             | O_PATH
447 #elif defined(O_SEARCH)
448             | O_SEARCH
449 #elif defined(__FreeBSD__) && defined(O_EXEC)
450             | O_EXEC
451 #else
452             | O_RDONLY
453 #endif
454             ;
455
456 #if !defined(HAVE_OPENAT)
457         if (fd != AT_FDCWD) {
458                 errno = ENOTSUP;
459                 return (-1);
460         } else
461                 return (open(path, flags));
462 #else
463         return (openat(fd, path, flags));
464 #endif
465 }
466
467 static int
468 lazy_stat(struct archive_write_disk *a)
469 {
470         if (a->pst != NULL) {
471                 /* Already have stat() data available. */
472                 return (ARCHIVE_OK);
473         }
474 #ifdef HAVE_FSTAT
475         if (a->fd >= 0 && fstat(a->fd, &a->st) == 0) {
476                 a->pst = &a->st;
477                 return (ARCHIVE_OK);
478         }
479 #endif
480         /*
481          * XXX At this point, symlinks should not be hit, otherwise
482          * XXX a race occurred.  Do we want to check explicitly for that?
483          */
484         if (lstat(a->name, &a->st) == 0) {
485                 a->pst = &a->st;
486                 return (ARCHIVE_OK);
487         }
488         archive_set_error(&a->archive, errno, "Couldn't stat file");
489         return (ARCHIVE_WARN);
490 }
491
492 static struct archive_vtable *
493 archive_write_disk_vtable(void)
494 {
495         static struct archive_vtable av;
496         static int inited = 0;
497
498         if (!inited) {
499                 av.archive_close = _archive_write_disk_close;
500                 av.archive_filter_bytes = _archive_write_disk_filter_bytes;
501                 av.archive_free = _archive_write_disk_free;
502                 av.archive_write_header = _archive_write_disk_header;
503                 av.archive_write_finish_entry
504                     = _archive_write_disk_finish_entry;
505                 av.archive_write_data = _archive_write_disk_data;
506                 av.archive_write_data_block = _archive_write_disk_data_block;
507                 inited = 1;
508         }
509         return (&av);
510 }
511
512 static int64_t
513 _archive_write_disk_filter_bytes(struct archive *_a, int n)
514 {
515         struct archive_write_disk *a = (struct archive_write_disk *)_a;
516         (void)n; /* UNUSED */
517         if (n == -1 || n == 0)
518                 return (a->total_bytes_written);
519         return (-1);
520 }
521
522
523 int
524 archive_write_disk_set_options(struct archive *_a, int flags)
525 {
526         struct archive_write_disk *a = (struct archive_write_disk *)_a;
527
528         a->flags = flags;
529         return (ARCHIVE_OK);
530 }
531
532
533 /*
534  * Extract this entry to disk.
535  *
536  * TODO: Validate hardlinks.  According to the standards, we're
537  * supposed to check each extracted hardlink and squawk if it refers
538  * to a file that we didn't restore.  I'm not entirely convinced this
539  * is a good idea, but more importantly: Is there any way to validate
540  * hardlinks without keeping a complete list of filenames from the
541  * entire archive?? Ugh.
542  *
543  */
544 static int
545 _archive_write_disk_header(struct archive *_a, struct archive_entry *entry)
546 {
547         struct archive_write_disk *a = (struct archive_write_disk *)_a;
548         struct fixup_entry *fe;
549         int ret, r;
550
551         archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
552             ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
553             "archive_write_disk_header");
554         archive_clear_error(&a->archive);
555         if (a->archive.state & ARCHIVE_STATE_DATA) {
556                 r = _archive_write_disk_finish_entry(&a->archive);
557                 if (r == ARCHIVE_FATAL)
558                         return (r);
559         }
560
561         /* Set up for this particular entry. */
562         a->pst = NULL;
563         a->current_fixup = NULL;
564         a->deferred = 0;
565         if (a->entry) {
566                 archive_entry_free(a->entry);
567                 a->entry = NULL;
568         }
569         a->entry = archive_entry_clone(entry);
570         a->fd = -1;
571         a->fd_offset = 0;
572         a->offset = 0;
573         a->restore_pwd = -1;
574         a->uid = a->user_uid;
575         a->mode = archive_entry_mode(a->entry);
576         if (archive_entry_size_is_set(a->entry))
577                 a->filesize = archive_entry_size(a->entry);
578         else
579                 a->filesize = -1;
580         archive_strcpy(&(a->_name_data), archive_entry_pathname(a->entry));
581         a->name = a->_name_data.s;
582         archive_clear_error(&a->archive);
583
584         /*
585          * Clean up the requested path.  This is necessary for correct
586          * dir restores; the dir restore logic otherwise gets messed
587          * up by nonsense like "dir/.".
588          */
589         ret = cleanup_pathname(a);
590         if (ret != ARCHIVE_OK)
591                 return (ret);
592
593         /*
594          * Query the umask so we get predictable mode settings.
595          * This gets done on every call to _write_header in case the
596          * user edits their umask during the extraction for some
597          * reason.
598          */
599         umask(a->user_umask = umask(0));
600
601         /* Figure out what we need to do for this entry. */
602         a->todo = TODO_MODE_BASE;
603         if (a->flags & ARCHIVE_EXTRACT_PERM) {
604                 a->todo |= TODO_MODE_FORCE; /* Be pushy about permissions. */
605                 /*
606                  * SGID requires an extra "check" step because we
607                  * cannot easily predict the GID that the system will
608                  * assign.  (Different systems assign GIDs to files
609                  * based on a variety of criteria, including process
610                  * credentials and the gid of the enclosing
611                  * directory.)  We can only restore the SGID bit if
612                  * the file has the right GID, and we only know the
613                  * GID if we either set it (see set_ownership) or if
614                  * we've actually called stat() on the file after it
615                  * was restored.  Since there are several places at
616                  * which we might verify the GID, we need a TODO bit
617                  * to keep track.
618                  */
619                 if (a->mode & S_ISGID)
620                         a->todo |= TODO_SGID | TODO_SGID_CHECK;
621                 /*
622                  * Verifying the SUID is simpler, but can still be
623                  * done in multiple ways, hence the separate "check" bit.
624                  */
625                 if (a->mode & S_ISUID)
626                         a->todo |= TODO_SUID | TODO_SUID_CHECK;
627         } else {
628                 /*
629                  * User didn't request full permissions, so don't
630                  * restore SUID, SGID bits and obey umask.
631                  */
632                 a->mode &= ~S_ISUID;
633                 a->mode &= ~S_ISGID;
634                 a->mode &= ~S_ISVTX;
635                 a->mode &= ~a->user_umask;
636         }
637         if (a->flags & ARCHIVE_EXTRACT_OWNER)
638                 a->todo |= TODO_OWNER;
639         if (a->flags & ARCHIVE_EXTRACT_TIME)
640                 a->todo |= TODO_TIMES;
641         if (a->flags & ARCHIVE_EXTRACT_ACL) {
642 #if ARCHIVE_ACL_DARWIN
643                 /*
644                  * On MacOS, platform ACLs get stored in mac_metadata, too.
645                  * If we intend to extract mac_metadata and it is present
646                  * we skip extracting libarchive NFSv4 ACLs.
647                  */
648                 size_t metadata_size;
649
650                 if ((a->flags & ARCHIVE_EXTRACT_MAC_METADATA) == 0 ||
651                     archive_entry_mac_metadata(a->entry,
652                     &metadata_size) == NULL || metadata_size == 0)
653 #endif
654 #if ARCHIVE_ACL_LIBRICHACL
655                 /*
656                  * RichACLs are stored in an extended attribute.
657                  * If we intend to extract extended attributes and have this
658                  * attribute we skip extracting libarchive NFSv4 ACLs.
659                  */
660                 short extract_acls = 1;
661                 if (a->flags & ARCHIVE_EXTRACT_XATTR && (
662                     archive_entry_acl_types(a->entry) &
663                     ARCHIVE_ENTRY_ACL_TYPE_NFS4)) {
664                         const char *attr_name;
665                         const void *attr_value;
666                         size_t attr_size;
667                         int i = archive_entry_xattr_reset(a->entry);
668                         while (i--) {
669                                 archive_entry_xattr_next(a->entry, &attr_name,
670                                     &attr_value, &attr_size);
671                                 if (attr_name != NULL && attr_value != NULL &&
672                                     attr_size > 0 && strcmp(attr_name,
673                                     "trusted.richacl") == 0) {
674                                         extract_acls = 0;
675                                         break;
676                                 }
677                         }
678                 }
679                 if (extract_acls)
680 #endif
681 #if ARCHIVE_ACL_DARWIN || ARCHIVE_ACL_LIBRICHACL
682                 {
683 #endif
684                 if (archive_entry_filetype(a->entry) == AE_IFDIR)
685                         a->deferred |= TODO_ACLS;
686                 else
687                         a->todo |= TODO_ACLS;
688 #if ARCHIVE_ACL_DARWIN || ARCHIVE_ACL_LIBRICHACL
689                 }
690 #endif
691         }
692         if (a->flags & ARCHIVE_EXTRACT_MAC_METADATA) {
693                 if (archive_entry_filetype(a->entry) == AE_IFDIR)
694                         a->deferred |= TODO_MAC_METADATA;
695                 else
696                         a->todo |= TODO_MAC_METADATA;
697         }
698 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
699         if ((a->flags & ARCHIVE_EXTRACT_NO_HFS_COMPRESSION) == 0) {
700                 unsigned long set, clear;
701                 archive_entry_fflags(a->entry, &set, &clear);
702                 if ((set & ~clear) & UF_COMPRESSED) {
703                         a->todo |= TODO_HFS_COMPRESSION;
704                         a->decmpfs_block_count = (unsigned)-1;
705                 }
706         }
707         if ((a->flags & ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED) != 0 &&
708             (a->mode & AE_IFMT) == AE_IFREG && a->filesize > 0) {
709                 a->todo |= TODO_HFS_COMPRESSION;
710                 a->decmpfs_block_count = (unsigned)-1;
711         }
712         {
713                 const char *p;
714
715                 /* Check if the current file name is a type of the
716                  * resource fork file. */
717                 p = strrchr(a->name, '/');
718                 if (p == NULL)
719                         p = a->name;
720                 else
721                         p++;
722                 if (p[0] == '.' && p[1] == '_') {
723                         /* Do not compress "._XXX" files. */
724                         a->todo &= ~TODO_HFS_COMPRESSION;
725                         if (a->filesize > 0)
726                                 a->todo |= TODO_APPLEDOUBLE;
727                 }
728         }
729 #endif
730
731         if (a->flags & ARCHIVE_EXTRACT_XATTR) {
732 #if ARCHIVE_XATTR_DARWIN
733                 /*
734                  * On MacOS, extended attributes get stored in mac_metadata,
735                  * too. If we intend to extract mac_metadata and it is present
736                  * we skip extracting extended attributes.
737                  */
738                 size_t metadata_size;
739
740                 if ((a->flags & ARCHIVE_EXTRACT_MAC_METADATA) == 0 ||
741                     archive_entry_mac_metadata(a->entry,
742                     &metadata_size) == NULL || metadata_size == 0)
743 #endif
744                 a->todo |= TODO_XATTR;
745         }
746         if (a->flags & ARCHIVE_EXTRACT_FFLAGS)
747                 a->todo |= TODO_FFLAGS;
748         if (a->flags & ARCHIVE_EXTRACT_SECURE_SYMLINKS) {
749                 ret = check_symlinks(a);
750                 if (ret != ARCHIVE_OK)
751                         return (ret);
752         }
753 #if defined(HAVE_FCHDIR) && defined(PATH_MAX)
754         /* If path exceeds PATH_MAX, shorten the path. */
755         edit_deep_directories(a);
756 #endif
757
758         ret = restore_entry(a);
759
760 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
761         /*
762          * Check if the filesystem the file is restoring on supports
763          * HFS+ Compression. If not, cancel HFS+ Compression.
764          */
765         if (a->todo | TODO_HFS_COMPRESSION) {
766                 /*
767                  * NOTE: UF_COMPRESSED is ignored even if the filesystem
768                  * supports HFS+ Compression because the file should
769                  * have at least an extended attribute "com.apple.decmpfs"
770                  * before the flag is set to indicate that the file have
771                  * been compressed. If the filesystem does not support
772                  * HFS+ Compression the system call will fail.
773                  */
774                 if (a->fd < 0 || fchflags(a->fd, UF_COMPRESSED) != 0)
775                         a->todo &= ~TODO_HFS_COMPRESSION;
776         }
777 #endif
778
779         /*
780          * TODO: There are rumours that some extended attributes must
781          * be restored before file data is written.  If this is true,
782          * then we either need to write all extended attributes both
783          * before and after restoring the data, or find some rule for
784          * determining which must go first and which last.  Due to the
785          * many ways people are using xattrs, this may prove to be an
786          * intractable problem.
787          */
788
789 #ifdef HAVE_FCHDIR
790         /* If we changed directory above, restore it here. */
791         if (a->restore_pwd >= 0) {
792                 r = fchdir(a->restore_pwd);
793                 if (r != 0) {
794                         archive_set_error(&a->archive, errno,
795                             "chdir() failure");
796                         ret = ARCHIVE_FATAL;
797                 }
798                 close(a->restore_pwd);
799                 a->restore_pwd = -1;
800         }
801 #endif
802
803         /*
804          * Fixup uses the unedited pathname from archive_entry_pathname(),
805          * because it is relative to the base dir and the edited path
806          * might be relative to some intermediate dir as a result of the
807          * deep restore logic.
808          */
809         if (a->deferred & TODO_MODE) {
810                 fe = current_fixup(a, archive_entry_pathname(entry));
811                 if (fe == NULL)
812                         return (ARCHIVE_FATAL);
813                 fe->fixup |= TODO_MODE_BASE;
814                 fe->mode = a->mode;
815         }
816
817         if ((a->deferred & TODO_TIMES)
818                 && (archive_entry_mtime_is_set(entry)
819                     || archive_entry_atime_is_set(entry))) {
820                 fe = current_fixup(a, archive_entry_pathname(entry));
821                 if (fe == NULL)
822                         return (ARCHIVE_FATAL);
823                 fe->mode = a->mode;
824                 fe->fixup |= TODO_TIMES;
825                 if (archive_entry_atime_is_set(entry)) {
826                         fe->atime = archive_entry_atime(entry);
827                         fe->atime_nanos = archive_entry_atime_nsec(entry);
828                 } else {
829                         /* If atime is unset, use start time. */
830                         fe->atime = a->start_time;
831                         fe->atime_nanos = 0;
832                 }
833                 if (archive_entry_mtime_is_set(entry)) {
834                         fe->mtime = archive_entry_mtime(entry);
835                         fe->mtime_nanos = archive_entry_mtime_nsec(entry);
836                 } else {
837                         /* If mtime is unset, use start time. */
838                         fe->mtime = a->start_time;
839                         fe->mtime_nanos = 0;
840                 }
841                 if (archive_entry_birthtime_is_set(entry)) {
842                         fe->birthtime = archive_entry_birthtime(entry);
843                         fe->birthtime_nanos = archive_entry_birthtime_nsec(
844                             entry);
845                 } else {
846                         /* If birthtime is unset, use mtime. */
847                         fe->birthtime = fe->mtime;
848                         fe->birthtime_nanos = fe->mtime_nanos;
849                 }
850         }
851
852         if (a->deferred & TODO_ACLS) {
853                 fe = current_fixup(a, archive_entry_pathname(entry));
854                 if (fe == NULL)
855                         return (ARCHIVE_FATAL);
856                 fe->fixup |= TODO_ACLS;
857                 archive_acl_copy(&fe->acl, archive_entry_acl(entry));
858         }
859
860         if (a->deferred & TODO_MAC_METADATA) {
861                 const void *metadata;
862                 size_t metadata_size;
863                 metadata = archive_entry_mac_metadata(a->entry, &metadata_size);
864                 if (metadata != NULL && metadata_size > 0) {
865                         fe = current_fixup(a, archive_entry_pathname(entry));
866                         if (fe == NULL)
867                                 return (ARCHIVE_FATAL);
868                         fe->mac_metadata = malloc(metadata_size);
869                         if (fe->mac_metadata != NULL) {
870                                 memcpy(fe->mac_metadata, metadata,
871                                     metadata_size);
872                                 fe->mac_metadata_size = metadata_size;
873                                 fe->fixup |= TODO_MAC_METADATA;
874                         }
875                 }
876         }
877
878         if (a->deferred & TODO_FFLAGS) {
879                 fe = current_fixup(a, archive_entry_pathname(entry));
880                 if (fe == NULL)
881                         return (ARCHIVE_FATAL);
882                 fe->fixup |= TODO_FFLAGS;
883                 /* TODO: Complete this.. defer fflags from below. */
884         }
885
886         /* We've created the object and are ready to pour data into it. */
887         if (ret >= ARCHIVE_WARN)
888                 a->archive.state = ARCHIVE_STATE_DATA;
889         /*
890          * If it's not open, tell our client not to try writing.
891          * In particular, dirs, links, etc, don't get written to.
892          */
893         if (a->fd < 0) {
894                 archive_entry_set_size(entry, 0);
895                 a->filesize = 0;
896         }
897
898         return (ret);
899 }
900
901 int
902 archive_write_disk_set_skip_file(struct archive *_a, la_int64_t d, la_int64_t i)
903 {
904         struct archive_write_disk *a = (struct archive_write_disk *)_a;
905         archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
906             ARCHIVE_STATE_ANY, "archive_write_disk_set_skip_file");
907         a->skip_file_set = 1;
908         a->skip_file_dev = d;
909         a->skip_file_ino = i;
910         return (ARCHIVE_OK);
911 }
912
913 static ssize_t
914 write_data_block(struct archive_write_disk *a, const char *buff, size_t size)
915 {
916         uint64_t start_size = size;
917         ssize_t bytes_written = 0;
918         ssize_t block_size = 0, bytes_to_write;
919
920         if (size == 0)
921                 return (ARCHIVE_OK);
922
923         if (a->filesize == 0 || a->fd < 0) {
924                 archive_set_error(&a->archive, 0,
925                     "Attempt to write to an empty file");
926                 return (ARCHIVE_WARN);
927         }
928
929         if (a->flags & ARCHIVE_EXTRACT_SPARSE) {
930 #if HAVE_STRUCT_STAT_ST_BLKSIZE
931                 int r;
932                 if ((r = lazy_stat(a)) != ARCHIVE_OK)
933                         return (r);
934                 block_size = a->pst->st_blksize;
935 #else
936                 /* XXX TODO XXX Is there a more appropriate choice here ? */
937                 /* This needn't match the filesystem allocation size. */
938                 block_size = 16*1024;
939 #endif
940         }
941
942         /* If this write would run beyond the file size, truncate it. */
943         if (a->filesize >= 0 && (int64_t)(a->offset + size) > a->filesize)
944                 start_size = size = (size_t)(a->filesize - a->offset);
945
946         /* Write the data. */
947         while (size > 0) {
948                 if (block_size == 0) {
949                         bytes_to_write = size;
950                 } else {
951                         /* We're sparsifying the file. */
952                         const char *p, *end;
953                         int64_t block_end;
954
955                         /* Skip leading zero bytes. */
956                         for (p = buff, end = buff + size; p < end; ++p) {
957                                 if (*p != '\0')
958                                         break;
959                         }
960                         a->offset += p - buff;
961                         size -= p - buff;
962                         buff = p;
963                         if (size == 0)
964                                 break;
965
966                         /* Calculate next block boundary after offset. */
967                         block_end
968                             = (a->offset / block_size + 1) * block_size;
969
970                         /* If the adjusted write would cross block boundary,
971                          * truncate it to the block boundary. */
972                         bytes_to_write = size;
973                         if (a->offset + bytes_to_write > block_end)
974                                 bytes_to_write = block_end - a->offset;
975                 }
976                 /* Seek if necessary to the specified offset. */
977                 if (a->offset != a->fd_offset) {
978                         if (lseek(a->fd, a->offset, SEEK_SET) < 0) {
979                                 archive_set_error(&a->archive, errno,
980                                     "Seek failed");
981                                 return (ARCHIVE_FATAL);
982                         }
983                         a->fd_offset = a->offset;
984                 }
985                 bytes_written = write(a->fd, buff, bytes_to_write);
986                 if (bytes_written < 0) {
987                         archive_set_error(&a->archive, errno, "Write failed");
988                         return (ARCHIVE_WARN);
989                 }
990                 buff += bytes_written;
991                 size -= bytes_written;
992                 a->total_bytes_written += bytes_written;
993                 a->offset += bytes_written;
994                 a->fd_offset = a->offset;
995         }
996         return (start_size - size);
997 }
998
999 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_SYS_XATTR_H)\
1000         && defined(HAVE_ZLIB_H)
1001
1002 /*
1003  * Set UF_COMPRESSED file flag.
1004  * This have to be called after hfs_write_decmpfs() because if the
1005  * file does not have "com.apple.decmpfs" xattr the flag is ignored.
1006  */
1007 static int
1008 hfs_set_compressed_fflag(struct archive_write_disk *a)
1009 {
1010         int r;
1011
1012         if ((r = lazy_stat(a)) != ARCHIVE_OK)
1013                 return (r);
1014
1015         a->st.st_flags |= UF_COMPRESSED;
1016         if (fchflags(a->fd, a->st.st_flags) != 0) {
1017                 archive_set_error(&a->archive, errno,
1018                     "Failed to set UF_COMPRESSED file flag");
1019                 return (ARCHIVE_WARN);
1020         }
1021         return (ARCHIVE_OK);
1022 }
1023
1024 /*
1025  * HFS+ Compression decmpfs
1026  *
1027  *     +------------------------------+ +0
1028  *     |      Magic(LE 4 bytes)       |
1029  *     +------------------------------+
1030  *     |      Type(LE 4 bytes)        |
1031  *     +------------------------------+
1032  *     | Uncompressed size(LE 8 bytes)|
1033  *     +------------------------------+ +16
1034  *     |                              |
1035  *     |       Compressed data        |
1036  *     |  (Placed only if Type == 3)  |
1037  *     |                              |
1038  *     +------------------------------+  +3802 = MAX_DECMPFS_XATTR_SIZE
1039  *
1040  *  Type is 3: decmpfs has compressed data.
1041  *  Type is 4: Resource Fork has compressed data.
1042  */
1043 /*
1044  * Write "com.apple.decmpfs"
1045  */
1046 static int
1047 hfs_write_decmpfs(struct archive_write_disk *a)
1048 {
1049         int r;
1050         uint32_t compression_type;
1051
1052         r = fsetxattr(a->fd, DECMPFS_XATTR_NAME, a->decmpfs_header_p,
1053             a->decmpfs_attr_size, 0, 0);
1054         if (r < 0) {
1055                 archive_set_error(&a->archive, errno,
1056                     "Cannot restore xattr:%s", DECMPFS_XATTR_NAME);
1057                 compression_type = archive_le32dec(
1058                     &a->decmpfs_header_p[DECMPFS_COMPRESSION_TYPE]);
1059                 if (compression_type == CMP_RESOURCE_FORK)
1060                         fremovexattr(a->fd, XATTR_RESOURCEFORK_NAME,
1061                             XATTR_SHOWCOMPRESSION);
1062                 return (ARCHIVE_WARN);
1063         }
1064         return (ARCHIVE_OK);
1065 }
1066
1067 /*
1068  * HFS+ Compression Resource Fork
1069  *
1070  *     +-----------------------------+
1071  *     |     Header(260 bytes)       |
1072  *     +-----------------------------+
1073  *     |   Block count(LE 4 bytes)   |
1074  *     +-----------------------------+  --+
1075  * +-- |     Offset (LE 4 bytes)     |    |
1076  * |   | [distance from Block count] |    | Block 0
1077  * |   +-----------------------------+    |
1078  * |   | Compressed size(LE 4 bytes) |    |
1079  * |   +-----------------------------+  --+
1080  * |   |                             |
1081  * |   |      ..................     |
1082  * |   |                             |
1083  * |   +-----------------------------+  --+
1084  * |   |     Offset (LE 4 bytes)     |    |
1085  * |   +-----------------------------+    | Block (Block count -1)
1086  * |   | Compressed size(LE 4 bytes) |    |
1087  * +-> +-----------------------------+  --+
1088  *     |   Compressed data(n bytes)  |  Block 0
1089  *     +-----------------------------+
1090  *     |                             |
1091  *     |      ..................     |
1092  *     |                             |
1093  *     +-----------------------------+
1094  *     |   Compressed data(n bytes)  |  Block (Block count -1)
1095  *     +-----------------------------+
1096  *     |      Footer(50 bytes)       |
1097  *     +-----------------------------+
1098  *
1099  */
1100 /*
1101  * Write the header of "com.apple.ResourceFork"
1102  */
1103 static int
1104 hfs_write_resource_fork(struct archive_write_disk *a, unsigned char *buff,
1105     size_t bytes, uint32_t position)
1106 {
1107         int ret;
1108
1109         ret = fsetxattr(a->fd, XATTR_RESOURCEFORK_NAME, buff, bytes,
1110             position, a->rsrc_xattr_options);
1111         if (ret < 0) {
1112                 archive_set_error(&a->archive, errno,
1113                     "Cannot restore xattr: %s at %u pos %u bytes",
1114                     XATTR_RESOURCEFORK_NAME,
1115                     (unsigned)position,
1116                     (unsigned)bytes);
1117                 return (ARCHIVE_WARN);
1118         }
1119         a->rsrc_xattr_options &= ~XATTR_CREATE;
1120         return (ARCHIVE_OK);
1121 }
1122
1123 static int
1124 hfs_write_compressed_data(struct archive_write_disk *a, size_t bytes_compressed)
1125 {
1126         int ret;
1127
1128         ret = hfs_write_resource_fork(a, a->compressed_buffer,
1129             bytes_compressed, a->compressed_rsrc_position);
1130         if (ret == ARCHIVE_OK)
1131                 a->compressed_rsrc_position += bytes_compressed;
1132         return (ret);
1133 }
1134
1135 static int
1136 hfs_write_resource_fork_header(struct archive_write_disk *a)
1137 {
1138         unsigned char *buff;
1139         uint32_t rsrc_bytes;
1140         uint32_t rsrc_header_bytes;
1141
1142         /*
1143          * Write resource fork header + block info.
1144          */
1145         buff = a->resource_fork;
1146         rsrc_bytes = a->compressed_rsrc_position - RSRC_F_SIZE;
1147         rsrc_header_bytes =
1148                 RSRC_H_SIZE +           /* Header base size. */
1149                 4 +                     /* Block count. */
1150                 (a->decmpfs_block_count * 8);/* Block info */
1151         archive_be32enc(buff, 0x100);
1152         archive_be32enc(buff + 4, rsrc_bytes);
1153         archive_be32enc(buff + 8, rsrc_bytes - 256);
1154         archive_be32enc(buff + 12, 0x32);
1155         memset(buff + 16, 0, 240);
1156         archive_be32enc(buff + 256, rsrc_bytes - 260);
1157         return hfs_write_resource_fork(a, buff, rsrc_header_bytes, 0);
1158 }
1159
1160 static size_t
1161 hfs_set_resource_fork_footer(unsigned char *buff, size_t buff_size)
1162 {
1163         static const char rsrc_footer[RSRC_F_SIZE] = {
1164                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1165                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1166                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1167                 0x00, 0x1c, 0x00, 0x32, 0x00, 0x00, 'c',  'm',
1168                 'p', 'f',   0x00, 0x00, 0x00, 0x0a, 0x00, 0x01,
1169                 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1170                 0x00, 0x00
1171         };
1172         if (buff_size < sizeof(rsrc_footer))
1173                 return (0);
1174         memcpy(buff, rsrc_footer, sizeof(rsrc_footer));
1175         return (sizeof(rsrc_footer));
1176 }
1177
1178 static int
1179 hfs_reset_compressor(struct archive_write_disk *a)
1180 {
1181         int ret;
1182
1183         if (a->stream_valid)
1184                 ret = deflateReset(&a->stream);
1185         else
1186                 ret = deflateInit(&a->stream, a->decmpfs_compression_level);
1187
1188         if (ret != Z_OK) {
1189                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1190                     "Failed to initialize compressor");
1191                 return (ARCHIVE_FATAL);
1192         } else
1193                 a->stream_valid = 1;
1194
1195         return (ARCHIVE_OK);
1196 }
1197
1198 static int
1199 hfs_decompress(struct archive_write_disk *a)
1200 {
1201         uint32_t *block_info;
1202         unsigned int block_count;
1203         uint32_t data_pos, data_size;
1204         ssize_t r;
1205         ssize_t bytes_written, bytes_to_write;
1206         unsigned char *b;
1207
1208         block_info = (uint32_t *)(a->resource_fork + RSRC_H_SIZE);
1209         block_count = archive_le32dec(block_info++);
1210         while (block_count--) {
1211                 data_pos = RSRC_H_SIZE + archive_le32dec(block_info++);
1212                 data_size = archive_le32dec(block_info++);
1213                 r = fgetxattr(a->fd, XATTR_RESOURCEFORK_NAME,
1214                     a->compressed_buffer, data_size, data_pos, 0);
1215                 if (r != data_size)  {
1216                         archive_set_error(&a->archive,
1217                             (r < 0)?errno:ARCHIVE_ERRNO_MISC,
1218                             "Failed to read resource fork");
1219                         return (ARCHIVE_WARN);
1220                 }
1221                 if (a->compressed_buffer[0] == 0xff) {
1222                         bytes_to_write = data_size -1;
1223                         b = a->compressed_buffer + 1;
1224                 } else {
1225                         uLong dest_len = MAX_DECMPFS_BLOCK_SIZE;
1226                         int zr;
1227
1228                         zr = uncompress((Bytef *)a->uncompressed_buffer,
1229                             &dest_len, a->compressed_buffer, data_size);
1230                         if (zr != Z_OK) {
1231                                 archive_set_error(&a->archive,
1232                                     ARCHIVE_ERRNO_MISC,
1233                                     "Failed to decompress resource fork");
1234                                 return (ARCHIVE_WARN);
1235                         }
1236                         bytes_to_write = dest_len;
1237                         b = (unsigned char *)a->uncompressed_buffer;
1238                 }
1239                 do {
1240                         bytes_written = write(a->fd, b, bytes_to_write);
1241                         if (bytes_written < 0) {
1242                                 archive_set_error(&a->archive, errno,
1243                                     "Write failed");
1244                                 return (ARCHIVE_WARN);
1245                         }
1246                         bytes_to_write -= bytes_written;
1247                         b += bytes_written;
1248                 } while (bytes_to_write > 0);
1249         }
1250         r = fremovexattr(a->fd, XATTR_RESOURCEFORK_NAME, 0);
1251         if (r == -1)  {
1252                 archive_set_error(&a->archive, errno,
1253                     "Failed to remove resource fork");
1254                 return (ARCHIVE_WARN);
1255         }
1256         return (ARCHIVE_OK);
1257 }
1258
1259 static int
1260 hfs_drive_compressor(struct archive_write_disk *a, const char *buff,
1261     size_t size)
1262 {
1263         unsigned char *buffer_compressed;
1264         size_t bytes_compressed;
1265         size_t bytes_used;
1266         int ret;
1267
1268         ret = hfs_reset_compressor(a);
1269         if (ret != ARCHIVE_OK)
1270                 return (ret);
1271
1272         if (a->compressed_buffer == NULL) {
1273                 size_t block_size;
1274
1275                 block_size = COMPRESSED_W_SIZE + RSRC_F_SIZE +
1276                     + compressBound(MAX_DECMPFS_BLOCK_SIZE);
1277                 a->compressed_buffer = malloc(block_size);
1278                 if (a->compressed_buffer == NULL) {
1279                         archive_set_error(&a->archive, ENOMEM,
1280                             "Can't allocate memory for Resource Fork");
1281                         return (ARCHIVE_FATAL);
1282                 }
1283                 a->compressed_buffer_size = block_size;
1284                 a->compressed_buffer_remaining = block_size;
1285         }
1286
1287         buffer_compressed = a->compressed_buffer +
1288             a->compressed_buffer_size - a->compressed_buffer_remaining;
1289         a->stream.next_in = (Bytef *)(uintptr_t)(const void *)buff;
1290         a->stream.avail_in = size;
1291         a->stream.next_out = buffer_compressed;
1292         a->stream.avail_out = a->compressed_buffer_remaining;
1293         do {
1294                 ret = deflate(&a->stream, Z_FINISH);
1295                 switch (ret) {
1296                 case Z_OK:
1297                 case Z_STREAM_END:
1298                         break;
1299                 default:
1300                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1301                             "Failed to compress data");
1302                         return (ARCHIVE_FAILED);
1303                 }
1304         } while (ret == Z_OK);
1305         bytes_compressed = a->compressed_buffer_remaining - a->stream.avail_out;
1306
1307         /*
1308          * If the compressed size is larger than the original size,
1309          * throw away compressed data, use uncompressed data instead.
1310          */
1311         if (bytes_compressed > size) {
1312                 buffer_compressed[0] = 0xFF;/* uncompressed marker. */
1313                 memcpy(buffer_compressed + 1, buff, size);
1314                 bytes_compressed = size + 1;
1315         }
1316         a->compressed_buffer_remaining -= bytes_compressed;
1317
1318         /*
1319          * If the compressed size is smaller than MAX_DECMPFS_XATTR_SIZE
1320          * and the block count in the file is only one, store compressed
1321          * data to decmpfs xattr instead of the resource fork.
1322          */
1323         if (a->decmpfs_block_count == 1 &&
1324             (a->decmpfs_attr_size + bytes_compressed)
1325               <= MAX_DECMPFS_XATTR_SIZE) {
1326                 archive_le32enc(&a->decmpfs_header_p[DECMPFS_COMPRESSION_TYPE],
1327                     CMP_XATTR);
1328                 memcpy(a->decmpfs_header_p + DECMPFS_HEADER_SIZE,
1329                     buffer_compressed, bytes_compressed);
1330                 a->decmpfs_attr_size += bytes_compressed;
1331                 a->compressed_buffer_remaining = a->compressed_buffer_size;
1332                 /*
1333                  * Finish HFS+ Compression.
1334                  * - Write the decmpfs xattr.
1335                  * - Set the UF_COMPRESSED file flag.
1336                  */
1337                 ret = hfs_write_decmpfs(a);
1338                 if (ret == ARCHIVE_OK)
1339                         ret = hfs_set_compressed_fflag(a);
1340                 return (ret);
1341         }
1342
1343         /* Update block info. */
1344         archive_le32enc(a->decmpfs_block_info++,
1345             a->compressed_rsrc_position_v - RSRC_H_SIZE);
1346         archive_le32enc(a->decmpfs_block_info++, bytes_compressed);
1347         a->compressed_rsrc_position_v += bytes_compressed;
1348
1349         /*
1350          * Write the compressed data to the resource fork.
1351          */
1352         bytes_used = a->compressed_buffer_size - a->compressed_buffer_remaining;
1353         while (bytes_used >= COMPRESSED_W_SIZE) {
1354                 ret = hfs_write_compressed_data(a, COMPRESSED_W_SIZE);
1355                 if (ret != ARCHIVE_OK)
1356                         return (ret);
1357                 bytes_used -= COMPRESSED_W_SIZE;
1358                 if (bytes_used > COMPRESSED_W_SIZE)
1359                         memmove(a->compressed_buffer,
1360                             a->compressed_buffer + COMPRESSED_W_SIZE,
1361                             bytes_used);
1362                 else
1363                         memcpy(a->compressed_buffer,
1364                             a->compressed_buffer + COMPRESSED_W_SIZE,
1365                             bytes_used);
1366         }
1367         a->compressed_buffer_remaining = a->compressed_buffer_size - bytes_used;
1368
1369         /*
1370          * If the current block is the last block, write the remaining
1371          * compressed data and the resource fork footer.
1372          */
1373         if (a->file_remaining_bytes == 0) {
1374                 size_t rsrc_size;
1375                 int64_t bk;
1376
1377                 /* Append the resource footer. */
1378                 rsrc_size = hfs_set_resource_fork_footer(
1379                     a->compressed_buffer + bytes_used,
1380                     a->compressed_buffer_remaining);
1381                 ret = hfs_write_compressed_data(a, bytes_used + rsrc_size);
1382                 a->compressed_buffer_remaining = a->compressed_buffer_size;
1383
1384                 /* If the compressed size is not enough smaller than
1385                  * the uncompressed size. cancel HFS+ compression.
1386                  * TODO: study a behavior of ditto utility and improve
1387                  * the condition to fall back into no HFS+ compression. */
1388                 bk = HFS_BLOCKS(a->compressed_rsrc_position);
1389                 bk += bk >> 7;
1390                 if (bk > HFS_BLOCKS(a->filesize))
1391                         return hfs_decompress(a);
1392                 /*
1393                  * Write the resourcefork header.
1394                  */
1395                 if (ret == ARCHIVE_OK)
1396                         ret = hfs_write_resource_fork_header(a);
1397                 /*
1398                  * Finish HFS+ Compression.
1399                  * - Write the decmpfs xattr.
1400                  * - Set the UF_COMPRESSED file flag.
1401                  */
1402                 if (ret == ARCHIVE_OK)
1403                         ret = hfs_write_decmpfs(a);
1404                 if (ret == ARCHIVE_OK)
1405                         ret = hfs_set_compressed_fflag(a);
1406         }
1407         return (ret);
1408 }
1409
1410 static ssize_t
1411 hfs_write_decmpfs_block(struct archive_write_disk *a, const char *buff,
1412     size_t size)
1413 {
1414         const char *buffer_to_write;
1415         size_t bytes_to_write;
1416         int ret;
1417
1418         if (a->decmpfs_block_count == (unsigned)-1) {
1419                 void *new_block;
1420                 size_t new_size;
1421                 unsigned int block_count;
1422
1423                 if (a->decmpfs_header_p == NULL) {
1424                         new_block = malloc(MAX_DECMPFS_XATTR_SIZE
1425                             + sizeof(uint32_t));
1426                         if (new_block == NULL) {
1427                                 archive_set_error(&a->archive, ENOMEM,
1428                                     "Can't allocate memory for decmpfs");
1429                                 return (ARCHIVE_FATAL);
1430                         }
1431                         a->decmpfs_header_p = new_block;
1432                 }
1433                 a->decmpfs_attr_size = DECMPFS_HEADER_SIZE;
1434                 archive_le32enc(&a->decmpfs_header_p[DECMPFS_COMPRESSION_MAGIC],
1435                     DECMPFS_MAGIC);
1436                 archive_le32enc(&a->decmpfs_header_p[DECMPFS_COMPRESSION_TYPE],
1437                     CMP_RESOURCE_FORK);
1438                 archive_le64enc(&a->decmpfs_header_p[DECMPFS_UNCOMPRESSED_SIZE],
1439                     a->filesize);
1440
1441                 /* Calculate a block count of the file. */
1442                 block_count =
1443                     (a->filesize + MAX_DECMPFS_BLOCK_SIZE -1) /
1444                         MAX_DECMPFS_BLOCK_SIZE;
1445                 /*
1446                  * Allocate buffer for resource fork.
1447                  * Set up related pointers;
1448                  */
1449                 new_size =
1450                     RSRC_H_SIZE + /* header */
1451                     4 + /* Block count */
1452                     (block_count * sizeof(uint32_t) * 2) +
1453                     RSRC_F_SIZE; /* footer */
1454                 if (new_size > a->resource_fork_allocated_size) {
1455                         new_block = realloc(a->resource_fork, new_size);
1456                         if (new_block == NULL) {
1457                                 archive_set_error(&a->archive, ENOMEM,
1458                                     "Can't allocate memory for ResourceFork");
1459                                 return (ARCHIVE_FATAL);
1460                         }
1461                         a->resource_fork_allocated_size = new_size;
1462                         a->resource_fork = new_block;
1463                 }
1464
1465                 /* Allocate uncompressed buffer */
1466                 if (a->uncompressed_buffer == NULL) {
1467                         new_block = malloc(MAX_DECMPFS_BLOCK_SIZE);
1468                         if (new_block == NULL) {
1469                                 archive_set_error(&a->archive, ENOMEM,
1470                                     "Can't allocate memory for decmpfs");
1471                                 return (ARCHIVE_FATAL);
1472                         }
1473                         a->uncompressed_buffer = new_block;
1474                 }
1475                 a->block_remaining_bytes = MAX_DECMPFS_BLOCK_SIZE;
1476                 a->file_remaining_bytes = a->filesize;
1477                 a->compressed_buffer_remaining = a->compressed_buffer_size;
1478
1479                 /*
1480                  * Set up a resource fork.
1481                  */
1482                 a->rsrc_xattr_options = XATTR_CREATE;
1483                 /* Get the position where we are going to set a bunch
1484                  * of block info. */
1485                 a->decmpfs_block_info =
1486                     (uint32_t *)(a->resource_fork + RSRC_H_SIZE);
1487                 /* Set the block count to the resource fork. */
1488                 archive_le32enc(a->decmpfs_block_info++, block_count);
1489                 /* Get the position where we are going to set compressed
1490                  * data. */
1491                 a->compressed_rsrc_position =
1492                     RSRC_H_SIZE + 4 + (block_count * 8);
1493                 a->compressed_rsrc_position_v = a->compressed_rsrc_position;
1494                 a->decmpfs_block_count = block_count;
1495         }
1496
1497         /* Ignore redundant bytes. */
1498         if (a->file_remaining_bytes == 0)
1499                 return ((ssize_t)size);
1500
1501         /* Do not overrun a block size. */
1502         if (size > a->block_remaining_bytes)
1503                 bytes_to_write = a->block_remaining_bytes;
1504         else
1505                 bytes_to_write = size;
1506         /* Do not overrun the file size. */
1507         if (bytes_to_write > a->file_remaining_bytes)
1508                 bytes_to_write = a->file_remaining_bytes;
1509
1510         /* For efficiency, if a copy length is full of the uncompressed
1511          * buffer size, do not copy writing data to it. */
1512         if (bytes_to_write == MAX_DECMPFS_BLOCK_SIZE)
1513                 buffer_to_write = buff;
1514         else {
1515                 memcpy(a->uncompressed_buffer +
1516                     MAX_DECMPFS_BLOCK_SIZE - a->block_remaining_bytes,
1517                     buff, bytes_to_write);
1518                 buffer_to_write = a->uncompressed_buffer;
1519         }
1520         a->block_remaining_bytes -= bytes_to_write;
1521         a->file_remaining_bytes -= bytes_to_write;
1522
1523         if (a->block_remaining_bytes == 0 || a->file_remaining_bytes == 0) {
1524                 ret = hfs_drive_compressor(a, buffer_to_write,
1525                     MAX_DECMPFS_BLOCK_SIZE - a->block_remaining_bytes);
1526                 if (ret < 0)
1527                         return (ret);
1528                 a->block_remaining_bytes = MAX_DECMPFS_BLOCK_SIZE;
1529         }
1530         /* Ignore redundant bytes. */
1531         if (a->file_remaining_bytes == 0)
1532                 return ((ssize_t)size);
1533         return (bytes_to_write);
1534 }
1535
1536 static ssize_t
1537 hfs_write_data_block(struct archive_write_disk *a, const char *buff,
1538     size_t size)
1539 {
1540         uint64_t start_size = size;
1541         ssize_t bytes_written = 0;
1542         ssize_t bytes_to_write;
1543
1544         if (size == 0)
1545                 return (ARCHIVE_OK);
1546
1547         if (a->filesize == 0 || a->fd < 0) {
1548                 archive_set_error(&a->archive, 0,
1549                     "Attempt to write to an empty file");
1550                 return (ARCHIVE_WARN);
1551         }
1552
1553         /* If this write would run beyond the file size, truncate it. */
1554         if (a->filesize >= 0 && (int64_t)(a->offset + size) > a->filesize)
1555                 start_size = size = (size_t)(a->filesize - a->offset);
1556
1557         /* Write the data. */
1558         while (size > 0) {
1559                 bytes_to_write = size;
1560                 /* Seek if necessary to the specified offset. */
1561                 if (a->offset < a->fd_offset) {
1562                         /* Can't support backward move. */
1563                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1564                             "Seek failed");
1565                         return (ARCHIVE_FATAL);
1566                 } else if (a->offset > a->fd_offset) {
1567                         int64_t skip = a->offset - a->fd_offset;
1568                         char nullblock[1024];
1569
1570                         memset(nullblock, 0, sizeof(nullblock));
1571                         while (skip > 0) {
1572                                 if (skip > (int64_t)sizeof(nullblock))
1573                                         bytes_written = hfs_write_decmpfs_block(
1574                                             a, nullblock, sizeof(nullblock));
1575                                 else
1576                                         bytes_written = hfs_write_decmpfs_block(
1577                                             a, nullblock, skip);
1578                                 if (bytes_written < 0) {
1579                                         archive_set_error(&a->archive, errno,
1580                                             "Write failed");
1581                                         return (ARCHIVE_WARN);
1582                                 }
1583                                 skip -= bytes_written;
1584                         }
1585
1586                         a->fd_offset = a->offset;
1587                 }
1588                 bytes_written =
1589                     hfs_write_decmpfs_block(a, buff, bytes_to_write);
1590                 if (bytes_written < 0)
1591                         return (bytes_written);
1592                 buff += bytes_written;
1593                 size -= bytes_written;
1594                 a->total_bytes_written += bytes_written;
1595                 a->offset += bytes_written;
1596                 a->fd_offset = a->offset;
1597         }
1598         return (start_size - size);
1599 }
1600 #else
1601 static ssize_t
1602 hfs_write_data_block(struct archive_write_disk *a, const char *buff,
1603     size_t size)
1604 {
1605         return (write_data_block(a, buff, size));
1606 }
1607 #endif
1608
1609 static ssize_t
1610 _archive_write_disk_data_block(struct archive *_a,
1611     const void *buff, size_t size, int64_t offset)
1612 {
1613         struct archive_write_disk *a = (struct archive_write_disk *)_a;
1614         ssize_t r;
1615
1616         archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1617             ARCHIVE_STATE_DATA, "archive_write_data_block");
1618
1619         a->offset = offset;
1620         if (a->todo & TODO_HFS_COMPRESSION)
1621                 r = hfs_write_data_block(a, buff, size);
1622         else
1623                 r = write_data_block(a, buff, size);
1624         if (r < ARCHIVE_OK)
1625                 return (r);
1626         if ((size_t)r < size) {
1627                 archive_set_error(&a->archive, 0,
1628                     "Too much data: Truncating file at %ju bytes",
1629                     (uintmax_t)a->filesize);
1630                 return (ARCHIVE_WARN);
1631         }
1632 #if ARCHIVE_VERSION_NUMBER < 3999000
1633         return (ARCHIVE_OK);
1634 #else
1635         return (size);
1636 #endif
1637 }
1638
1639 static ssize_t
1640 _archive_write_disk_data(struct archive *_a, const void *buff, size_t size)
1641 {
1642         struct archive_write_disk *a = (struct archive_write_disk *)_a;
1643
1644         archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1645             ARCHIVE_STATE_DATA, "archive_write_data");
1646
1647         if (a->todo & TODO_HFS_COMPRESSION)
1648                 return (hfs_write_data_block(a, buff, size));
1649         return (write_data_block(a, buff, size));
1650 }
1651
1652 static int
1653 _archive_write_disk_finish_entry(struct archive *_a)
1654 {
1655         struct archive_write_disk *a = (struct archive_write_disk *)_a;
1656         int ret = ARCHIVE_OK;
1657
1658         archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1659             ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
1660             "archive_write_finish_entry");
1661         if (a->archive.state & ARCHIVE_STATE_HEADER)
1662                 return (ARCHIVE_OK);
1663         archive_clear_error(&a->archive);
1664
1665         /* Pad or truncate file to the right size. */
1666         if (a->fd < 0) {
1667                 /* There's no file. */
1668         } else if (a->filesize < 0) {
1669                 /* File size is unknown, so we can't set the size. */
1670         } else if (a->fd_offset == a->filesize) {
1671                 /* Last write ended at exactly the filesize; we're done. */
1672                 /* Hopefully, this is the common case. */
1673 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
1674         } else if (a->todo & TODO_HFS_COMPRESSION) {
1675                 char null_d[1024];
1676                 ssize_t r;
1677
1678                 if (a->file_remaining_bytes)
1679                         memset(null_d, 0, sizeof(null_d));
1680                 while (a->file_remaining_bytes) {
1681                         if (a->file_remaining_bytes > sizeof(null_d))
1682                                 r = hfs_write_data_block(
1683                                     a, null_d, sizeof(null_d));
1684                         else
1685                                 r = hfs_write_data_block(
1686                                     a, null_d, a->file_remaining_bytes);
1687                         if (r < 0)
1688                                 return ((int)r);
1689                 }
1690 #endif
1691         } else {
1692 #if HAVE_FTRUNCATE
1693                 if (ftruncate(a->fd, a->filesize) == -1 &&
1694                     a->filesize == 0) {
1695                         archive_set_error(&a->archive, errno,
1696                             "File size could not be restored");
1697                         return (ARCHIVE_FAILED);
1698                 }
1699 #endif
1700                 /*
1701                  * Not all platforms implement the XSI option to
1702                  * extend files via ftruncate.  Stat() the file again
1703                  * to see what happened.
1704                  */
1705                 a->pst = NULL;
1706                 if ((ret = lazy_stat(a)) != ARCHIVE_OK)
1707                         return (ret);
1708                 /* We can use lseek()/write() to extend the file if
1709                  * ftruncate didn't work or isn't available. */
1710                 if (a->st.st_size < a->filesize) {
1711                         const char nul = '\0';
1712                         if (lseek(a->fd, a->filesize - 1, SEEK_SET) < 0) {
1713                                 archive_set_error(&a->archive, errno,
1714                                     "Seek failed");
1715                                 return (ARCHIVE_FATAL);
1716                         }
1717                         if (write(a->fd, &nul, 1) < 0) {
1718                                 archive_set_error(&a->archive, errno,
1719                                     "Write to restore size failed");
1720                                 return (ARCHIVE_FATAL);
1721                         }
1722                         a->pst = NULL;
1723                 }
1724         }
1725
1726         /* Restore metadata. */
1727
1728         /*
1729          * This is specific to Mac OS X.
1730          * If the current file is an AppleDouble file, it should be
1731          * linked with the data fork file and remove it.
1732          */
1733         if (a->todo & TODO_APPLEDOUBLE) {
1734                 int r2 = fixup_appledouble(a, a->name);
1735                 if (r2 == ARCHIVE_EOF) {
1736                         /* The current file has been successfully linked
1737                          * with the data fork file and removed. So there
1738                          * is nothing to do on the current file.  */
1739                         goto finish_metadata;
1740                 }
1741                 if (r2 < ret) ret = r2;
1742         }
1743
1744         /*
1745          * Look up the "real" UID only if we're going to need it.
1746          * TODO: the TODO_SGID condition can be dropped here, can't it?
1747          */
1748         if (a->todo & (TODO_OWNER | TODO_SUID | TODO_SGID)) {
1749                 a->uid = archive_write_disk_uid(&a->archive,
1750                     archive_entry_uname(a->entry),
1751                     archive_entry_uid(a->entry));
1752         }
1753         /* Look up the "real" GID only if we're going to need it. */
1754         /* TODO: the TODO_SUID condition can be dropped here, can't it? */
1755         if (a->todo & (TODO_OWNER | TODO_SGID | TODO_SUID)) {
1756                 a->gid = archive_write_disk_gid(&a->archive,
1757                     archive_entry_gname(a->entry),
1758                     archive_entry_gid(a->entry));
1759          }
1760
1761         /*
1762          * Restore ownership before set_mode tries to restore suid/sgid
1763          * bits.  If we set the owner, we know what it is and can skip
1764          * a stat() call to examine the ownership of the file on disk.
1765          */
1766         if (a->todo & TODO_OWNER) {
1767                 int r2 = set_ownership(a);
1768                 if (r2 < ret) ret = r2;
1769         }
1770
1771         /*
1772          * HYPOTHESIS:
1773          * If we're not root, we won't be setting any security
1774          * attributes that may be wiped by the set_mode() routine
1775          * below.  We also can't set xattr on non-owner-writable files,
1776          * which may be the state after set_mode(). Perform
1777          * set_xattrs() first based on these constraints.
1778          */
1779         if (a->user_uid != 0 &&
1780             (a->todo & TODO_XATTR)) {
1781                 int r2 = set_xattrs(a);
1782                 if (r2 < ret) ret = r2;
1783         }
1784
1785         /*
1786          * set_mode must precede ACLs on systems such as Solaris and
1787          * FreeBSD where setting the mode implicitly clears extended ACLs
1788          */
1789         if (a->todo & TODO_MODE) {
1790                 int r2 = set_mode(a, a->mode);
1791                 if (r2 < ret) ret = r2;
1792         }
1793
1794         /*
1795          * Security-related extended attributes (such as
1796          * security.capability on Linux) have to be restored last,
1797          * since they're implicitly removed by other file changes.
1798          * We do this last only when root.
1799          */
1800         if (a->user_uid == 0 &&
1801             (a->todo & TODO_XATTR)) {
1802                 int r2 = set_xattrs(a);
1803                 if (r2 < ret) ret = r2;
1804         }
1805
1806         /*
1807          * Some flags prevent file modification; they must be restored after
1808          * file contents are written.
1809          */
1810         if (a->todo & TODO_FFLAGS) {
1811                 int r2 = set_fflags(a);
1812                 if (r2 < ret) ret = r2;
1813         }
1814
1815         /*
1816          * Time must follow most other metadata;
1817          * otherwise atime will get changed.
1818          */
1819         if (a->todo & TODO_TIMES) {
1820                 int r2 = set_times_from_entry(a);
1821                 if (r2 < ret) ret = r2;
1822         }
1823
1824         /*
1825          * Mac extended metadata includes ACLs.
1826          */
1827         if (a->todo & TODO_MAC_METADATA) {
1828                 const void *metadata;
1829                 size_t metadata_size;
1830                 metadata = archive_entry_mac_metadata(a->entry, &metadata_size);
1831                 if (metadata != NULL && metadata_size > 0) {
1832                         int r2 = set_mac_metadata(a, archive_entry_pathname(
1833                             a->entry), metadata, metadata_size);
1834                         if (r2 < ret) ret = r2;
1835                 }
1836         }
1837
1838         /*
1839          * ACLs must be restored after timestamps because there are
1840          * ACLs that prevent attribute changes (including time).
1841          */
1842         if (a->todo & TODO_ACLS) {
1843                 int r2;
1844                 r2 = archive_write_disk_set_acls(&a->archive, a->fd,
1845                     archive_entry_pathname(a->entry),
1846                     archive_entry_acl(a->entry),
1847                     archive_entry_mode(a->entry));
1848                 if (r2 < ret) ret = r2;
1849         }
1850
1851 finish_metadata:
1852         /* If there's an fd, we can close it now. */
1853         if (a->fd >= 0) {
1854                 close(a->fd);
1855                 a->fd = -1;
1856                 if (a->tmpname) {
1857                         if (rename(a->tmpname, a->name) == -1) {
1858                                 archive_set_error(&a->archive, errno,
1859                                     "Failed to rename temporary file");
1860                                 ret = ARCHIVE_FAILED;
1861                                 unlink(a->tmpname);
1862                         }
1863                         a->tmpname = NULL;
1864                 }
1865         }
1866         /* If there's an entry, we can release it now. */
1867         archive_entry_free(a->entry);
1868         a->entry = NULL;
1869         a->archive.state = ARCHIVE_STATE_HEADER;
1870         return (ret);
1871 }
1872
1873 int
1874 archive_write_disk_set_group_lookup(struct archive *_a,
1875     void *private_data,
1876     la_int64_t (*lookup_gid)(void *private, const char *gname, la_int64_t gid),
1877     void (*cleanup_gid)(void *private))
1878 {
1879         struct archive_write_disk *a = (struct archive_write_disk *)_a;
1880         archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1881             ARCHIVE_STATE_ANY, "archive_write_disk_set_group_lookup");
1882
1883         if (a->cleanup_gid != NULL && a->lookup_gid_data != NULL)
1884                 (a->cleanup_gid)(a->lookup_gid_data);
1885
1886         a->lookup_gid = lookup_gid;
1887         a->cleanup_gid = cleanup_gid;
1888         a->lookup_gid_data = private_data;
1889         return (ARCHIVE_OK);
1890 }
1891
1892 int
1893 archive_write_disk_set_user_lookup(struct archive *_a,
1894     void *private_data,
1895     int64_t (*lookup_uid)(void *private, const char *uname, int64_t uid),
1896     void (*cleanup_uid)(void *private))
1897 {
1898         struct archive_write_disk *a = (struct archive_write_disk *)_a;
1899         archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1900             ARCHIVE_STATE_ANY, "archive_write_disk_set_user_lookup");
1901
1902         if (a->cleanup_uid != NULL && a->lookup_uid_data != NULL)
1903                 (a->cleanup_uid)(a->lookup_uid_data);
1904
1905         a->lookup_uid = lookup_uid;
1906         a->cleanup_uid = cleanup_uid;
1907         a->lookup_uid_data = private_data;
1908         return (ARCHIVE_OK);
1909 }
1910
1911 int64_t
1912 archive_write_disk_gid(struct archive *_a, const char *name, la_int64_t id)
1913 {
1914        struct archive_write_disk *a = (struct archive_write_disk *)_a;
1915        archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1916            ARCHIVE_STATE_ANY, "archive_write_disk_gid");
1917        if (a->lookup_gid)
1918                return (a->lookup_gid)(a->lookup_gid_data, name, id);
1919        return (id);
1920 }
1921  
1922 int64_t
1923 archive_write_disk_uid(struct archive *_a, const char *name, la_int64_t id)
1924 {
1925         struct archive_write_disk *a = (struct archive_write_disk *)_a;
1926         archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1927             ARCHIVE_STATE_ANY, "archive_write_disk_uid");
1928         if (a->lookup_uid)
1929                 return (a->lookup_uid)(a->lookup_uid_data, name, id);
1930         return (id);
1931 }
1932
1933 /*
1934  * Create a new archive_write_disk object and initialize it with global state.
1935  */
1936 struct archive *
1937 archive_write_disk_new(void)
1938 {
1939         struct archive_write_disk *a;
1940
1941         a = (struct archive_write_disk *)calloc(1, sizeof(*a));
1942         if (a == NULL)
1943                 return (NULL);
1944         a->archive.magic = ARCHIVE_WRITE_DISK_MAGIC;
1945         /* We're ready to write a header immediately. */
1946         a->archive.state = ARCHIVE_STATE_HEADER;
1947         a->archive.vtable = archive_write_disk_vtable();
1948         a->start_time = time(NULL);
1949         /* Query and restore the umask. */
1950         umask(a->user_umask = umask(0));
1951 #ifdef HAVE_GETEUID
1952         a->user_uid = geteuid();
1953 #endif /* HAVE_GETEUID */
1954         if (archive_string_ensure(&a->path_safe, 512) == NULL) {
1955                 free(a);
1956                 return (NULL);
1957         }
1958 #ifdef HAVE_ZLIB_H
1959         a->decmpfs_compression_level = 5;
1960 #endif
1961         return (&a->archive);
1962 }
1963
1964
1965 /*
1966  * If pathname is longer than PATH_MAX, chdir to a suitable
1967  * intermediate dir and edit the path down to a shorter suffix.  Note
1968  * that this routine never returns an error; if the chdir() attempt
1969  * fails for any reason, we just go ahead with the long pathname.  The
1970  * object creation is likely to fail, but any error will get handled
1971  * at that time.
1972  */
1973 #if defined(HAVE_FCHDIR) && defined(PATH_MAX)
1974 static void
1975 edit_deep_directories(struct archive_write_disk *a)
1976 {
1977         int ret;
1978         char *tail = a->name;
1979
1980         /* If path is short, avoid the open() below. */
1981         if (strlen(tail) < PATH_MAX)
1982                 return;
1983
1984         /* Try to record our starting dir. */
1985         a->restore_pwd = la_opendirat(AT_FDCWD, ".");
1986         __archive_ensure_cloexec_flag(a->restore_pwd);
1987         if (a->restore_pwd < 0)
1988                 return;
1989
1990         /* As long as the path is too long... */
1991         while (strlen(tail) >= PATH_MAX) {
1992                 /* Locate a dir prefix shorter than PATH_MAX. */
1993                 tail += PATH_MAX - 8;
1994                 while (tail > a->name && *tail != '/')
1995                         tail--;
1996                 /* Exit if we find a too-long path component. */
1997                 if (tail <= a->name)
1998                         return;
1999                 /* Create the intermediate dir and chdir to it. */
2000                 *tail = '\0'; /* Terminate dir portion */
2001                 ret = create_dir(a, a->name);
2002                 if (ret == ARCHIVE_OK && chdir(a->name) != 0)
2003                         ret = ARCHIVE_FAILED;
2004                 *tail = '/'; /* Restore the / we removed. */
2005                 if (ret != ARCHIVE_OK)
2006                         return;
2007                 tail++;
2008                 /* The chdir() succeeded; we've now shortened the path. */
2009                 a->name = tail;
2010         }
2011         return;
2012 }
2013 #endif
2014
2015 /*
2016  * The main restore function.
2017  */
2018 static int
2019 restore_entry(struct archive_write_disk *a)
2020 {
2021         int ret = ARCHIVE_OK, en;
2022
2023         if (a->flags & ARCHIVE_EXTRACT_UNLINK && !S_ISDIR(a->mode)) {
2024                 /*
2025                  * TODO: Fix this.  Apparently, there are platforms
2026                  * that still allow root to hose the entire filesystem
2027                  * by unlinking a dir.  The S_ISDIR() test above
2028                  * prevents us from using unlink() here if the new
2029                  * object is a dir, but that doesn't mean the old
2030                  * object isn't a dir.
2031                  */
2032                 if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS)
2033                         (void)clear_nochange_fflags(a);
2034                 if (unlink(a->name) == 0) {
2035                         /* We removed it, reset cached stat. */
2036                         a->pst = NULL;
2037                 } else if (errno == ENOENT) {
2038                         /* File didn't exist, that's just as good. */
2039                 } else if (rmdir(a->name) == 0) {
2040                         /* It was a dir, but now it's gone. */
2041                         a->pst = NULL;
2042                 } else {
2043                         /* We tried, but couldn't get rid of it. */
2044                         archive_set_error(&a->archive, errno,
2045                             "Could not unlink");
2046                         return(ARCHIVE_FAILED);
2047                 }
2048         }
2049
2050         /* Try creating it first; if this fails, we'll try to recover. */
2051         en = create_filesystem_object(a);
2052
2053         if ((en == ENOTDIR || en == ENOENT)
2054             && !(a->flags & ARCHIVE_EXTRACT_NO_AUTODIR)) {
2055                 /* If the parent dir doesn't exist, try creating it. */
2056                 create_parent_dir(a, a->name);
2057                 /* Now try to create the object again. */
2058                 en = create_filesystem_object(a);
2059         }
2060
2061         if ((en == ENOENT) && (archive_entry_hardlink(a->entry) != NULL)) {
2062                 archive_set_error(&a->archive, en,
2063                     "Hard-link target '%s' does not exist.",
2064                     archive_entry_hardlink(a->entry));
2065                 return (ARCHIVE_FAILED);
2066         }
2067
2068         if ((en == EISDIR || en == EEXIST)
2069             && (a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) {
2070                 /* If we're not overwriting, we're done. */
2071                 if (S_ISDIR(a->mode)) {
2072                         /* Don't overwrite any settings on existing directories. */
2073                         a->todo = 0;
2074                 }
2075                 archive_entry_unset_size(a->entry);
2076                 return (ARCHIVE_OK);
2077         }
2078
2079         /*
2080          * Some platforms return EISDIR if you call
2081          * open(O_WRONLY | O_EXCL | O_CREAT) on a directory, some
2082          * return EEXIST.  POSIX is ambiguous, requiring EISDIR
2083          * for open(O_WRONLY) on a dir and EEXIST for open(O_EXCL | O_CREAT)
2084          * on an existing item.
2085          */
2086         if (en == EISDIR) {
2087                 /* A dir is in the way of a non-dir, rmdir it. */
2088                 if (rmdir(a->name) != 0) {
2089                         archive_set_error(&a->archive, errno,
2090                             "Can't remove already-existing dir");
2091                         return (ARCHIVE_FAILED);
2092                 }
2093                 a->pst = NULL;
2094                 /* Try again. */
2095                 en = create_filesystem_object(a);
2096         } else if (en == EEXIST) {
2097                 /*
2098                  * We know something is in the way, but we don't know what;
2099                  * we need to find out before we go any further.
2100                  */
2101                 int r = 0;
2102                 /*
2103                  * The SECURE_SYMLINKS logic has already removed a
2104                  * symlink to a dir if the client wants that.  So
2105                  * follow the symlink if we're creating a dir.
2106                  */
2107                 if (S_ISDIR(a->mode))
2108                         r = la_stat(a->name, &a->st);
2109                 /*
2110                  * If it's not a dir (or it's a broken symlink),
2111                  * then don't follow it.
2112                  */
2113                 if (r != 0 || !S_ISDIR(a->mode))
2114                         r = lstat(a->name, &a->st);
2115                 if (r != 0) {
2116                         archive_set_error(&a->archive, errno,
2117                             "Can't stat existing object");
2118                         return (ARCHIVE_FAILED);
2119                 }
2120
2121                 /*
2122                  * NO_OVERWRITE_NEWER doesn't apply to directories.
2123                  */
2124                 if ((a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER)
2125                     &&  !S_ISDIR(a->st.st_mode)) {
2126                         if (!older(&(a->st), a->entry)) {
2127                                 archive_entry_unset_size(a->entry);
2128                                 return (ARCHIVE_OK);
2129                         }
2130                 }
2131
2132                 /* If it's our archive, we're done. */
2133                 if (a->skip_file_set &&
2134                     a->st.st_dev == (dev_t)a->skip_file_dev &&
2135                     a->st.st_ino == (ino_t)a->skip_file_ino) {
2136                         archive_set_error(&a->archive, 0,
2137                             "Refusing to overwrite archive");
2138                         return (ARCHIVE_FAILED);
2139                 }
2140
2141                 if (!S_ISDIR(a->st.st_mode)) {
2142                         if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS)
2143                                 (void)clear_nochange_fflags(a);
2144
2145                         if ((a->flags & ARCHIVE_EXTRACT_SAFE_WRITES) &&
2146                             S_ISREG(a->st.st_mode)) {
2147                                 /* Use a temporary file to extract */
2148                                 if ((a->fd = la_mktemp(a)) == -1) {
2149                                         archive_set_error(&a->archive, errno,
2150                                             "Can't create temporary file");
2151                                         return ARCHIVE_FAILED;
2152                                 }
2153                                 a->pst = NULL;
2154                                 en = 0;
2155                         } else {
2156                                 /* A non-dir is in the way, unlink it. */
2157                                 if (unlink(a->name) != 0) {
2158                                         archive_set_error(&a->archive, errno,
2159                                             "Can't unlink already-existing "
2160                                             "object");
2161                                         return (ARCHIVE_FAILED);
2162                                 }
2163                                 a->pst = NULL;
2164                                 /* Try again. */
2165                                 en = create_filesystem_object(a);
2166                         }
2167                 } else if (!S_ISDIR(a->mode)) {
2168                         /* A dir is in the way of a non-dir, rmdir it. */
2169                         if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS)
2170                                 (void)clear_nochange_fflags(a);
2171                         if (rmdir(a->name) != 0) {
2172                                 archive_set_error(&a->archive, errno,
2173                                     "Can't replace existing directory with non-directory");
2174                                 return (ARCHIVE_FAILED);
2175                         }
2176                         /* Try again. */
2177                         en = create_filesystem_object(a);
2178                 } else {
2179                         /*
2180                          * There's a dir in the way of a dir.  Don't
2181                          * waste time with rmdir()/mkdir(), just fix
2182                          * up the permissions on the existing dir.
2183                          * Note that we don't change perms on existing
2184                          * dirs unless _EXTRACT_PERM is specified.
2185                          */
2186                         if ((a->mode != a->st.st_mode)
2187                             && (a->todo & TODO_MODE_FORCE))
2188                                 a->deferred |= (a->todo & TODO_MODE);
2189                         /* Ownership doesn't need deferred fixup. */
2190                         en = 0; /* Forget the EEXIST. */
2191                 }
2192         }
2193
2194         if (en) {
2195                 /* Everything failed; give up here. */
2196                 if ((&a->archive)->error == NULL)
2197                         archive_set_error(&a->archive, en, "Can't create '%s'",
2198                             a->name);
2199                 return (ARCHIVE_FAILED);
2200         }
2201
2202         a->pst = NULL; /* Cached stat data no longer valid. */
2203         return (ret);
2204 }
2205
2206 /*
2207  * Returns 0 if creation succeeds, or else returns errno value from
2208  * the failed system call.   Note:  This function should only ever perform
2209  * a single system call.
2210  */
2211 static int
2212 create_filesystem_object(struct archive_write_disk *a)
2213 {
2214         /* Create the entry. */
2215         const char *linkname;
2216         mode_t final_mode, mode;
2217         int r;
2218         /* these for check_symlinks_fsobj */
2219         char *linkname_copy;    /* non-const copy of linkname */
2220         struct stat st;
2221         struct archive_string error_string;
2222         int error_number;
2223
2224         /* We identify hard/symlinks according to the link names. */
2225         /* Since link(2) and symlink(2) don't handle modes, we're done here. */
2226         linkname = archive_entry_hardlink(a->entry);
2227         if (linkname != NULL) {
2228 #if !HAVE_LINK
2229                 return (EPERM);
2230 #else
2231                 archive_string_init(&error_string);
2232                 linkname_copy = strdup(linkname);
2233                 if (linkname_copy == NULL) {
2234                     return (EPERM);
2235                 }
2236                 /*
2237                  * TODO: consider using the cleaned-up path as the link
2238                  * target?
2239                  */
2240                 r = cleanup_pathname_fsobj(linkname_copy, &error_number,
2241                     &error_string, a->flags);
2242                 if (r != ARCHIVE_OK) {
2243                         archive_set_error(&a->archive, error_number, "%s",
2244                             error_string.s);
2245                         free(linkname_copy);
2246                         archive_string_free(&error_string);
2247                         /*
2248                          * EPERM is more appropriate than error_number for our
2249                          * callers
2250                          */
2251                         return (EPERM);
2252                 }
2253                 r = check_symlinks_fsobj(linkname_copy, &error_number,
2254                     &error_string, a->flags);
2255                 if (r != ARCHIVE_OK) {
2256                         archive_set_error(&a->archive, error_number, "%s",
2257                             error_string.s);
2258                         free(linkname_copy);
2259                         archive_string_free(&error_string);
2260                         /*
2261                          * EPERM is more appropriate than error_number for our
2262                          * callers
2263                          */
2264                         return (EPERM);
2265                 }
2266                 free(linkname_copy);
2267                 archive_string_free(&error_string);
2268                 /*
2269                  * Unlinking and linking here is really not atomic,
2270                  * but doing it right, would require us to construct
2271                  * an mktemplink() function, and then use rename(2).
2272                  */
2273                 if (a->flags & ARCHIVE_EXTRACT_SAFE_WRITES)
2274                         unlink(a->name);
2275                 r = link(linkname, a->name) ? errno : 0;
2276                 /*
2277                  * New cpio and pax formats allow hardlink entries
2278                  * to carry data, so we may have to open the file
2279                  * for hardlink entries.
2280                  *
2281                  * If the hardlink was successfully created and
2282                  * the archive doesn't have carry data for it,
2283                  * consider it to be non-authoritative for meta data.
2284                  * This is consistent with GNU tar and BSD pax.
2285                  * If the hardlink does carry data, let the last
2286                  * archive entry decide ownership.
2287                  */
2288                 if (r == 0 && a->filesize <= 0) {
2289                         a->todo = 0;
2290                         a->deferred = 0;
2291                 } else if (r == 0 && a->filesize > 0) {
2292 #ifdef HAVE_LSTAT
2293                         r = lstat(a->name, &st);
2294 #else
2295                         r = la_stat(a->name, &st);
2296 #endif
2297                         if (r != 0)
2298                                 r = errno;
2299                         else if ((st.st_mode & AE_IFMT) == AE_IFREG) {
2300                                 a->fd = open(a->name, O_WRONLY | O_TRUNC |
2301                                     O_BINARY | O_CLOEXEC | O_NOFOLLOW);
2302                                 __archive_ensure_cloexec_flag(a->fd);
2303                                 if (a->fd < 0)
2304                                         r = errno;
2305                         }
2306                 }
2307                 return (r);
2308 #endif
2309         }
2310         linkname = archive_entry_symlink(a->entry);
2311         if (linkname != NULL) {
2312 #if HAVE_SYMLINK
2313                 /*
2314                  * Unlinking and linking here is really not atomic,
2315                  * but doing it right, would require us to construct
2316                  * an mktempsymlink() function, and then use rename(2).
2317                  */
2318                 if (a->flags & ARCHIVE_EXTRACT_SAFE_WRITES)
2319                         unlink(a->name);
2320                 return symlink(linkname, a->name) ? errno : 0;
2321 #else
2322                 return (EPERM);
2323 #endif
2324         }
2325
2326         /*
2327          * The remaining system calls all set permissions, so let's
2328          * try to take advantage of that to avoid an extra chmod()
2329          * call.  (Recall that umask is set to zero right now!)
2330          */
2331
2332         /* Mode we want for the final restored object (w/o file type bits). */
2333         final_mode = a->mode & 07777;
2334         /*
2335          * The mode that will actually be restored in this step.  Note
2336          * that SUID, SGID, etc, require additional work to ensure
2337          * security, so we never restore them at this point.
2338          */
2339         mode = final_mode & 0777 & ~a->user_umask;
2340
2341         /* 
2342          * Always create writable such that [f]setxattr() works if we're not
2343          * root.
2344          */
2345         if (a->user_uid != 0 &&
2346             a->todo & (TODO_HFS_COMPRESSION | TODO_XATTR)) {
2347                 mode |= 0200;
2348         }
2349
2350         switch (a->mode & AE_IFMT) {
2351         default:
2352                 /* POSIX requires that we fall through here. */
2353                 /* FALLTHROUGH */
2354         case AE_IFREG:
2355                 a->tmpname = NULL;
2356                 a->fd = open(a->name,
2357                     O_WRONLY | O_CREAT | O_EXCL | O_BINARY | O_CLOEXEC, mode);
2358                 __archive_ensure_cloexec_flag(a->fd);
2359                 r = (a->fd < 0);
2360                 break;
2361         case AE_IFCHR:
2362 #ifdef HAVE_MKNOD
2363                 /* Note: we use AE_IFCHR for the case label, and
2364                  * S_IFCHR for the mknod() call.  This is correct.  */
2365                 r = mknod(a->name, mode | S_IFCHR,
2366                     archive_entry_rdev(a->entry));
2367                 break;
2368 #else
2369                 /* TODO: Find a better way to warn about our inability
2370                  * to restore a char device node. */
2371                 return (EINVAL);
2372 #endif /* HAVE_MKNOD */
2373         case AE_IFBLK:
2374 #ifdef HAVE_MKNOD
2375                 r = mknod(a->name, mode | S_IFBLK,
2376                     archive_entry_rdev(a->entry));
2377                 break;
2378 #else
2379                 /* TODO: Find a better way to warn about our inability
2380                  * to restore a block device node. */
2381                 return (EINVAL);
2382 #endif /* HAVE_MKNOD */
2383         case AE_IFDIR:
2384                 mode = (mode | MINIMUM_DIR_MODE) & MAXIMUM_DIR_MODE;
2385                 r = mkdir(a->name, mode);
2386                 if (r == 0) {
2387                         /* Defer setting dir times. */
2388                         a->deferred |= (a->todo & TODO_TIMES);
2389                         a->todo &= ~TODO_TIMES;
2390                         /* Never use an immediate chmod(). */
2391                         /* We can't avoid the chmod() entirely if EXTRACT_PERM
2392                          * because of SysV SGID inheritance. */
2393                         if ((mode != final_mode)
2394                             || (a->flags & ARCHIVE_EXTRACT_PERM))
2395                                 a->deferred |= (a->todo & TODO_MODE);
2396                         a->todo &= ~TODO_MODE;
2397                 }
2398                 break;
2399         case AE_IFIFO:
2400 #ifdef HAVE_MKFIFO
2401                 r = mkfifo(a->name, mode);
2402                 break;
2403 #else
2404                 /* TODO: Find a better way to warn about our inability
2405                  * to restore a fifo. */
2406                 return (EINVAL);
2407 #endif /* HAVE_MKFIFO */
2408         }
2409
2410         /* All the system calls above set errno on failure. */
2411         if (r)
2412                 return (errno);
2413
2414         /* If we managed to set the final mode, we've avoided a chmod(). */
2415         if (mode == final_mode)
2416                 a->todo &= ~TODO_MODE;
2417         return (0);
2418 }
2419
2420 /*
2421  * Cleanup function for archive_extract.  Mostly, this involves processing
2422  * the fixup list, which is used to address a number of problems:
2423  *   * Dir permissions might prevent us from restoring a file in that
2424  *     dir, so we restore the dir with minimum 0700 permissions first,
2425  *     then correct the mode at the end.
2426  *   * Similarly, the act of restoring a file touches the directory
2427  *     and changes the timestamp on the dir, so we have to touch-up dir
2428  *     timestamps at the end as well.
2429  *   * Some file flags can interfere with the restore by, for example,
2430  *     preventing the creation of hardlinks to those files.
2431  *   * Mac OS extended metadata includes ACLs, so must be deferred on dirs.
2432  *
2433  * Note that tar/cpio do not require that archives be in a particular
2434  * order; there is no way to know when the last file has been restored
2435  * within a directory, so there's no way to optimize the memory usage
2436  * here by fixing up the directory any earlier than the
2437  * end-of-archive.
2438  *
2439  * XXX TODO: Directory ACLs should be restored here, for the same
2440  * reason we set directory perms here. XXX
2441  */
2442 static int
2443 _archive_write_disk_close(struct archive *_a)
2444 {
2445         struct archive_write_disk *a = (struct archive_write_disk *)_a;
2446         struct fixup_entry *next, *p;
2447         int fd, ret;
2448
2449         archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
2450             ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
2451             "archive_write_disk_close");
2452         ret = _archive_write_disk_finish_entry(&a->archive);
2453
2454         /* Sort dir list so directories are fixed up in depth-first order. */
2455         p = sort_dir_list(a->fixup_list);
2456
2457         while (p != NULL) {
2458                 fd = -1;
2459                 a->pst = NULL; /* Mark stat cache as out-of-date. */
2460                 if (p->fixup &
2461                     (TODO_TIMES | TODO_MODE_BASE | TODO_ACLS | TODO_FFLAGS)) {
2462                         fd = open(p->name,
2463                             O_WRONLY | O_BINARY | O_NOFOLLOW | O_CLOEXEC);
2464                 }
2465                 if (p->fixup & TODO_TIMES) {
2466                         set_times(a, fd, p->mode, p->name,
2467                             p->atime, p->atime_nanos,
2468                             p->birthtime, p->birthtime_nanos,
2469                             p->mtime, p->mtime_nanos,
2470                             p->ctime, p->ctime_nanos);
2471                 }
2472                 if (p->fixup & TODO_MODE_BASE) {
2473 #ifdef HAVE_FCHMOD
2474                         if (fd >= 0)
2475                                 fchmod(fd, p->mode);
2476                         else
2477 #endif
2478                         chmod(p->name, p->mode);
2479                 }
2480                 if (p->fixup & TODO_ACLS)
2481                         archive_write_disk_set_acls(&a->archive, fd,
2482                             p->name, &p->acl, p->mode);
2483                 if (p->fixup & TODO_FFLAGS)
2484                         set_fflags_platform(a, fd, p->name,
2485                             p->mode, p->fflags_set, 0);
2486                 if (p->fixup & TODO_MAC_METADATA)
2487                         set_mac_metadata(a, p->name, p->mac_metadata,
2488                                          p->mac_metadata_size);
2489                 next = p->next;
2490                 archive_acl_clear(&p->acl);
2491                 free(p->mac_metadata);
2492                 free(p->name);
2493                 if (fd >= 0)
2494                         close(fd);
2495                 free(p);
2496                 p = next;
2497         }
2498         a->fixup_list = NULL;
2499         return (ret);
2500 }
2501
2502 static int
2503 _archive_write_disk_free(struct archive *_a)
2504 {
2505         struct archive_write_disk *a;
2506         int ret;
2507         if (_a == NULL)
2508                 return (ARCHIVE_OK);
2509         archive_check_magic(_a, ARCHIVE_WRITE_DISK_MAGIC,
2510             ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_disk_free");
2511         a = (struct archive_write_disk *)_a;
2512         ret = _archive_write_disk_close(&a->archive);
2513         archive_write_disk_set_group_lookup(&a->archive, NULL, NULL, NULL);
2514         archive_write_disk_set_user_lookup(&a->archive, NULL, NULL, NULL);
2515         archive_entry_free(a->entry);
2516         archive_string_free(&a->_name_data);
2517         archive_string_free(&a->_tmpname_data);
2518         archive_string_free(&a->archive.error_string);
2519         archive_string_free(&a->path_safe);
2520         a->archive.magic = 0;
2521         __archive_clean(&a->archive);
2522         free(a->decmpfs_header_p);
2523         free(a->resource_fork);
2524         free(a->compressed_buffer);
2525         free(a->uncompressed_buffer);
2526 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_SYS_XATTR_H)\
2527         && defined(HAVE_ZLIB_H)
2528         if (a->stream_valid) {
2529                 switch (deflateEnd(&a->stream)) {
2530                 case Z_OK:
2531                         break;
2532                 default:
2533                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2534                             "Failed to clean up compressor");
2535                         ret = ARCHIVE_FATAL;
2536                         break;
2537                 }
2538         }
2539 #endif
2540         free(a);
2541         return (ret);
2542 }
2543
2544 /*
2545  * Simple O(n log n) merge sort to order the fixup list.  In
2546  * particular, we want to restore dir timestamps depth-first.
2547  */
2548 static struct fixup_entry *
2549 sort_dir_list(struct fixup_entry *p)
2550 {
2551         struct fixup_entry *a, *b, *t;
2552
2553         if (p == NULL)
2554                 return (NULL);
2555         /* A one-item list is already sorted. */
2556         if (p->next == NULL)
2557                 return (p);
2558
2559         /* Step 1: split the list. */
2560         t = p;
2561         a = p->next->next;
2562         while (a != NULL) {
2563                 /* Step a twice, t once. */
2564                 a = a->next;
2565                 if (a != NULL)
2566                         a = a->next;
2567                 t = t->next;
2568         }
2569         /* Now, t is at the mid-point, so break the list here. */
2570         b = t->next;
2571         t->next = NULL;
2572         a = p;
2573
2574         /* Step 2: Recursively sort the two sub-lists. */
2575         a = sort_dir_list(a);
2576         b = sort_dir_list(b);
2577
2578         /* Step 3: Merge the returned lists. */
2579         /* Pick the first element for the merged list. */
2580         if (strcmp(a->name, b->name) > 0) {
2581                 t = p = a;
2582                 a = a->next;
2583         } else {
2584                 t = p = b;
2585                 b = b->next;
2586         }
2587
2588         /* Always put the later element on the list first. */
2589         while (a != NULL && b != NULL) {
2590                 if (strcmp(a->name, b->name) > 0) {
2591                         t->next = a;
2592                         a = a->next;
2593                 } else {
2594                         t->next = b;
2595                         b = b->next;
2596                 }
2597                 t = t->next;
2598         }
2599
2600         /* Only one list is non-empty, so just splice it on. */
2601         if (a != NULL)
2602                 t->next = a;
2603         if (b != NULL)
2604                 t->next = b;
2605
2606         return (p);
2607 }
2608
2609 /*
2610  * Returns a new, initialized fixup entry.
2611  *
2612  * TODO: Reduce the memory requirements for this list by using a tree
2613  * structure rather than a simple list of names.
2614  */
2615 static struct fixup_entry *
2616 new_fixup(struct archive_write_disk *a, const char *pathname)
2617 {
2618         struct fixup_entry *fe;
2619
2620         fe = (struct fixup_entry *)calloc(1, sizeof(struct fixup_entry));
2621         if (fe == NULL) {
2622                 archive_set_error(&a->archive, ENOMEM,
2623                     "Can't allocate memory for a fixup");
2624                 return (NULL);
2625         }
2626         fe->next = a->fixup_list;
2627         a->fixup_list = fe;
2628         fe->fixup = 0;
2629         fe->name = strdup(pathname);
2630         return (fe);
2631 }
2632
2633 /*
2634  * Returns a fixup structure for the current entry.
2635  */
2636 static struct fixup_entry *
2637 current_fixup(struct archive_write_disk *a, const char *pathname)
2638 {
2639         if (a->current_fixup == NULL)
2640                 a->current_fixup = new_fixup(a, pathname);
2641         return (a->current_fixup);
2642 }
2643
2644 /* Error helper for new *_fsobj functions */
2645 static void
2646 fsobj_error(int *a_eno, struct archive_string *a_estr,
2647     int err, const char *errstr, const char *path)
2648 {
2649         if (a_eno)
2650                 *a_eno = err;
2651         if (a_estr)
2652                 archive_string_sprintf(a_estr, "%s%s", errstr, path);
2653 }
2654
2655 /*
2656  * TODO: Someday, integrate this with the deep dir support; they both
2657  * scan the path and both can be optimized by comparing against other
2658  * recent paths.
2659  */
2660 /*
2661  * Checks the given path to see if any elements along it are symlinks.  Returns
2662  * ARCHIVE_OK if there are none, otherwise puts an error in errmsg.
2663  */
2664 static int
2665 check_symlinks_fsobj(char *path, int *a_eno, struct archive_string *a_estr,
2666     int flags)
2667 {
2668 #if !defined(HAVE_LSTAT) && \
2669     !(defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_UNLINKAT))
2670         /* Platform doesn't have lstat, so we can't look for symlinks. */
2671         (void)path; /* UNUSED */
2672         (void)error_number; /* UNUSED */
2673         (void)error_string; /* UNUSED */
2674         (void)flags; /* UNUSED */
2675         return (ARCHIVE_OK);
2676 #else
2677         int res = ARCHIVE_OK;
2678         char *tail;
2679         char *head;
2680         int last;
2681         char c;
2682         int r;
2683         struct stat st;
2684         int chdir_fd;
2685 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_UNLINKAT)
2686         int fd;
2687 #endif
2688
2689         /* Nothing to do here if name is empty */
2690         if(path[0] == '\0')
2691             return (ARCHIVE_OK);
2692
2693         /*
2694          * Guard against symlink tricks.  Reject any archive entry whose
2695          * destination would be altered by a symlink.
2696          *
2697          * Walk the filename in chunks separated by '/'.  For each segment:
2698          *  - if it doesn't exist, continue
2699          *  - if it's symlink, abort or remove it
2700          *  - if it's a directory and it's not the last chunk, cd into it
2701          * As we go:
2702          *  head points to the current (relative) path
2703          *  tail points to the temporary \0 terminating the segment we're
2704          *      currently examining
2705          *  c holds what used to be in *tail
2706          *  last is 1 if this is the last tail
2707          */
2708         chdir_fd = la_opendirat(AT_FDCWD, ".");
2709         __archive_ensure_cloexec_flag(chdir_fd);
2710         if (chdir_fd < 0) {
2711                 fsobj_error(a_eno, a_estr, errno,
2712                     "Could not open ", path);
2713                 return (ARCHIVE_FATAL);
2714         }
2715         head = path;
2716         tail = path;
2717         last = 0;
2718         /* TODO: reintroduce a safe cache here? */
2719         /* Skip the root directory if the path is absolute. */
2720         if(tail == path && tail[0] == '/')
2721                 ++tail;
2722         /* Keep going until we've checked the entire name.
2723          * head, tail, path all alias the same string, which is
2724          * temporarily zeroed at tail, so be careful restoring the
2725          * stashed (c=tail[0]) for error messages.
2726          * Exiting the loop with break is okay; continue is not.
2727          */
2728         while (!last) {
2729                 /*
2730                  * Skip the separator we just consumed, plus any adjacent ones
2731                  */
2732                 while (*tail == '/')
2733                     ++tail;
2734                 /* Skip the next path element. */
2735                 while (*tail != '\0' && *tail != '/')
2736                         ++tail;
2737                 /* is this the last path component? */
2738                 last = (tail[0] == '\0') || (tail[0] == '/' && tail[1] == '\0');
2739                 /* temporarily truncate the string here */
2740                 c = tail[0];
2741                 tail[0] = '\0';
2742                 /* Check that we haven't hit a symlink. */
2743 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_UNLINKAT)
2744                 r = fstatat(chdir_fd, head, &st, AT_SYMLINK_NOFOLLOW);
2745 #else
2746                 r = lstat(head, &st);
2747 #endif
2748                 if (r != 0) {
2749                         tail[0] = c;
2750                         /* We've hit a dir that doesn't exist; stop now. */
2751                         if (errno == ENOENT) {
2752                                 break;
2753                         } else {
2754                                 /*
2755                                  * Treat any other error as fatal - best to be
2756                                  * paranoid here.
2757                                  * Note: This effectively disables deep
2758                                  * directory support when security checks are
2759                                  * enabled. Otherwise, very long pathnames that
2760                                  * trigger an error here could evade the
2761                                  * sandbox.
2762                                  * TODO: We could do better, but it would
2763                                  * probably require merging the symlink checks
2764                                  * with the deep-directory editing.
2765                                  */
2766                                 fsobj_error(a_eno, a_estr, errno,
2767                                     "Could not stat ", path);
2768                                 res = ARCHIVE_FAILED;
2769                                 break;
2770                         }
2771                 } else if (S_ISDIR(st.st_mode)) {
2772                         if (!last) {
2773 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_UNLINKAT)
2774                                 fd = la_opendirat(chdir_fd, head);
2775                                 if (fd < 0)
2776                                         r = -1;
2777                                 else {
2778                                         r = 0;
2779                                         close(chdir_fd);
2780                                         chdir_fd = fd;
2781                                 }
2782 #else
2783                                 r = chdir(head);
2784 #endif
2785                                 if (r != 0) {
2786                                         tail[0] = c;
2787                                         fsobj_error(a_eno, a_estr, errno,
2788                                             "Could not chdir ", path);
2789                                         res = (ARCHIVE_FATAL);
2790                                         break;
2791                                 }
2792                                 /* Our view is now from inside this dir: */
2793                                 head = tail + 1;
2794                         }
2795                 } else if (S_ISLNK(st.st_mode)) {
2796                         if (last) {
2797                                 /*
2798                                  * Last element is symlink; remove it
2799                                  * so we can overwrite it with the
2800                                  * item being extracted.
2801                                  */
2802 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_UNLINKAT)
2803                                 r = unlinkat(chdir_fd, head, 0);
2804 #else
2805                                 r = unlink(head);
2806 #endif
2807                                 if (r != 0) {
2808                                         tail[0] = c;
2809                                         fsobj_error(a_eno, a_estr, errno,
2810                                             "Could not remove symlink ",
2811                                             path);
2812                                         res = ARCHIVE_FAILED;
2813                                         break;
2814                                 }
2815                                 /*
2816                                  * Even if we did remove it, a warning
2817                                  * is in order.  The warning is silly,
2818                                  * though, if we're just replacing one
2819                                  * symlink with another symlink.
2820                                  */
2821                                 tail[0] = c;
2822                                 /*
2823                                  * FIXME:  not sure how important this is to
2824                                  * restore
2825                                  */
2826                                 /*
2827                                 if (!S_ISLNK(path)) {
2828                                         fsobj_error(a_eno, a_estr, 0,
2829                                             "Removing symlink ", path);
2830                                 }
2831                                 */
2832                                 /* Symlink gone.  No more problem! */
2833                                 res = ARCHIVE_OK;
2834                                 break;
2835                         } else if (flags & ARCHIVE_EXTRACT_UNLINK) {
2836                                 /* User asked us to remove problems. */
2837 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_UNLINKAT)
2838                                 r = unlinkat(chdir_fd, head, 0);
2839 #else
2840                                 r = unlink(head);
2841 #endif
2842                                 if (r != 0) {
2843                                         tail[0] = c;
2844                                         fsobj_error(a_eno, a_estr, 0,
2845                                             "Cannot remove intervening "
2846                                             "symlink ", path);
2847                                         res = ARCHIVE_FAILED;
2848                                         break;
2849                                 }
2850                                 tail[0] = c;
2851                         } else if ((flags &
2852                             ARCHIVE_EXTRACT_SECURE_SYMLINKS) == 0) {
2853                                 /*
2854                                  * We are not the last element and we want to
2855                                  * follow symlinks if they are a directory.
2856                                  * 
2857                                  * This is needed to extract hardlinks over
2858                                  * symlinks.
2859                                  */
2860 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_UNLINKAT)
2861                                 r = fstatat(chdir_fd, head, &st, 0);
2862 #else
2863                                 r = la_stat(head, &st);
2864 #endif
2865                                 if (r != 0) {
2866                                         tail[0] = c;
2867                                         if (errno == ENOENT) {
2868                                                 break;
2869                                         } else {
2870                                                 fsobj_error(a_eno, a_estr,
2871                                                     errno,
2872                                                     "Could not stat ", path);
2873                                                 res = (ARCHIVE_FAILED);
2874                                                 break;
2875                                         }
2876                                 } else if (S_ISDIR(st.st_mode)) {
2877 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_UNLINKAT)
2878                                         fd = la_opendirat(chdir_fd, head);
2879                                         if (fd < 0)
2880                                                 r = -1;
2881                                         else {
2882                                                 r = 0;
2883                                                 close(chdir_fd);
2884                                                 chdir_fd = fd;
2885                                         }
2886 #else
2887                                         r = chdir(head);
2888 #endif
2889                                         if (r != 0) {
2890                                                 tail[0] = c;
2891                                                 fsobj_error(a_eno, a_estr,
2892                                                     errno,
2893                                                     "Could not chdir ", path);
2894                                                 res = (ARCHIVE_FATAL);
2895                                                 break;
2896                                         }
2897                                         /*
2898                                          * Our view is now from inside
2899                                          * this dir:
2900                                          */
2901                                         head = tail + 1;
2902                                 } else {
2903                                         tail[0] = c;
2904                                         fsobj_error(a_eno, a_estr, 0,
2905                                             "Cannot extract through "
2906                                             "symlink ", path);
2907                                         res = ARCHIVE_FAILED;
2908                                         break;
2909                                 }
2910                         } else {
2911                                 tail[0] = c;
2912                                 fsobj_error(a_eno, a_estr, 0,
2913                                     "Cannot extract through symlink ", path);
2914                                 res = ARCHIVE_FAILED;
2915                                 break;
2916                         }
2917                 }
2918                 /* be sure to always maintain this */
2919                 tail[0] = c;
2920                 if (tail[0] != '\0')
2921                         tail++; /* Advance to the next segment. */
2922         }
2923         /* Catches loop exits via break */
2924         tail[0] = c;
2925 #if defined(HAVE_OPENAT) && defined(HAVE_FSTATAT) && defined(HAVE_UNLINKAT)
2926         /* If we operate with openat(), fstatat() and unlinkat() there was
2927          * no chdir(), so just close the fd */
2928         if (chdir_fd >= 0)
2929                 close(chdir_fd);
2930 #elif HAVE_FCHDIR
2931         /* If we changed directory above, restore it here. */
2932         if (chdir_fd >= 0) {
2933                 r = fchdir(chdir_fd);
2934                 if (r != 0) {
2935                         fsobj_error(a_eno, a_estr, errno,
2936                             "chdir() failure", "");
2937                 }
2938                 close(chdir_fd);
2939                 chdir_fd = -1;
2940                 if (r != 0) {
2941                         res = (ARCHIVE_FATAL);
2942                 }
2943         }
2944 #endif
2945         /* TODO: reintroduce a safe cache here? */
2946         return res;
2947 #endif
2948 }
2949
2950 /*
2951  * Check a->name for symlinks, returning ARCHIVE_OK if its clean, otherwise
2952  * calls archive_set_error and returns ARCHIVE_{FATAL,FAILED}
2953  */
2954 static int
2955 check_symlinks(struct archive_write_disk *a)
2956 {
2957         struct archive_string error_string;
2958         int error_number;
2959         int rc;
2960         archive_string_init(&error_string);
2961         rc = check_symlinks_fsobj(a->name, &error_number, &error_string,
2962             a->flags);
2963         if (rc != ARCHIVE_OK) {
2964                 archive_set_error(&a->archive, error_number, "%s",
2965                     error_string.s);
2966         }
2967         archive_string_free(&error_string);
2968         a->pst = NULL;  /* to be safe */
2969         return rc;
2970 }
2971
2972
2973 #if defined(__CYGWIN__)
2974 /*
2975  * 1. Convert a path separator from '\' to '/' .
2976  *    We shouldn't check multibyte character directly because some
2977  *    character-set have been using the '\' character for a part of
2978  *    its multibyte character code.
2979  * 2. Replace unusable characters in Windows with underscore('_').
2980  * See also : http://msdn.microsoft.com/en-us/library/aa365247.aspx
2981  */
2982 static void
2983 cleanup_pathname_win(char *path)
2984 {
2985         wchar_t wc;
2986         char *p;
2987         size_t alen, l;
2988         int mb, complete, utf8;
2989
2990         alen = 0;
2991         mb = 0;
2992         complete = 1;
2993         utf8 = (strcmp(nl_langinfo(CODESET), "UTF-8") == 0)? 1: 0;
2994         for (p = path; *p != '\0'; p++) {
2995                 ++alen;
2996                 if (*p == '\\') {
2997                         /* If previous byte is smaller than 128,
2998                          * this is not second byte of multibyte characters,
2999                          * so we can replace '\' with '/'. */
3000                         if (utf8 || !mb)
3001                                 *p = '/';
3002                         else
3003                                 complete = 0;/* uncompleted. */
3004                 } else if (*(unsigned char *)p > 127)
3005                         mb = 1;
3006                 else
3007                         mb = 0;
3008                 /* Rewrite the path name if its next character is unusable. */
3009                 if (*p == ':' || *p == '*' || *p == '?' || *p == '"' ||
3010                     *p == '<' || *p == '>' || *p == '|')
3011                         *p = '_';
3012         }
3013         if (complete)
3014                 return;
3015
3016         /*
3017          * Convert path separator in wide-character.
3018          */
3019         p = path;
3020         while (*p != '\0' && alen) {
3021                 l = mbtowc(&wc, p, alen);
3022                 if (l == (size_t)-1) {
3023                         while (*p != '\0') {
3024                                 if (*p == '\\')
3025                                         *p = '/';
3026                                 ++p;
3027                         }
3028                         break;
3029                 }
3030                 if (l == 1 && wc == L'\\')
3031                         *p = '/';
3032                 p += l;
3033                 alen -= l;
3034         }
3035 }
3036 #endif
3037
3038 /*
3039  * Canonicalize the pathname.  In particular, this strips duplicate
3040  * '/' characters, '.' elements, and trailing '/'.  It also raises an
3041  * error for an empty path, a trailing '..', (if _SECURE_NODOTDOT is
3042  * set) any '..' in the path or (if ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS
3043  * is set) if the path is absolute.
3044  */
3045 static int
3046 cleanup_pathname_fsobj(char *path, int *a_eno, struct archive_string *a_estr,
3047     int flags)
3048 {
3049         char *dest, *src;
3050         char separator = '\0';
3051
3052         dest = src = path;
3053         if (*src == '\0') {
3054                 fsobj_error(a_eno, a_estr, ARCHIVE_ERRNO_MISC,
3055                     "Invalid empty ", "pathname");
3056                 return (ARCHIVE_FAILED);
3057         }
3058
3059 #if defined(__CYGWIN__)
3060         cleanup_pathname_win(path);
3061 #endif
3062         /* Skip leading '/'. */
3063         if (*src == '/') {
3064                 if (flags & ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS) {
3065                         fsobj_error(a_eno, a_estr, ARCHIVE_ERRNO_MISC,
3066                             "Path is ", "absolute");
3067                         return (ARCHIVE_FAILED);
3068                 }
3069
3070                 separator = *src++;
3071         }
3072
3073         /* Scan the pathname one element at a time. */
3074         for (;;) {
3075                 /* src points to first char after '/' */
3076                 if (src[0] == '\0') {
3077                         break;
3078                 } else if (src[0] == '/') {
3079                         /* Found '//', ignore second one. */
3080                         src++;
3081                         continue;
3082                 } else if (src[0] == '.') {
3083                         if (src[1] == '\0') {
3084                                 /* Ignore trailing '.' */
3085                                 break;
3086                         } else if (src[1] == '/') {
3087                                 /* Skip './'. */
3088                                 src += 2;
3089                                 continue;
3090                         } else if (src[1] == '.') {
3091                                 if (src[2] == '/' || src[2] == '\0') {
3092                                         /* Conditionally warn about '..' */
3093                                         if (flags
3094                                             & ARCHIVE_EXTRACT_SECURE_NODOTDOT) {
3095                                                 fsobj_error(a_eno, a_estr,
3096                                                     ARCHIVE_ERRNO_MISC,
3097                                                     "Path contains ", "'..'");
3098                                                 return (ARCHIVE_FAILED);
3099                                         }
3100                                 }
3101                                 /*
3102                                  * Note: Under no circumstances do we
3103                                  * remove '..' elements.  In
3104                                  * particular, restoring
3105                                  * '/foo/../bar/' should create the
3106                                  * 'foo' dir as a side-effect.
3107                                  */
3108                         }
3109                 }
3110
3111                 /* Copy current element, including leading '/'. */
3112                 if (separator)
3113                         *dest++ = '/';
3114                 while (*src != '\0' && *src != '/') {
3115                         *dest++ = *src++;
3116                 }
3117
3118                 if (*src == '\0')
3119                         break;
3120
3121                 /* Skip '/' separator. */
3122                 separator = *src++;
3123         }
3124         /*
3125          * We've just copied zero or more path elements, not including the
3126          * final '/'.
3127          */
3128         if (dest == path) {
3129                 /*
3130                  * Nothing got copied.  The path must have been something
3131                  * like '.' or '/' or './' or '/././././/./'.
3132                  */
3133                 if (separator)
3134                         *dest++ = '/';
3135                 else
3136                         *dest++ = '.';
3137         }
3138         /* Terminate the result. */
3139         *dest = '\0';
3140         return (ARCHIVE_OK);
3141 }
3142
3143 static int
3144 cleanup_pathname(struct archive_write_disk *a)
3145 {
3146         struct archive_string error_string;
3147         int error_number;
3148         int rc;
3149         archive_string_init(&error_string);
3150         rc = cleanup_pathname_fsobj(a->name, &error_number, &error_string,
3151             a->flags);
3152         if (rc != ARCHIVE_OK) {
3153                 archive_set_error(&a->archive, error_number, "%s",
3154                     error_string.s);
3155         }
3156         archive_string_free(&error_string);
3157         return rc;
3158 }
3159
3160 /*
3161  * Create the parent directory of the specified path, assuming path
3162  * is already in mutable storage.
3163  */
3164 static int
3165 create_parent_dir(struct archive_write_disk *a, char *path)
3166 {
3167         char *slash;
3168         int r;
3169
3170         /* Remove tail element to obtain parent name. */
3171         slash = strrchr(path, '/');
3172         if (slash == NULL)
3173                 return (ARCHIVE_OK);
3174         *slash = '\0';
3175         r = create_dir(a, path);
3176         *slash = '/';
3177         return (r);
3178 }
3179
3180 /*
3181  * Create the specified dir, recursing to create parents as necessary.
3182  *
3183  * Returns ARCHIVE_OK if the path exists when we're done here.
3184  * Otherwise, returns ARCHIVE_FAILED.
3185  * Assumes path is in mutable storage; path is unchanged on exit.
3186  */
3187 static int
3188 create_dir(struct archive_write_disk *a, char *path)
3189 {
3190         struct stat st;
3191         struct fixup_entry *le;
3192         char *slash, *base;
3193         mode_t mode_final, mode;
3194         int r;
3195
3196         /* Check for special names and just skip them. */
3197         slash = strrchr(path, '/');
3198         if (slash == NULL)
3199                 base = path;
3200         else
3201                 base = slash + 1;
3202
3203         if (base[0] == '\0' ||
3204             (base[0] == '.' && base[1] == '\0') ||
3205             (base[0] == '.' && base[1] == '.' && base[2] == '\0')) {
3206                 /* Don't bother trying to create null path, '.', or '..'. */
3207                 if (slash != NULL) {
3208                         *slash = '\0';
3209                         r = create_dir(a, path);
3210                         *slash = '/';
3211                         return (r);
3212                 }
3213                 return (ARCHIVE_OK);
3214         }
3215
3216         /*
3217          * Yes, this should be stat() and not lstat().  Using lstat()
3218          * here loses the ability to extract through symlinks.  Also note
3219          * that this should not use the a->st cache.
3220          */
3221         if (la_stat(path, &st) == 0) {
3222                 if (S_ISDIR(st.st_mode))
3223                         return (ARCHIVE_OK);
3224                 if ((a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) {
3225                         archive_set_error(&a->archive, EEXIST,
3226                             "Can't create directory '%s'", path);
3227                         return (ARCHIVE_FAILED);
3228                 }
3229                 if (unlink(path) != 0) {
3230                         archive_set_error(&a->archive, errno,
3231                             "Can't create directory '%s': "
3232                             "Conflicting file cannot be removed",
3233                             path);
3234                         return (ARCHIVE_FAILED);
3235                 }
3236         } else if (errno != ENOENT && errno != ENOTDIR) {
3237                 /* Stat failed? */
3238                 archive_set_error(&a->archive, errno,
3239                     "Can't test directory '%s'", path);
3240                 return (ARCHIVE_FAILED);
3241         } else if (slash != NULL) {
3242                 *slash = '\0';
3243                 r = create_dir(a, path);
3244                 *slash = '/';
3245                 if (r != ARCHIVE_OK)
3246                         return (r);
3247         }
3248
3249         /*
3250          * Mode we want for the final restored directory.  Per POSIX,
3251          * implicitly-created dirs must be created obeying the umask.
3252          * There's no mention whether this is different for privileged
3253          * restores (which the rest of this code handles by pretending
3254          * umask=0).  I've chosen here to always obey the user's umask for
3255          * implicit dirs, even if _EXTRACT_PERM was specified.
3256          */
3257         mode_final = DEFAULT_DIR_MODE & ~a->user_umask;
3258         /* Mode we want on disk during the restore process. */
3259         mode = mode_final;
3260         mode |= MINIMUM_DIR_MODE;
3261         mode &= MAXIMUM_DIR_MODE;
3262         if (mkdir(path, mode) == 0) {
3263                 if (mode != mode_final) {
3264                         le = new_fixup(a, path);
3265                         if (le == NULL)
3266                                 return (ARCHIVE_FATAL);
3267                         le->fixup |=TODO_MODE_BASE;
3268                         le->mode = mode_final;
3269                 }
3270                 return (ARCHIVE_OK);
3271         }
3272
3273         /*
3274          * Without the following check, a/b/../b/c/d fails at the
3275          * second visit to 'b', so 'd' can't be created.  Note that we
3276          * don't add it to the fixup list here, as it's already been
3277          * added.
3278          */
3279         if (la_stat(path, &st) == 0 && S_ISDIR(st.st_mode))
3280                 return (ARCHIVE_OK);
3281
3282         archive_set_error(&a->archive, errno, "Failed to create dir '%s'",
3283             path);
3284         return (ARCHIVE_FAILED);
3285 }
3286
3287 /*
3288  * Note: Although we can skip setting the user id if the desired user
3289  * id matches the current user, we cannot skip setting the group, as
3290  * many systems set the gid based on the containing directory.  So
3291  * we have to perform a chown syscall if we want to set the SGID
3292  * bit.  (The alternative is to stat() and then possibly chown(); it's
3293  * more efficient to skip the stat() and just always chown().)  Note
3294  * that a successful chown() here clears the TODO_SGID_CHECK bit, which
3295  * allows set_mode to skip the stat() check for the GID.
3296  */
3297 static int
3298 set_ownership(struct archive_write_disk *a)
3299 {
3300 #if !defined(__CYGWIN__) && !defined(__linux__)
3301 /*
3302  * On Linux, a process may have the CAP_CHOWN capability.
3303  * On Windows there is no 'root' user with uid 0.
3304  * Elsewhere we can skip calling chown if we are not root and the desired
3305  * user id does not match the current user.
3306  */
3307         if (a->user_uid != 0 && a->user_uid != a->uid) {
3308                 archive_set_error(&a->archive, errno,
3309                     "Can't set UID=%jd", (intmax_t)a->uid);
3310                 return (ARCHIVE_WARN);
3311         }
3312 #endif
3313
3314 #ifdef HAVE_FCHOWN
3315         /* If we have an fd, we can avoid a race. */
3316         if (a->fd >= 0 && fchown(a->fd, a->uid, a->gid) == 0) {
3317                 /* We've set owner and know uid/gid are correct. */
3318                 a->todo &= ~(TODO_OWNER | TODO_SGID_CHECK | TODO_SUID_CHECK);
3319                 return (ARCHIVE_OK);
3320         }
3321 #endif
3322
3323         /* We prefer lchown() but will use chown() if that's all we have. */
3324         /* Of course, if we have neither, this will always fail. */
3325 #ifdef HAVE_LCHOWN
3326         if (lchown(a->name, a->uid, a->gid) == 0) {
3327                 /* We've set owner and know uid/gid are correct. */
3328                 a->todo &= ~(TODO_OWNER | TODO_SGID_CHECK | TODO_SUID_CHECK);
3329                 return (ARCHIVE_OK);
3330         }
3331 #elif HAVE_CHOWN
3332         if (!S_ISLNK(a->mode) && chown(a->name, a->uid, a->gid) == 0) {
3333                 /* We've set owner and know uid/gid are correct. */
3334                 a->todo &= ~(TODO_OWNER | TODO_SGID_CHECK | TODO_SUID_CHECK);
3335                 return (ARCHIVE_OK);
3336         }
3337 #endif
3338
3339         archive_set_error(&a->archive, errno,
3340             "Can't set user=%jd/group=%jd for %s",
3341             (intmax_t)a->uid, (intmax_t)a->gid, a->name);
3342         return (ARCHIVE_WARN);
3343 }
3344
3345 /*
3346  * Note: Returns 0 on success, non-zero on failure.
3347  */
3348 static int
3349 set_time(int fd, int mode, const char *name,
3350     time_t atime, long atime_nsec,
3351     time_t mtime, long mtime_nsec)
3352 {
3353         /* Select the best implementation for this platform. */
3354 #if defined(HAVE_UTIMENSAT) && defined(HAVE_FUTIMENS)
3355         /*
3356          * utimensat() and futimens() are defined in
3357          * POSIX.1-2008. They support ns resolution and setting times
3358          * on fds and symlinks.
3359          */
3360         struct timespec ts[2];
3361         (void)mode; /* UNUSED */
3362         if (atime == (time_t)-1) {
3363                 ts[0].tv_sec = 0;
3364                 ts[0].tv_nsec = UTIME_OMIT;
3365         } else {
3366                 ts[0].tv_sec = atime;
3367                 ts[0].tv_nsec = atime_nsec;
3368         }
3369         if (mtime == (time_t)-1) {
3370                 ts[1].tv_sec = 0;
3371                 ts[1].tv_nsec = UTIME_OMIT;
3372         } else {
3373                 ts[1].tv_sec = mtime;
3374                 ts[1].tv_nsec = mtime_nsec;
3375         }
3376         if (fd >= 0)
3377                 return futimens(fd, ts);
3378         return utimensat(AT_FDCWD, name, ts, AT_SYMLINK_NOFOLLOW);
3379
3380 #elif HAVE_UTIMES
3381         /*