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 struct fixup_entry {
169 struct fixup_entry *next;
170 struct archive_acl acl;
171 mode_t mode;
172 int64_t atime;
173 int64_t birthtime;
174 int64_t mtime;
175 int64_t ctime;
176 unsigned long atime_nanos;
177 unsigned long birthtime_nanos;
178 unsigned long mtime_nanos;
179 unsigned long ctime_nanos;
180 unsigned long fflags_set;
181 size_t mac_metadata_size;
182 void *mac_metadata;
183 int fixup; /* bitmask of what needs fixing */
184 char *name;
185 };
186
187 /*
188 * We use a bitmask to track which operations remain to be done for
189 * this file. In particular, this helps us avoid unnecessary
190 * operations when it's possible to take care of one step as a
191 * side-effect of another. For example, mkdir() can specify the mode
192 * for the newly-created object but symlink() cannot. This means we
193 * can skip chmod() if mkdir() succeeded, but we must explicitly
194 * chmod() if we're trying to create a directory that already exists
195 * (mkdir() failed) or if we're restoring a symlink. Similarly, we
196 * need to verify UID/GID before trying to restore SUID/SGID bits;
197 * that verification can occur explicitly through a stat() call or
198 * implicitly because of a successful chown() call.
199 */
200 #define TODO_MODE_FORCE 0x40000000
201 #define TODO_MODE_BASE 0x20000000
202 #define TODO_SUID 0x10000000
203 #define TODO_SUID_CHECK 0x08000000
204 #define TODO_SGID 0x04000000
205 #define TODO_SGID_CHECK 0x02000000
206 #define TODO_APPLEDOUBLE 0x01000000
207 #define TODO_MODE (TODO_MODE_BASE|TODO_SUID|TODO_SGID)
208 #define TODO_TIMES ARCHIVE_EXTRACT_TIME
209 #define TODO_OWNER ARCHIVE_EXTRACT_OWNER
210 #define TODO_FFLAGS ARCHIVE_EXTRACT_FFLAGS
211 #define TODO_ACLS ARCHIVE_EXTRACT_ACL
212 #define TODO_XATTR ARCHIVE_EXTRACT_XATTR
213 #define TODO_MAC_METADATA ARCHIVE_EXTRACT_MAC_METADATA
214 #define TODO_HFS_COMPRESSION ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED
215
216 struct archive_write_disk {
217 struct archive archive;
218
219 mode_t user_umask;
220 struct fixup_entry *fixup_list;
221 struct fixup_entry *current_fixup;
222 int64_t user_uid;
223 int skip_file_set;
224 int64_t skip_file_dev;
225 int64_t skip_file_ino;
226 time_t start_time;
227
228 int64_t (*lookup_gid)(void *private, const char *gname, int64_t gid);
229 void (*cleanup_gid)(void *private);
230 void *lookup_gid_data;
231 int64_t (*lookup_uid)(void *private, const char *uname, int64_t uid);
232 void (*cleanup_uid)(void *private);
233 void *lookup_uid_data;
234
235 /*
236 * Full path of last file to satisfy symlink checks.
237 */
238 struct archive_string path_safe;
239
240 /*
241 * Cached stat data from disk for the current entry.
242 * If this is valid, pst points to st. Otherwise,
243 * pst is null.
244 */
245 struct stat st;
246 struct stat *pst;
247
248 /* Information about the object being restored right now. */
249 struct archive_entry *entry; /* Entry being extracted. */
250 char *name; /* Name of entry, possibly edited. */
251 struct archive_string _name_data; /* backing store for 'name' */
252 /* Tasks remaining for this object. */
253 int todo;
254 /* Tasks deferred until end-of-archive. */
255 int deferred;
256 /* Options requested by the client. */
257 int flags;
258 /* Handle for the file we're restoring. */
259 int fd;
260 /* Current offset for writing data to the file. */
261 int64_t offset;
262 /* Last offset actually written to disk. */
263 int64_t fd_offset;
264 /* Total bytes actually written to files. */
265 int64_t total_bytes_written;
266 /* Maximum size of file, -1 if unknown. */
267 int64_t filesize;
268 /* Dir we were in before this restore; only for deep paths. */
269 int restore_pwd;
270 /* Mode we should use for this entry; affected by _PERM and umask. */
271 mode_t mode;
272 /* UID/GID to use in restoring this entry. */
273 int64_t uid;
274 int64_t gid;
275 /*
276 * HFS+ Compression.
277 */
278 /* Xattr "com.apple.decmpfs". */
279 uint32_t decmpfs_attr_size;
280 unsigned char *decmpfs_header_p;
281 /* ResourceFork set options used for fsetxattr. */
282 int rsrc_xattr_options;
283 /* Xattr "com.apple.ResourceFork". */
284 unsigned char *resource_fork;
285 size_t resource_fork_allocated_size;
286 unsigned int decmpfs_block_count;
287 uint32_t *decmpfs_block_info;
288 /* Buffer for compressed data. */
289 unsigned char *compressed_buffer;
290 size_t compressed_buffer_size;
291 size_t compressed_buffer_remaining;
292 /* The offset of the ResourceFork where compressed data will
293 * be placed. */
294 uint32_t compressed_rsrc_position;
295 uint32_t compressed_rsrc_position_v;
296 /* Buffer for uncompressed data. */
297 char *uncompressed_buffer;
298 size_t block_remaining_bytes;
299 size_t file_remaining_bytes;
300 #ifdef HAVE_ZLIB_H
301 z_stream stream;
302 int stream_valid;
303 int decmpfs_compression_level;
304 #endif
305 };
306
307 /*
308 * Default mode for dirs created automatically (will be modified by umask).
309 * Note that POSIX specifies 0777 for implicitly-created dirs, "modified
310 * by the process' file creation mask."
311 */
312 #define DEFAULT_DIR_MODE 0777
313 /*
314 * Dir modes are restored in two steps: During the extraction, the permissions
315 * in the archive are modified to match the following limits. During
316 * the post-extract fixup pass, the permissions from the archive are
317 * applied.
318 */
319 #define MINIMUM_DIR_MODE 0700
320 #define MAXIMUM_DIR_MODE 0775
321
322 /*
323 * Maximum uncompressed size of a decmpfs block.
324 */
325 #define MAX_DECMPFS_BLOCK_SIZE (64 * 1024)
326 /*
327 * HFS+ compression type.
328 */
329 #define CMP_XATTR 3/* Compressed data in xattr. */
330 #define CMP_RESOURCE_FORK 4/* Compressed data in resource fork. */
331 /*
332 * HFS+ compression resource fork.
333 */
334 #define RSRC_H_SIZE 260 /* Base size of Resource fork header. */
335 #define RSRC_F_SIZE 50 /* Size of Resource fork footer. */
336 /* Size to write compressed data to resource fork. */
337 #define COMPRESSED_W_SIZE (64 * 1024)
338 /* decmpfs definitions. */
339 #define MAX_DECMPFS_XATTR_SIZE 3802
340 #ifndef DECMPFS_XATTR_NAME
341 #define DECMPFS_XATTR_NAME "com.apple.decmpfs"
342 #endif
343 #define DECMPFS_MAGIC 0x636d7066
344 #define DECMPFS_COMPRESSION_MAGIC 0
345 #define DECMPFS_COMPRESSION_TYPE 4
346 #define DECMPFS_UNCOMPRESSED_SIZE 8
347 #define DECMPFS_HEADER_SIZE 16
348
349 #define HFS_BLOCKS(s) ((s) >> 12)
350
351 static void fsobj_error(int *, struct archive_string *, int, const char *,
352 const char *);
353 static int check_symlinks_fsobj(char *, int *, struct archive_string *,
354 int);
355 static int check_symlinks(struct archive_write_disk *);
356 static int create_filesystem_object(struct archive_write_disk *);
357 static struct fixup_entry *current_fixup(struct archive_write_disk *,
358 const char *pathname);
359 #if defined(HAVE_FCHDIR) && defined(PATH_MAX)
360 static void edit_deep_directories(struct archive_write_disk *ad);
361 #endif
362 static int cleanup_pathname_fsobj(char *, int *, struct archive_string *,
363 int);
364 static int cleanup_pathname(struct archive_write_disk *);
365 static int create_dir(struct archive_write_disk *, char *);
366 static int create_parent_dir(struct archive_write_disk *, char *);
367 static ssize_t hfs_write_data_block(struct archive_write_disk *,
368 const char *, size_t);
369 static int fixup_appledouble(struct archive_write_disk *, const char *);
370 static int older(struct stat *, struct archive_entry *);
371 static int restore_entry(struct archive_write_disk *);
372 static int set_mac_metadata(struct archive_write_disk *, const char *,
373 const void *, size_t);
374 static int set_xattrs(struct archive_write_disk *);
375 static int clear_nochange_fflags(struct archive_write_disk *);
376 static int set_fflags(struct archive_write_disk *);
377 static int set_fflags_platform(struct archive_write_disk *, int fd,
378 const char *name, mode_t mode,
379 unsigned long fflags_set, unsigned long fflags_clear);
380 static int set_ownership(struct archive_write_disk *);
381 static int set_mode(struct archive_write_disk *, int mode);
382 static int set_time(int, int, const char *, time_t, long, time_t, long);
383 static int set_times(struct archive_write_disk *, int, int, const char *,
384 time_t, long, time_t, long, time_t, long, time_t, long);
385 static int set_times_from_entry(struct archive_write_disk *);
386 static struct fixup_entry *sort_dir_list(struct fixup_entry *p);
387 static ssize_t write_data_block(struct archive_write_disk *,
388 const char *, size_t);
389
390 static struct archive_vtable *archive_write_disk_vtable(void);
391
392 static int _archive_write_disk_close(struct archive *);
393 static int _archive_write_disk_free(struct archive *);
394 static int _archive_write_disk_header(struct archive *,
395 struct archive_entry *);
396 static int64_t _archive_write_disk_filter_bytes(struct archive *, int);
397 static int _archive_write_disk_finish_entry(struct archive *);
398 static ssize_t _archive_write_disk_data(struct archive *, const void *,
399 size_t);
400 static ssize_t _archive_write_disk_data_block(struct archive *, const void *,
401 size_t, int64_t);
402
403 static int
lazy_stat(struct archive_write_disk * a)404 lazy_stat(struct archive_write_disk *a)
405 {
406 if (a->pst != NULL) {
407 /* Already have stat() data available. */
408 return (ARCHIVE_OK);
409 }
410 #ifdef HAVE_FSTAT
411 if (a->fd >= 0 && fstat(a->fd, &a->st) == 0) {
412 a->pst = &a->st;
413 return (ARCHIVE_OK);
414 }
415 #endif
416 /*
417 * XXX At this point, symlinks should not be hit, otherwise
418 * XXX a race occurred. Do we want to check explicitly for that?
419 */
420 if (lstat(a->name, &a->st) == 0) {
421 a->pst = &a->st;
422 return (ARCHIVE_OK);
423 }
424 archive_set_error(&a->archive, errno, "Couldn't stat file");
425 return (ARCHIVE_WARN);
426 }
427
428 static struct archive_vtable *
archive_write_disk_vtable(void)429 archive_write_disk_vtable(void)
430 {
431 static struct archive_vtable av;
432 static int inited = 0;
433
434 if (!inited) {
435 av.archive_close = _archive_write_disk_close;
436 av.archive_filter_bytes = _archive_write_disk_filter_bytes;
437 av.archive_free = _archive_write_disk_free;
438 av.archive_write_header = _archive_write_disk_header;
439 av.archive_write_finish_entry
440 = _archive_write_disk_finish_entry;
441 av.archive_write_data = _archive_write_disk_data;
442 av.archive_write_data_block = _archive_write_disk_data_block;
443 inited = 1;
444 }
445 return (&av);
446 }
447
448 static int64_t
_archive_write_disk_filter_bytes(struct archive * _a,int n)449 _archive_write_disk_filter_bytes(struct archive *_a, int n)
450 {
451 struct archive_write_disk *a = (struct archive_write_disk *)_a;
452 (void)n; /* UNUSED */
453 if (n == -1 || n == 0)
454 return (a->total_bytes_written);
455 return (-1);
456 }
457
458
459 int
archive_write_disk_set_options(struct archive * _a,int flags)460 archive_write_disk_set_options(struct archive *_a, int flags)
461 {
462 struct archive_write_disk *a = (struct archive_write_disk *)_a;
463
464 a->flags = flags;
465 return (ARCHIVE_OK);
466 }
467
468
469 /*
470 * Extract this entry to disk.
471 *
472 * TODO: Validate hardlinks. According to the standards, we're
473 * supposed to check each extracted hardlink and squawk if it refers
474 * to a file that we didn't restore. I'm not entirely convinced this
475 * is a good idea, but more importantly: Is there any way to validate
476 * hardlinks without keeping a complete list of filenames from the
477 * entire archive?? Ugh.
478 *
479 */
480 static int
_archive_write_disk_header(struct archive * _a,struct archive_entry * entry)481 _archive_write_disk_header(struct archive *_a, struct archive_entry *entry)
482 {
483 struct archive_write_disk *a = (struct archive_write_disk *)_a;
484 struct fixup_entry *fe;
485 int ret, r;
486
487 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
488 ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
489 "archive_write_disk_header");
490 archive_clear_error(&a->archive);
491 if (a->archive.state & ARCHIVE_STATE_DATA) {
492 r = _archive_write_disk_finish_entry(&a->archive);
493 if (r == ARCHIVE_FATAL)
494 return (r);
495 }
496
497 /* Set up for this particular entry. */
498 a->pst = NULL;
499 a->current_fixup = NULL;
500 a->deferred = 0;
501 if (a->entry) {
502 archive_entry_free(a->entry);
503 a->entry = NULL;
504 }
505 a->entry = archive_entry_clone(entry);
506 a->fd = -1;
507 a->fd_offset = 0;
508 a->offset = 0;
509 a->restore_pwd = -1;
510 a->uid = a->user_uid;
511 a->mode = archive_entry_mode(a->entry);
512 if (archive_entry_size_is_set(a->entry))
513 a->filesize = archive_entry_size(a->entry);
514 else
515 a->filesize = -1;
516 archive_strcpy(&(a->_name_data), archive_entry_pathname(a->entry));
517 a->name = a->_name_data.s;
518 archive_clear_error(&a->archive);
519
520 /*
521 * Clean up the requested path. This is necessary for correct
522 * dir restores; the dir restore logic otherwise gets messed
523 * up by nonsense like "dir/.".
524 */
525 ret = cleanup_pathname(a);
526 if (ret != ARCHIVE_OK)
527 return (ret);
528
529 /*
530 * Query the umask so we get predictable mode settings.
531 * This gets done on every call to _write_header in case the
532 * user edits their umask during the extraction for some
533 * reason.
534 */
535 umask(a->user_umask = umask(0));
536
537 /* Figure out what we need to do for this entry. */
538 a->todo = TODO_MODE_BASE;
539 if (a->flags & ARCHIVE_EXTRACT_PERM) {
540 a->todo |= TODO_MODE_FORCE; /* Be pushy about permissions. */
541 /*
542 * SGID requires an extra "check" step because we
543 * cannot easily predict the GID that the system will
544 * assign. (Different systems assign GIDs to files
545 * based on a variety of criteria, including process
546 * credentials and the gid of the enclosing
547 * directory.) We can only restore the SGID bit if
548 * the file has the right GID, and we only know the
549 * GID if we either set it (see set_ownership) or if
550 * we've actually called stat() on the file after it
551 * was restored. Since there are several places at
552 * which we might verify the GID, we need a TODO bit
553 * to keep track.
554 */
555 if (a->mode & S_ISGID)
556 a->todo |= TODO_SGID | TODO_SGID_CHECK;
557 /*
558 * Verifying the SUID is simpler, but can still be
559 * done in multiple ways, hence the separate "check" bit.
560 */
561 if (a->mode & S_ISUID)
562 a->todo |= TODO_SUID | TODO_SUID_CHECK;
563 } else {
564 /*
565 * User didn't request full permissions, so don't
566 * restore SUID, SGID bits and obey umask.
567 */
568 a->mode &= ~S_ISUID;
569 a->mode &= ~S_ISGID;
570 a->mode &= ~S_ISVTX;
571 a->mode &= ~a->user_umask;
572 }
573 if (a->flags & ARCHIVE_EXTRACT_OWNER)
574 a->todo |= TODO_OWNER;
575 if (a->flags & ARCHIVE_EXTRACT_TIME)
576 a->todo |= TODO_TIMES;
577 if (a->flags & ARCHIVE_EXTRACT_ACL) {
578 #if ARCHIVE_ACL_DARWIN
579 /*
580 * On MacOS, platform ACLs get stored in mac_metadata, too.
581 * If we intend to extract mac_metadata and it is present
582 * we skip extracting libarchive NFSv4 ACLs.
583 */
584 size_t metadata_size;
585
586 if ((a->flags & ARCHIVE_EXTRACT_MAC_METADATA) == 0 ||
587 archive_entry_mac_metadata(a->entry,
588 &metadata_size) == NULL || metadata_size == 0)
589 #endif
590 #if ARCHIVE_ACL_LIBRICHACL
591 /*
592 * RichACLs are stored in an extended attribute.
593 * If we intend to extract extended attributes and have this
594 * attribute we skip extracting libarchive NFSv4 ACLs.
595 */
596 short extract_acls = 1;
597 if (a->flags & ARCHIVE_EXTRACT_XATTR && (
598 archive_entry_acl_types(a->entry) &
599 ARCHIVE_ENTRY_ACL_TYPE_NFS4)) {
600 const char *attr_name;
601 const void *attr_value;
602 size_t attr_size;
603 int i = archive_entry_xattr_reset(a->entry);
604 while (i--) {
605 archive_entry_xattr_next(a->entry, &attr_name,
606 &attr_value, &attr_size);
607 if (attr_name != NULL && attr_value != NULL &&
608 attr_size > 0 && strcmp(attr_name,
609 "trusted.richacl") == 0) {
610 extract_acls = 0;
611 break;
612 }
613 }
614 }
615 if (extract_acls)
616 #endif
617 #if ARCHIVE_ACL_DARWIN || ARCHIVE_ACL_LIBRICHACL
618 {
619 #endif
620 if (archive_entry_filetype(a->entry) == AE_IFDIR)
621 a->deferred |= TODO_ACLS;
622 else
623 a->todo |= TODO_ACLS;
624 #if ARCHIVE_ACL_DARWIN || ARCHIVE_ACL_LIBRICHACL
625 }
626 #endif
627 }
628 if (a->flags & ARCHIVE_EXTRACT_MAC_METADATA) {
629 if (archive_entry_filetype(a->entry) == AE_IFDIR)
630 a->deferred |= TODO_MAC_METADATA;
631 else
632 a->todo |= TODO_MAC_METADATA;
633 }
634 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
635 if ((a->flags & ARCHIVE_EXTRACT_NO_HFS_COMPRESSION) == 0) {
636 unsigned long set, clear;
637 archive_entry_fflags(a->entry, &set, &clear);
638 if ((set & ~clear) & UF_COMPRESSED) {
639 a->todo |= TODO_HFS_COMPRESSION;
640 a->decmpfs_block_count = (unsigned)-1;
641 }
642 }
643 if ((a->flags & ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED) != 0 &&
644 (a->mode & AE_IFMT) == AE_IFREG && a->filesize > 0) {
645 a->todo |= TODO_HFS_COMPRESSION;
646 a->decmpfs_block_count = (unsigned)-1;
647 }
648 {
649 const char *p;
650
651 /* Check if the current file name is a type of the
652 * resource fork file. */
653 p = strrchr(a->name, '/');
654 if (p == NULL)
655 p = a->name;
656 else
657 p++;
658 if (p[0] == '.' && p[1] == '_') {
659 /* Do not compress "._XXX" files. */
660 a->todo &= ~TODO_HFS_COMPRESSION;
661 if (a->filesize > 0)
662 a->todo |= TODO_APPLEDOUBLE;
663 }
664 }
665 #endif
666
667 if (a->flags & ARCHIVE_EXTRACT_XATTR) {
668 #if ARCHIVE_XATTR_DARWIN
669 /*
670 * On MacOS, extended attributes get stored in mac_metadata,
671 * too. If we intend to extract mac_metadata and it is present
672 * we skip extracting extended attributes.
673 */
674 size_t metadata_size;
675
676 if ((a->flags & ARCHIVE_EXTRACT_MAC_METADATA) == 0 ||
677 archive_entry_mac_metadata(a->entry,
678 &metadata_size) == NULL || metadata_size == 0)
679 #endif
680 a->todo |= TODO_XATTR;
681 }
682 if (a->flags & ARCHIVE_EXTRACT_FFLAGS)
683 a->todo |= TODO_FFLAGS;
684 if (a->flags & ARCHIVE_EXTRACT_SECURE_SYMLINKS) {
685 ret = check_symlinks(a);
686 if (ret != ARCHIVE_OK)
687 return (ret);
688 }
689 #if defined(HAVE_FCHDIR) && defined(PATH_MAX)
690 /* If path exceeds PATH_MAX, shorten the path. */
691 edit_deep_directories(a);
692 #endif
693
694 ret = restore_entry(a);
695
696 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
697 /*
698 * Check if the filesystem the file is restoring on supports
699 * HFS+ Compression. If not, cancel HFS+ Compression.
700 */
701 if (a->todo | TODO_HFS_COMPRESSION) {
702 /*
703 * NOTE: UF_COMPRESSED is ignored even if the filesystem
704 * supports HFS+ Compression because the file should
705 * have at least an extended attribute "com.apple.decmpfs"
706 * before the flag is set to indicate that the file have
707 * been compressed. If the filesystem does not support
708 * HFS+ Compression the system call will fail.
709 */
710 if (a->fd < 0 || fchflags(a->fd, UF_COMPRESSED) != 0)
711 a->todo &= ~TODO_HFS_COMPRESSION;
712 }
713 #endif
714
715 /*
716 * TODO: There are rumours that some extended attributes must
717 * be restored before file data is written. If this is true,
718 * then we either need to write all extended attributes both
719 * before and after restoring the data, or find some rule for
720 * determining which must go first and which last. Due to the
721 * many ways people are using xattrs, this may prove to be an
722 * intractable problem.
723 */
724
725 #ifdef HAVE_FCHDIR
726 /* If we changed directory above, restore it here. */
727 if (a->restore_pwd >= 0) {
728 r = fchdir(a->restore_pwd);
729 if (r != 0) {
730 archive_set_error(&a->archive, errno,
731 "chdir() failure");
732 ret = ARCHIVE_FATAL;
733 }
734 close(a->restore_pwd);
735 a->restore_pwd = -1;
736 }
737 #endif
738
739 /*
740 * Fixup uses the unedited pathname from archive_entry_pathname(),
741 * because it is relative to the base dir and the edited path
742 * might be relative to some intermediate dir as a result of the
743 * deep restore logic.
744 */
745 if (a->deferred & TODO_MODE) {
746 fe = current_fixup(a, archive_entry_pathname(entry));
747 if (fe == NULL)
748 return (ARCHIVE_FATAL);
749 fe->fixup |= TODO_MODE_BASE;
750 fe->mode = a->mode;
751 }
752
753 if ((a->deferred & TODO_TIMES)
754 && (archive_entry_mtime_is_set(entry)
755 || archive_entry_atime_is_set(entry))) {
756 fe = current_fixup(a, archive_entry_pathname(entry));
757 if (fe == NULL)
758 return (ARCHIVE_FATAL);
759 fe->mode = a->mode;
760 fe->fixup |= TODO_TIMES;
761 if (archive_entry_atime_is_set(entry)) {
762 fe->atime = archive_entry_atime(entry);
763 fe->atime_nanos = archive_entry_atime_nsec(entry);
764 } else {
765 /* If atime is unset, use start time. */
766 fe->atime = a->start_time;
767 fe->atime_nanos = 0;
768 }
769 if (archive_entry_mtime_is_set(entry)) {
770 fe->mtime = archive_entry_mtime(entry);
771 fe->mtime_nanos = archive_entry_mtime_nsec(entry);
772 } else {
773 /* If mtime is unset, use start time. */
774 fe->mtime = a->start_time;
775 fe->mtime_nanos = 0;
776 }
777 if (archive_entry_birthtime_is_set(entry)) {
778 fe->birthtime = archive_entry_birthtime(entry);
779 fe->birthtime_nanos = archive_entry_birthtime_nsec(
780 entry);
781 } else {
782 /* If birthtime is unset, use mtime. */
783 fe->birthtime = fe->mtime;
784 fe->birthtime_nanos = fe->mtime_nanos;
785 }
786 }
787
788 if (a->deferred & TODO_ACLS) {
789 fe = current_fixup(a, archive_entry_pathname(entry));
790 if (fe == NULL)
791 return (ARCHIVE_FATAL);
792 fe->fixup |= TODO_ACLS;
793 archive_acl_copy(&fe->acl, archive_entry_acl(entry));
794 }
795
796 if (a->deferred & TODO_MAC_METADATA) {
797 const void *metadata;
798 size_t metadata_size;
799 metadata = archive_entry_mac_metadata(a->entry, &metadata_size);
800 if (metadata != NULL && metadata_size > 0) {
801 fe = current_fixup(a, archive_entry_pathname(entry));
802 if (fe == NULL)
803 return (ARCHIVE_FATAL);
804 fe->mac_metadata = malloc(metadata_size);
805 if (fe->mac_metadata != NULL) {
806 memcpy(fe->mac_metadata, metadata,
807 metadata_size);
808 fe->mac_metadata_size = metadata_size;
809 fe->fixup |= TODO_MAC_METADATA;
810 }
811 }
812 }
813
814 if (a->deferred & TODO_FFLAGS) {
815 fe = current_fixup(a, archive_entry_pathname(entry));
816 if (fe == NULL)
817 return (ARCHIVE_FATAL);
818 fe->fixup |= TODO_FFLAGS;
819 /* TODO: Complete this.. defer fflags from below. */
820 }
821
822 /* We've created the object and are ready to pour data into it. */
823 if (ret >= ARCHIVE_WARN)
824 a->archive.state = ARCHIVE_STATE_DATA;
825 /*
826 * If it's not open, tell our client not to try writing.
827 * In particular, dirs, links, etc, don't get written to.
828 */
829 if (a->fd < 0) {
830 archive_entry_set_size(entry, 0);
831 a->filesize = 0;
832 }
833
834 return (ret);
835 }
836
837 int
archive_write_disk_set_skip_file(struct archive * _a,la_int64_t d,la_int64_t i)838 archive_write_disk_set_skip_file(struct archive *_a, la_int64_t d, la_int64_t i)
839 {
840 struct archive_write_disk *a = (struct archive_write_disk *)_a;
841 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
842 ARCHIVE_STATE_ANY, "archive_write_disk_set_skip_file");
843 a->skip_file_set = 1;
844 a->skip_file_dev = d;
845 a->skip_file_ino = i;
846 return (ARCHIVE_OK);
847 }
848
849 static ssize_t
write_data_block(struct archive_write_disk * a,const char * buff,size_t size)850 write_data_block(struct archive_write_disk *a, const char *buff, size_t size)
851 {
852 uint64_t start_size = size;
853 ssize_t bytes_written = 0;
854 ssize_t block_size = 0, bytes_to_write;
855
856 if (size == 0)
857 return (ARCHIVE_OK);
858
859 if (a->filesize == 0 || a->fd < 0) {
860 archive_set_error(&a->archive, 0,
861 "Attempt to write to an empty file");
862 return (ARCHIVE_WARN);
863 }
864
865 if (a->flags & ARCHIVE_EXTRACT_SPARSE) {
866 #if HAVE_STRUCT_STAT_ST_BLKSIZE
867 int r;
868 if ((r = lazy_stat(a)) != ARCHIVE_OK)
869 return (r);
870 block_size = a->pst->st_blksize;
871 #else
872 /* XXX TODO XXX Is there a more appropriate choice here ? */
873 /* This needn't match the filesystem allocation size. */
874 block_size = 16*1024;
875 #endif
876 }
877
878 /* If this write would run beyond the file size, truncate it. */
879 if (a->filesize >= 0 && (int64_t)(a->offset + size) > a->filesize)
880 start_size = size = (size_t)(a->filesize - a->offset);
881
882 /* Write the data. */
883 while (size > 0) {
884 if (block_size == 0) {
885 bytes_to_write = size;
886 } else {
887 /* We're sparsifying the file. */
888 const char *p, *end;
889 int64_t block_end;
890
891 /* Skip leading zero bytes. */
892 for (p = buff, end = buff + size; p < end; ++p) {
893 if (*p != '\0')
894 break;
895 }
896 a->offset += p - buff;
897 size -= p - buff;
898 buff = p;
899 if (size == 0)
900 break;
901
902 /* Calculate next block boundary after offset. */
903 block_end
904 = (a->offset / block_size + 1) * block_size;
905
906 /* If the adjusted write would cross block boundary,
907 * truncate it to the block boundary. */
908 bytes_to_write = size;
909 if (a->offset + bytes_to_write > block_end)
910 bytes_to_write = block_end - a->offset;
911 }
912 /* Seek if necessary to the specified offset. */
913 if (a->offset != a->fd_offset) {
914 if (lseek(a->fd, a->offset, SEEK_SET) < 0) {
915 archive_set_error(&a->archive, errno,
916 "Seek failed");
917 return (ARCHIVE_FATAL);
918 }
919 a->fd_offset = a->offset;
920 }
921 bytes_written = write(a->fd, buff, bytes_to_write);
922 if (bytes_written < 0) {
923 archive_set_error(&a->archive, errno, "Write failed");
924 return (ARCHIVE_WARN);
925 }
926 buff += bytes_written;
927 size -= bytes_written;
928 a->total_bytes_written += bytes_written;
929 a->offset += bytes_written;
930 a->fd_offset = a->offset;
931 }
932 return (start_size - size);
933 }
934
935 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_SYS_XATTR_H)\
936 && defined(HAVE_ZLIB_H)
937
938 /*
939 * Set UF_COMPRESSED file flag.
940 * This have to be called after hfs_write_decmpfs() because if the
941 * file does not have "com.apple.decmpfs" xattr the flag is ignored.
942 */
943 static int
hfs_set_compressed_fflag(struct archive_write_disk * a)944 hfs_set_compressed_fflag(struct archive_write_disk *a)
945 {
946 int r;
947
948 if ((r = lazy_stat(a)) != ARCHIVE_OK)
949 return (r);
950
951 a->st.st_flags |= UF_COMPRESSED;
952 if (fchflags(a->fd, a->st.st_flags) != 0) {
953 archive_set_error(&a->archive, errno,
954 "Failed to set UF_COMPRESSED file flag");
955 return (ARCHIVE_WARN);
956 }
957 return (ARCHIVE_OK);
958 }
959
960 /*
961 * HFS+ Compression decmpfs
962 *
963 * +------------------------------+ +0
964 * | Magic(LE 4 bytes) |
965 * +------------------------------+
966 * | Type(LE 4 bytes) |
967 * +------------------------------+
968 * | Uncompressed size(LE 8 bytes)|
969 * +------------------------------+ +16
970 * | |
971 * | Compressed data |
972 * | (Placed only if Type == 3) |
973 * | |
974 * +------------------------------+ +3802 = MAX_DECMPFS_XATTR_SIZE
975 *
976 * Type is 3: decmpfs has compressed data.
977 * Type is 4: Resource Fork has compressed data.
978 */
979 /*
980 * Write "com.apple.decmpfs"
981 */
982 static int
hfs_write_decmpfs(struct archive_write_disk * a)983 hfs_write_decmpfs(struct archive_write_disk *a)
984 {
985 int r;
986 uint32_t compression_type;
987
988 r = fsetxattr(a->fd, DECMPFS_XATTR_NAME, a->decmpfs_header_p,
989 a->decmpfs_attr_size, 0, 0);
990 if (r < 0) {
991 archive_set_error(&a->archive, errno,
992 "Cannot restore xattr:%s", DECMPFS_XATTR_NAME);
993 compression_type = archive_le32dec(
994 &a->decmpfs_header_p[DECMPFS_COMPRESSION_TYPE]);
995 if (compression_type == CMP_RESOURCE_FORK)
996 fremovexattr(a->fd, XATTR_RESOURCEFORK_NAME,
997 XATTR_SHOWCOMPRESSION);
998 return (ARCHIVE_WARN);
999 }
1000 return (ARCHIVE_OK);
1001 }
1002
1003 /*
1004 * HFS+ Compression Resource Fork
1005 *
1006 * +-----------------------------+
1007 * | Header(260 bytes) |
1008 * +-----------------------------+
1009 * | Block count(LE 4 bytes) |
1010 * +-----------------------------+ --+
1011 * +-- | Offset (LE 4 bytes) | |
1012 * | | [distance from Block count] | | Block 0
1013 * | +-----------------------------+ |
1014 * | | Compressed size(LE 4 bytes) | |
1015 * | +-----------------------------+ --+
1016 * | | |
1017 * | | .................. |
1018 * | | |
1019 * | +-----------------------------+ --+
1020 * | | Offset (LE 4 bytes) | |
1021 * | +-----------------------------+ | Block (Block count -1)
1022 * | | Compressed size(LE 4 bytes) | |
1023 * +-> +-----------------------------+ --+
1024 * | Compressed data(n bytes) | Block 0
1025 * +-----------------------------+
1026 * | |
1027 * | .................. |
1028 * | |
1029 * +-----------------------------+
1030 * | Compressed data(n bytes) | Block (Block count -1)
1031 * +-----------------------------+
1032 * | Footer(50 bytes) |
1033 * +-----------------------------+
1034 *
1035 */
1036 /*
1037 * Write the header of "com.apple.ResourceFork"
1038 */
1039 static int
hfs_write_resource_fork(struct archive_write_disk * a,unsigned char * buff,size_t bytes,uint32_t position)1040 hfs_write_resource_fork(struct archive_write_disk *a, unsigned char *buff,
1041 size_t bytes, uint32_t position)
1042 {
1043 int ret;
1044
1045 ret = fsetxattr(a->fd, XATTR_RESOURCEFORK_NAME, buff, bytes,
1046 position, a->rsrc_xattr_options);
1047 if (ret < 0) {
1048 archive_set_error(&a->archive, errno,
1049 "Cannot restore xattr: %s at %u pos %u bytes",
1050 XATTR_RESOURCEFORK_NAME,
1051 (unsigned)position,
1052 (unsigned)bytes);
1053 return (ARCHIVE_WARN);
1054 }
1055 a->rsrc_xattr_options &= ~XATTR_CREATE;
1056 return (ARCHIVE_OK);
1057 }
1058
1059 static int
hfs_write_compressed_data(struct archive_write_disk * a,size_t bytes_compressed)1060 hfs_write_compressed_data(struct archive_write_disk *a, size_t bytes_compressed)
1061 {
1062 int ret;
1063
1064 ret = hfs_write_resource_fork(a, a->compressed_buffer,
1065 bytes_compressed, a->compressed_rsrc_position);
1066 if (ret == ARCHIVE_OK)
1067 a->compressed_rsrc_position += bytes_compressed;
1068 return (ret);
1069 }
1070
1071 static int
hfs_write_resource_fork_header(struct archive_write_disk * a)1072 hfs_write_resource_fork_header(struct archive_write_disk *a)
1073 {
1074 unsigned char *buff;
1075 uint32_t rsrc_bytes;
1076 uint32_t rsrc_header_bytes;
1077
1078 /*
1079 * Write resource fork header + block info.
1080 */
1081 buff = a->resource_fork;
1082 rsrc_bytes = a->compressed_rsrc_position - RSRC_F_SIZE;
1083 rsrc_header_bytes =
1084 RSRC_H_SIZE + /* Header base size. */
1085 4 + /* Block count. */
1086 (a->decmpfs_block_count * 8);/* Block info */
1087 archive_be32enc(buff, 0x100);
1088 archive_be32enc(buff + 4, rsrc_bytes);
1089 archive_be32enc(buff + 8, rsrc_bytes - 256);
1090 archive_be32enc(buff + 12, 0x32);
1091 memset(buff + 16, 0, 240);
1092 archive_be32enc(buff + 256, rsrc_bytes - 260);
1093 return hfs_write_resource_fork(a, buff, rsrc_header_bytes, 0);
1094 }
1095
1096 static size_t
hfs_set_resource_fork_footer(unsigned char * buff,size_t buff_size)1097 hfs_set_resource_fork_footer(unsigned char *buff, size_t buff_size)
1098 {
1099 static const char rsrc_footer[RSRC_F_SIZE] = {
1100 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1101 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1102 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1103 0x00, 0x1c, 0x00, 0x32, 0x00, 0x00, 'c', 'm',
1104 'p', 'f', 0x00, 0x00, 0x00, 0x0a, 0x00, 0x01,
1105 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1106 0x00, 0x00
1107 };
1108 if (buff_size < sizeof(rsrc_footer))
1109 return (0);
1110 memcpy(buff, rsrc_footer, sizeof(rsrc_footer));
1111 return (sizeof(rsrc_footer));
1112 }
1113
1114 static int
hfs_reset_compressor(struct archive_write_disk * a)1115 hfs_reset_compressor(struct archive_write_disk *a)
1116 {
1117 int ret;
1118
1119 if (a->stream_valid)
1120 ret = deflateReset(&a->stream);
1121 else
1122 ret = deflateInit(&a->stream, a->decmpfs_compression_level);
1123
1124 if (ret != Z_OK) {
1125 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1126 "Failed to initialize compressor");
1127 return (ARCHIVE_FATAL);
1128 } else
1129 a->stream_valid = 1;
1130
1131 return (ARCHIVE_OK);
1132 }
1133
1134 static int
hfs_decompress(struct archive_write_disk * a)1135 hfs_decompress(struct archive_write_disk *a)
1136 {
1137 uint32_t *block_info;
1138 unsigned int block_count;
1139 uint32_t data_pos, data_size;
1140 ssize_t r;
1141 ssize_t bytes_written, bytes_to_write;
1142 unsigned char *b;
1143
1144 block_info = (uint32_t *)(a->resource_fork + RSRC_H_SIZE);
1145 block_count = archive_le32dec(block_info++);
1146 while (block_count--) {
1147 data_pos = RSRC_H_SIZE + archive_le32dec(block_info++);
1148 data_size = archive_le32dec(block_info++);
1149 r = fgetxattr(a->fd, XATTR_RESOURCEFORK_NAME,
1150 a->compressed_buffer, data_size, data_pos, 0);
1151 if (r != data_size) {
1152 archive_set_error(&a->archive,
1153 (r < 0)?errno:ARCHIVE_ERRNO_MISC,
1154 "Failed to read resource fork");
1155 return (ARCHIVE_WARN);
1156 }
1157 if (a->compressed_buffer[0] == 0xff) {
1158 bytes_to_write = data_size -1;
1159 b = a->compressed_buffer + 1;
1160 } else {
1161 uLong dest_len = MAX_DECMPFS_BLOCK_SIZE;
1162 int zr;
1163
1164 zr = uncompress((Bytef *)a->uncompressed_buffer,
1165 &dest_len, a->compressed_buffer, data_size);
1166 if (zr != Z_OK) {
1167 archive_set_error(&a->archive,
1168 ARCHIVE_ERRNO_MISC,
1169 "Failed to decompress resource fork");
1170 return (ARCHIVE_WARN);
1171 }
1172 bytes_to_write = dest_len;
1173 b = (unsigned char *)a->uncompressed_buffer;
1174 }
1175 do {
1176 bytes_written = write(a->fd, b, bytes_to_write);
1177 if (bytes_written < 0) {
1178 archive_set_error(&a->archive, errno,
1179 "Write failed");
1180 return (ARCHIVE_WARN);
1181 }
1182 bytes_to_write -= bytes_written;
1183 b += bytes_written;
1184 } while (bytes_to_write > 0);
1185 }
1186 r = fremovexattr(a->fd, XATTR_RESOURCEFORK_NAME, 0);
1187 if (r == -1) {
1188 archive_set_error(&a->archive, errno,
1189 "Failed to remove resource fork");
1190 return (ARCHIVE_WARN);
1191 }
1192 return (ARCHIVE_OK);
1193 }
1194
1195 static int
hfs_drive_compressor(struct archive_write_disk * a,const char * buff,size_t size)1196 hfs_drive_compressor(struct archive_write_disk *a, const char *buff,
1197 size_t size)
1198 {
1199 unsigned char *buffer_compressed;
1200 size_t bytes_compressed;
1201 size_t bytes_used;
1202 int ret;
1203
1204 ret = hfs_reset_compressor(a);
1205 if (ret != ARCHIVE_OK)
1206 return (ret);
1207
1208 if (a->compressed_buffer == NULL) {
1209 size_t block_size;
1210
1211 block_size = COMPRESSED_W_SIZE + RSRC_F_SIZE +
1212 + compressBound(MAX_DECMPFS_BLOCK_SIZE);
1213 a->compressed_buffer = malloc(block_size);
1214 if (a->compressed_buffer == NULL) {
1215 archive_set_error(&a->archive, ENOMEM,
1216 "Can't allocate memory for Resource Fork");
1217 return (ARCHIVE_FATAL);
1218 }
1219 a->compressed_buffer_size = block_size;
1220 a->compressed_buffer_remaining = block_size;
1221 }
1222
1223 buffer_compressed = a->compressed_buffer +
1224 a->compressed_buffer_size - a->compressed_buffer_remaining;
1225 a->stream.next_in = (Bytef *)(uintptr_t)(const void *)buff;
1226 a->stream.avail_in = size;
1227 a->stream.next_out = buffer_compressed;
1228 a->stream.avail_out = a->compressed_buffer_remaining;
1229 do {
1230 ret = deflate(&a->stream, Z_FINISH);
1231 switch (ret) {
1232 case Z_OK:
1233 case Z_STREAM_END:
1234 break;
1235 default:
1236 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1237 "Failed to compress data");
1238 return (ARCHIVE_FAILED);
1239 }
1240 } while (ret == Z_OK);
1241 bytes_compressed = a->compressed_buffer_remaining - a->stream.avail_out;
1242
1243 /*
1244 * If the compressed size is larger than the original size,
1245 * throw away compressed data, use uncompressed data instead.
1246 */
1247 if (bytes_compressed > size) {
1248 buffer_compressed[0] = 0xFF;/* uncompressed marker. */
1249 memcpy(buffer_compressed + 1, buff, size);
1250 bytes_compressed = size + 1;
1251 }
1252 a->compressed_buffer_remaining -= bytes_compressed;
1253
1254 /*
1255 * If the compressed size is smaller than MAX_DECMPFS_XATTR_SIZE
1256 * and the block count in the file is only one, store compressed
1257 * data to decmpfs xattr instead of the resource fork.
1258 */
1259 if (a->decmpfs_block_count == 1 &&
1260 (a->decmpfs_attr_size + bytes_compressed)
1261 <= MAX_DECMPFS_XATTR_SIZE) {
1262 archive_le32enc(&a->decmpfs_header_p[DECMPFS_COMPRESSION_TYPE],
1263 CMP_XATTR);
1264 memcpy(a->decmpfs_header_p + DECMPFS_HEADER_SIZE,
1265 buffer_compressed, bytes_compressed);
1266 a->decmpfs_attr_size += bytes_compressed;
1267 a->compressed_buffer_remaining = a->compressed_buffer_size;
1268 /*
1269 * Finish HFS+ Compression.
1270 * - Write the decmpfs xattr.
1271 * - Set the UF_COMPRESSED file flag.
1272 */
1273 ret = hfs_write_decmpfs(a);
1274 if (ret == ARCHIVE_OK)
1275 ret = hfs_set_compressed_fflag(a);
1276 return (ret);
1277 }
1278
1279 /* Update block info. */
1280 archive_le32enc(a->decmpfs_block_info++,
1281 a->compressed_rsrc_position_v - RSRC_H_SIZE);
1282 archive_le32enc(a->decmpfs_block_info++, bytes_compressed);
1283 a->compressed_rsrc_position_v += bytes_compressed;
1284
1285 /*
1286 * Write the compressed data to the resource fork.
1287 */
1288 bytes_used = a->compressed_buffer_size - a->compressed_buffer_remaining;
1289 while (bytes_used >= COMPRESSED_W_SIZE) {
1290 ret = hfs_write_compressed_data(a, COMPRESSED_W_SIZE);
1291 if (ret != ARCHIVE_OK)
1292 return (ret);
1293 bytes_used -= COMPRESSED_W_SIZE;
1294 if (bytes_used > COMPRESSED_W_SIZE)
1295 memmove(a->compressed_buffer,
1296 a->compressed_buffer + COMPRESSED_W_SIZE,
1297 bytes_used);
1298 else
1299 memcpy(a->compressed_buffer,
1300 a->compressed_buffer + COMPRESSED_W_SIZE,
1301 bytes_used);
1302 }
1303 a->compressed_buffer_remaining = a->compressed_buffer_size - bytes_used;
1304
1305 /*
1306 * If the current block is the last block, write the remaining
1307 * compressed data and the resource fork footer.
1308 */
1309 if (a->file_remaining_bytes == 0) {
1310 size_t rsrc_size;
1311 int64_t bk;
1312
1313 /* Append the resource footer. */
1314 rsrc_size = hfs_set_resource_fork_footer(
1315 a->compressed_buffer + bytes_used,
1316 a->compressed_buffer_remaining);
1317 ret = hfs_write_compressed_data(a, bytes_used + rsrc_size);
1318 a->compressed_buffer_remaining = a->compressed_buffer_size;
1319
1320 /* If the compressed size is not enough smaller than
1321 * the uncompressed size. cancel HFS+ compression.
1322 * TODO: study a behavior of ditto utility and improve
1323 * the condition to fall back into no HFS+ compression. */
1324 bk = HFS_BLOCKS(a->compressed_rsrc_position);
1325 bk += bk >> 7;
1326 if (bk > HFS_BLOCKS(a->filesize))
1327 return hfs_decompress(a);
1328 /*
1329 * Write the resourcefork header.
1330 */
1331 if (ret == ARCHIVE_OK)
1332 ret = hfs_write_resource_fork_header(a);
1333 /*
1334 * Finish HFS+ Compression.
1335 * - Write the decmpfs xattr.
1336 * - Set the UF_COMPRESSED file flag.
1337 */
1338 if (ret == ARCHIVE_OK)
1339 ret = hfs_write_decmpfs(a);
1340 if (ret == ARCHIVE_OK)
1341 ret = hfs_set_compressed_fflag(a);
1342 }
1343 return (ret);
1344 }
1345
1346 static ssize_t
hfs_write_decmpfs_block(struct archive_write_disk * a,const char * buff,size_t size)1347 hfs_write_decmpfs_block(struct archive_write_disk *a, const char *buff,
1348 size_t size)
1349 {
1350 const char *buffer_to_write;
1351 size_t bytes_to_write;
1352 int ret;
1353
1354 if (a->decmpfs_block_count == (unsigned)-1) {
1355 void *new_block;
1356 size_t new_size;
1357 unsigned int block_count;
1358
1359 if (a->decmpfs_header_p == NULL) {
1360 new_block = malloc(MAX_DECMPFS_XATTR_SIZE
1361 + sizeof(uint32_t));
1362 if (new_block == NULL) {
1363 archive_set_error(&a->archive, ENOMEM,
1364 "Can't allocate memory for decmpfs");
1365 return (ARCHIVE_FATAL);
1366 }
1367 a->decmpfs_header_p = new_block;
1368 }
1369 a->decmpfs_attr_size = DECMPFS_HEADER_SIZE;
1370 archive_le32enc(&a->decmpfs_header_p[DECMPFS_COMPRESSION_MAGIC],
1371 DECMPFS_MAGIC);
1372 archive_le32enc(&a->decmpfs_header_p[DECMPFS_COMPRESSION_TYPE],
1373 CMP_RESOURCE_FORK);
1374 archive_le64enc(&a->decmpfs_header_p[DECMPFS_UNCOMPRESSED_SIZE],
1375 a->filesize);
1376
1377 /* Calculate a block count of the file. */
1378 block_count =
1379 (a->filesize + MAX_DECMPFS_BLOCK_SIZE -1) /
1380 MAX_DECMPFS_BLOCK_SIZE;
1381 /*
1382 * Allocate buffer for resource fork.
1383 * Set up related pointers;
1384 */
1385 new_size =
1386 RSRC_H_SIZE + /* header */
1387 4 + /* Block count */
1388 (block_count * sizeof(uint32_t) * 2) +
1389 RSRC_F_SIZE; /* footer */
1390 if (new_size > a->resource_fork_allocated_size) {
1391 new_block = realloc(a->resource_fork, new_size);
1392 if (new_block == NULL) {
1393 archive_set_error(&a->archive, ENOMEM,
1394 "Can't allocate memory for ResourceFork");
1395 return (ARCHIVE_FATAL);
1396 }
1397 a->resource_fork_allocated_size = new_size;
1398 a->resource_fork = new_block;
1399 }
1400
1401 /* Allocate uncompressed buffer */
1402 if (a->uncompressed_buffer == NULL) {
1403 new_block = malloc(MAX_DECMPFS_BLOCK_SIZE);
1404 if (new_block == NULL) {
1405 archive_set_error(&a->archive, ENOMEM,
1406 "Can't allocate memory for decmpfs");
1407 return (ARCHIVE_FATAL);
1408 }
1409 a->uncompressed_buffer = new_block;
1410 }
1411 a->block_remaining_bytes = MAX_DECMPFS_BLOCK_SIZE;
1412 a->file_remaining_bytes = a->filesize;
1413 a->compressed_buffer_remaining = a->compressed_buffer_size;
1414
1415 /*
1416 * Set up a resource fork.
1417 */
1418 a->rsrc_xattr_options = XATTR_CREATE;
1419 /* Get the position where we are going to set a bunch
1420 * of block info. */
1421 a->decmpfs_block_info =
1422 (uint32_t *)(a->resource_fork + RSRC_H_SIZE);
1423 /* Set the block count to the resource fork. */
1424 archive_le32enc(a->decmpfs_block_info++, block_count);
1425 /* Get the position where we are going to set compressed
1426 * data. */
1427 a->compressed_rsrc_position =
1428 RSRC_H_SIZE + 4 + (block_count * 8);
1429 a->compressed_rsrc_position_v = a->compressed_rsrc_position;
1430 a->decmpfs_block_count = block_count;
1431 }
1432
1433 /* Ignore redundant bytes. */
1434 if (a->file_remaining_bytes == 0)
1435 return ((ssize_t)size);
1436
1437 /* Do not overrun a block size. */
1438 if (size > a->block_remaining_bytes)
1439 bytes_to_write = a->block_remaining_bytes;
1440 else
1441 bytes_to_write = size;
1442 /* Do not overrun the file size. */
1443 if (bytes_to_write > a->file_remaining_bytes)
1444 bytes_to_write = a->file_remaining_bytes;
1445
1446 /* For efficiency, if a copy length is full of the uncompressed
1447 * buffer size, do not copy writing data to it. */
1448 if (bytes_to_write == MAX_DECMPFS_BLOCK_SIZE)
1449 buffer_to_write = buff;
1450 else {
1451 memcpy(a->uncompressed_buffer +
1452 MAX_DECMPFS_BLOCK_SIZE - a->block_remaining_bytes,
1453 buff, bytes_to_write);
1454 buffer_to_write = a->uncompressed_buffer;
1455 }
1456 a->block_remaining_bytes -= bytes_to_write;
1457 a->file_remaining_bytes -= bytes_to_write;
1458
1459 if (a->block_remaining_bytes == 0 || a->file_remaining_bytes == 0) {
1460 ret = hfs_drive_compressor(a, buffer_to_write,
1461 MAX_DECMPFS_BLOCK_SIZE - a->block_remaining_bytes);
1462 if (ret < 0)
1463 return (ret);
1464 a->block_remaining_bytes = MAX_DECMPFS_BLOCK_SIZE;
1465 }
1466 /* Ignore redundant bytes. */
1467 if (a->file_remaining_bytes == 0)
1468 return ((ssize_t)size);
1469 return (bytes_to_write);
1470 }
1471
1472 static ssize_t
hfs_write_data_block(struct archive_write_disk * a,const char * buff,size_t size)1473 hfs_write_data_block(struct archive_write_disk *a, const char *buff,
1474 size_t size)
1475 {
1476 uint64_t start_size = size;
1477 ssize_t bytes_written = 0;
1478 ssize_t bytes_to_write;
1479
1480 if (size == 0)
1481 return (ARCHIVE_OK);
1482
1483 if (a->filesize == 0 || a->fd < 0) {
1484 archive_set_error(&a->archive, 0,
1485 "Attempt to write to an empty file");
1486 return (ARCHIVE_WARN);
1487 }
1488
1489 /* If this write would run beyond the file size, truncate it. */
1490 if (a->filesize >= 0 && (int64_t)(a->offset + size) > a->filesize)
1491 start_size = size = (size_t)(a->filesize - a->offset);
1492
1493 /* Write the data. */
1494 while (size > 0) {
1495 bytes_to_write = size;
1496 /* Seek if necessary to the specified offset. */
1497 if (a->offset < a->fd_offset) {
1498 /* Can't support backward move. */
1499 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1500 "Seek failed");
1501 return (ARCHIVE_FATAL);
1502 } else if (a->offset > a->fd_offset) {
1503 int64_t skip = a->offset - a->fd_offset;
1504 char nullblock[1024];
1505
1506 memset(nullblock, 0, sizeof(nullblock));
1507 while (skip > 0) {
1508 if (skip > (int64_t)sizeof(nullblock))
1509 bytes_written = hfs_write_decmpfs_block(
1510 a, nullblock, sizeof(nullblock));
1511 else
1512 bytes_written = hfs_write_decmpfs_block(
1513 a, nullblock, skip);
1514 if (bytes_written < 0) {
1515 archive_set_error(&a->archive, errno,
1516 "Write failed");
1517 return (ARCHIVE_WARN);
1518 }
1519 skip -= bytes_written;
1520 }
1521
1522 a->fd_offset = a->offset;
1523 }
1524 bytes_written =
1525 hfs_write_decmpfs_block(a, buff, bytes_to_write);
1526 if (bytes_written < 0)
1527 return (bytes_written);
1528 buff += bytes_written;
1529 size -= bytes_written;
1530 a->total_bytes_written += bytes_written;
1531 a->offset += bytes_written;
1532 a->fd_offset = a->offset;
1533 }
1534 return (start_size - size);
1535 }
1536 #else
1537 static ssize_t
hfs_write_data_block(struct archive_write_disk * a,const char * buff,size_t size)1538 hfs_write_data_block(struct archive_write_disk *a, const char *buff,
1539 size_t size)
1540 {
1541 return (write_data_block(a, buff, size));
1542 }
1543 #endif
1544
1545 static ssize_t
_archive_write_disk_data_block(struct archive * _a,const void * buff,size_t size,int64_t offset)1546 _archive_write_disk_data_block(struct archive *_a,
1547 const void *buff, size_t size, int64_t offset)
1548 {
1549 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1550 ssize_t r;
1551
1552 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1553 ARCHIVE_STATE_DATA, "archive_write_data_block");
1554
1555 a->offset = offset;
1556 if (a->todo & TODO_HFS_COMPRESSION)
1557 r = hfs_write_data_block(a, buff, size);
1558 else
1559 r = write_data_block(a, buff, size);
1560 if (r < ARCHIVE_OK)
1561 return (r);
1562 if ((size_t)r < size) {
1563 archive_set_error(&a->archive, 0,
1564 "Too much data: Truncating file at %ju bytes",
1565 (uintmax_t)a->filesize);
1566 return (ARCHIVE_WARN);
1567 }
1568 #if ARCHIVE_VERSION_NUMBER < 3999000
1569 return (ARCHIVE_OK);
1570 #else
1571 return (size);
1572 #endif
1573 }
1574
1575 static ssize_t
_archive_write_disk_data(struct archive * _a,const void * buff,size_t size)1576 _archive_write_disk_data(struct archive *_a, const void *buff, size_t size)
1577 {
1578 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1579
1580 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1581 ARCHIVE_STATE_DATA, "archive_write_data");
1582
1583 if (a->todo & TODO_HFS_COMPRESSION)
1584 return (hfs_write_data_block(a, buff, size));
1585 return (write_data_block(a, buff, size));
1586 }
1587
1588 static int
_archive_write_disk_finish_entry(struct archive * _a)1589 _archive_write_disk_finish_entry(struct archive *_a)
1590 {
1591 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1592 int ret = ARCHIVE_OK;
1593
1594 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1595 ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
1596 "archive_write_finish_entry");
1597 if (a->archive.state & ARCHIVE_STATE_HEADER)
1598 return (ARCHIVE_OK);
1599 archive_clear_error(&a->archive);
1600
1601 /* Pad or truncate file to the right size. */
1602 if (a->fd < 0) {
1603 /* There's no file. */
1604 } else if (a->filesize < 0) {
1605 /* File size is unknown, so we can't set the size. */
1606 } else if (a->fd_offset == a->filesize) {
1607 /* Last write ended at exactly the filesize; we're done. */
1608 /* Hopefully, this is the common case. */
1609 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_ZLIB_H)
1610 } else if (a->todo & TODO_HFS_COMPRESSION) {
1611 char null_d[1024];
1612 ssize_t r;
1613
1614 if (a->file_remaining_bytes)
1615 memset(null_d, 0, sizeof(null_d));
1616 while (a->file_remaining_bytes) {
1617 if (a->file_remaining_bytes > sizeof(null_d))
1618 r = hfs_write_data_block(
1619 a, null_d, sizeof(null_d));
1620 else
1621 r = hfs_write_data_block(
1622 a, null_d, a->file_remaining_bytes);
1623 if (r < 0)
1624 return ((int)r);
1625 }
1626 #endif
1627 } else {
1628 #if HAVE_FTRUNCATE
1629 if (ftruncate(a->fd, a->filesize) == -1 &&
1630 a->filesize == 0) {
1631 archive_set_error(&a->archive, errno,
1632 "File size could not be restored");
1633 return (ARCHIVE_FAILED);
1634 }
1635 #endif
1636 /*
1637 * Not all platforms implement the XSI option to
1638 * extend files via ftruncate. Stat() the file again
1639 * to see what happened.
1640 */
1641 a->pst = NULL;
1642 if ((ret = lazy_stat(a)) != ARCHIVE_OK)
1643 return (ret);
1644 /* We can use lseek()/write() to extend the file if
1645 * ftruncate didn't work or isn't available. */
1646 if (a->st.st_size < a->filesize) {
1647 const char nul = '\0';
1648 if (lseek(a->fd, a->filesize - 1, SEEK_SET) < 0) {
1649 archive_set_error(&a->archive, errno,
1650 "Seek failed");
1651 return (ARCHIVE_FATAL);
1652 }
1653 if (write(a->fd, &nul, 1) < 0) {
1654 archive_set_error(&a->archive, errno,
1655 "Write to restore size failed");
1656 return (ARCHIVE_FATAL);
1657 }
1658 a->pst = NULL;
1659 }
1660 }
1661
1662 /* Restore metadata. */
1663
1664 /*
1665 * This is specific to Mac OS X.
1666 * If the current file is an AppleDouble file, it should be
1667 * linked with the data fork file and remove it.
1668 */
1669 if (a->todo & TODO_APPLEDOUBLE) {
1670 int r2 = fixup_appledouble(a, a->name);
1671 if (r2 == ARCHIVE_EOF) {
1672 /* The current file has been successfully linked
1673 * with the data fork file and removed. So there
1674 * is nothing to do on the current file. */
1675 goto finish_metadata;
1676 }
1677 if (r2 < ret) ret = r2;
1678 }
1679
1680 /*
1681 * Look up the "real" UID only if we're going to need it.
1682 * TODO: the TODO_SGID condition can be dropped here, can't it?
1683 */
1684 if (a->todo & (TODO_OWNER | TODO_SUID | TODO_SGID)) {
1685 a->uid = archive_write_disk_uid(&a->archive,
1686 archive_entry_uname(a->entry),
1687 archive_entry_uid(a->entry));
1688 }
1689 /* Look up the "real" GID only if we're going to need it. */
1690 /* TODO: the TODO_SUID condition can be dropped here, can't it? */
1691 if (a->todo & (TODO_OWNER | TODO_SGID | TODO_SUID)) {
1692 a->gid = archive_write_disk_gid(&a->archive,
1693 archive_entry_gname(a->entry),
1694 archive_entry_gid(a->entry));
1695 }
1696
1697 /*
1698 * Restore ownership before set_mode tries to restore suid/sgid
1699 * bits. If we set the owner, we know what it is and can skip
1700 * a stat() call to examine the ownership of the file on disk.
1701 */
1702 if (a->todo & TODO_OWNER) {
1703 int r2 = set_ownership(a);
1704 if (r2 < ret) ret = r2;
1705 }
1706
1707 /*
1708 * set_mode must precede ACLs on systems such as Solaris and
1709 * FreeBSD where setting the mode implicitly clears extended ACLs
1710 */
1711 if (a->todo & TODO_MODE) {
1712 int r2 = set_mode(a, a->mode);
1713 if (r2 < ret) ret = r2;
1714 }
1715
1716 /*
1717 * Security-related extended attributes (such as
1718 * security.capability on Linux) have to be restored last,
1719 * since they're implicitly removed by other file changes.
1720 */
1721 if (a->todo & TODO_XATTR) {
1722 int r2 = set_xattrs(a);
1723 if (r2 < ret) ret = r2;
1724 }
1725
1726 /*
1727 * Some flags prevent file modification; they must be restored after
1728 * file contents are written.
1729 */
1730 if (a->todo & TODO_FFLAGS) {
1731 int r2 = set_fflags(a);
1732 if (r2 < ret) ret = r2;
1733 }
1734
1735 /*
1736 * Time must follow most other metadata;
1737 * otherwise atime will get changed.
1738 */
1739 if (a->todo & TODO_TIMES) {
1740 int r2 = set_times_from_entry(a);
1741 if (r2 < ret) ret = r2;
1742 }
1743
1744 /*
1745 * Mac extended metadata includes ACLs.
1746 */
1747 if (a->todo & TODO_MAC_METADATA) {
1748 const void *metadata;
1749 size_t metadata_size;
1750 metadata = archive_entry_mac_metadata(a->entry, &metadata_size);
1751 if (metadata != NULL && metadata_size > 0) {
1752 int r2 = set_mac_metadata(a, archive_entry_pathname(
1753 a->entry), metadata, metadata_size);
1754 if (r2 < ret) ret = r2;
1755 }
1756 }
1757
1758 /*
1759 * ACLs must be restored after timestamps because there are
1760 * ACLs that prevent attribute changes (including time).
1761 */
1762 if (a->todo & TODO_ACLS) {
1763 int r2;
1764 r2 = archive_write_disk_set_acls(&a->archive, a->fd,
1765 archive_entry_pathname(a->entry),
1766 archive_entry_acl(a->entry),
1767 archive_entry_mode(a->entry));
1768 if (r2 < ret) ret = r2;
1769 }
1770
1771 finish_metadata:
1772 /* If there's an fd, we can close it now. */
1773 if (a->fd >= 0) {
1774 close(a->fd);
1775 a->fd = -1;
1776 }
1777 /* If there's an entry, we can release it now. */
1778 if (a->entry) {
1779 archive_entry_free(a->entry);
1780 a->entry = NULL;
1781 }
1782 a->archive.state = ARCHIVE_STATE_HEADER;
1783 return (ret);
1784 }
1785
1786 int
archive_write_disk_set_group_lookup(struct archive * _a,void * private_data,la_int64_t (* lookup_gid)(void * private,const char * gname,la_int64_t gid),void (* cleanup_gid)(void * private))1787 archive_write_disk_set_group_lookup(struct archive *_a,
1788 void *private_data,
1789 la_int64_t (*lookup_gid)(void *private, const char *gname, la_int64_t gid),
1790 void (*cleanup_gid)(void *private))
1791 {
1792 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1793 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1794 ARCHIVE_STATE_ANY, "archive_write_disk_set_group_lookup");
1795
1796 if (a->cleanup_gid != NULL && a->lookup_gid_data != NULL)
1797 (a->cleanup_gid)(a->lookup_gid_data);
1798
1799 a->lookup_gid = lookup_gid;
1800 a->cleanup_gid = cleanup_gid;
1801 a->lookup_gid_data = private_data;
1802 return (ARCHIVE_OK);
1803 }
1804
1805 int
archive_write_disk_set_user_lookup(struct archive * _a,void * private_data,int64_t (* lookup_uid)(void * private,const char * uname,int64_t uid),void (* cleanup_uid)(void * private))1806 archive_write_disk_set_user_lookup(struct archive *_a,
1807 void *private_data,
1808 int64_t (*lookup_uid)(void *private, const char *uname, int64_t uid),
1809 void (*cleanup_uid)(void *private))
1810 {
1811 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1812 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1813 ARCHIVE_STATE_ANY, "archive_write_disk_set_user_lookup");
1814
1815 if (a->cleanup_uid != NULL && a->lookup_uid_data != NULL)
1816 (a->cleanup_uid)(a->lookup_uid_data);
1817
1818 a->lookup_uid = lookup_uid;
1819 a->cleanup_uid = cleanup_uid;
1820 a->lookup_uid_data = private_data;
1821 return (ARCHIVE_OK);
1822 }
1823
1824 int64_t
archive_write_disk_gid(struct archive * _a,const char * name,la_int64_t id)1825 archive_write_disk_gid(struct archive *_a, const char *name, la_int64_t id)
1826 {
1827 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1828 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1829 ARCHIVE_STATE_ANY, "archive_write_disk_gid");
1830 if (a->lookup_gid)
1831 return (a->lookup_gid)(a->lookup_gid_data, name, id);
1832 return (id);
1833 }
1834
1835 int64_t
archive_write_disk_uid(struct archive * _a,const char * name,la_int64_t id)1836 archive_write_disk_uid(struct archive *_a, const char *name, la_int64_t id)
1837 {
1838 struct archive_write_disk *a = (struct archive_write_disk *)_a;
1839 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
1840 ARCHIVE_STATE_ANY, "archive_write_disk_uid");
1841 if (a->lookup_uid)
1842 return (a->lookup_uid)(a->lookup_uid_data, name, id);
1843 return (id);
1844 }
1845
1846 /*
1847 * Create a new archive_write_disk object and initialize it with global state.
1848 */
1849 struct archive *
archive_write_disk_new(void)1850 archive_write_disk_new(void)
1851 {
1852 struct archive_write_disk *a;
1853
1854 a = (struct archive_write_disk *)calloc(1, sizeof(*a));
1855 if (a == NULL)
1856 return (NULL);
1857 a->archive.magic = ARCHIVE_WRITE_DISK_MAGIC;
1858 /* We're ready to write a header immediately. */
1859 a->archive.state = ARCHIVE_STATE_HEADER;
1860 a->archive.vtable = archive_write_disk_vtable();
1861 a->start_time = time(NULL);
1862 /* Query and restore the umask. */
1863 umask(a->user_umask = umask(0));
1864 #ifdef HAVE_GETEUID
1865 a->user_uid = geteuid();
1866 #endif /* HAVE_GETEUID */
1867 if (archive_string_ensure(&a->path_safe, 512) == NULL) {
1868 free(a);
1869 return (NULL);
1870 }
1871 #ifdef HAVE_ZLIB_H
1872 a->decmpfs_compression_level = 5;
1873 #endif
1874 return (&a->archive);
1875 }
1876
1877
1878 /*
1879 * If pathname is longer than PATH_MAX, chdir to a suitable
1880 * intermediate dir and edit the path down to a shorter suffix. Note
1881 * that this routine never returns an error; if the chdir() attempt
1882 * fails for any reason, we just go ahead with the long pathname. The
1883 * object creation is likely to fail, but any error will get handled
1884 * at that time.
1885 */
1886 #if defined(HAVE_FCHDIR) && defined(PATH_MAX)
1887 static void
edit_deep_directories(struct archive_write_disk * a)1888 edit_deep_directories(struct archive_write_disk *a)
1889 {
1890 int ret;
1891 char *tail = a->name;
1892
1893 /* If path is short, avoid the open() below. */
1894 if (strlen(tail) < PATH_MAX)
1895 return;
1896
1897 /* Try to record our starting dir. */
1898 a->restore_pwd = open(".", O_RDONLY | O_BINARY | O_CLOEXEC);
1899 __archive_ensure_cloexec_flag(a->restore_pwd);
1900 if (a->restore_pwd < 0)
1901 return;
1902
1903 /* As long as the path is too long... */
1904 while (strlen(tail) >= PATH_MAX) {
1905 /* Locate a dir prefix shorter than PATH_MAX. */
1906 tail += PATH_MAX - 8;
1907 while (tail > a->name && *tail != '/')
1908 tail--;
1909 /* Exit if we find a too-long path component. */
1910 if (tail <= a->name)
1911 return;
1912 /* Create the intermediate dir and chdir to it. */
1913 *tail = '\0'; /* Terminate dir portion */
1914 ret = create_dir(a, a->name);
1915 if (ret == ARCHIVE_OK && chdir(a->name) != 0)
1916 ret = ARCHIVE_FAILED;
1917 *tail = '/'; /* Restore the / we removed. */
1918 if (ret != ARCHIVE_OK)
1919 return;
1920 tail++;
1921 /* The chdir() succeeded; we've now shortened the path. */
1922 a->name = tail;
1923 }
1924 return;
1925 }
1926 #endif
1927
1928 /*
1929 * The main restore function.
1930 */
1931 static int
restore_entry(struct archive_write_disk * a)1932 restore_entry(struct archive_write_disk *a)
1933 {
1934 int ret = ARCHIVE_OK, en;
1935
1936 if (a->flags & ARCHIVE_EXTRACT_UNLINK && !S_ISDIR(a->mode)) {
1937 /*
1938 * TODO: Fix this. Apparently, there are platforms
1939 * that still allow root to hose the entire filesystem
1940 * by unlinking a dir. The S_ISDIR() test above
1941 * prevents us from using unlink() here if the new
1942 * object is a dir, but that doesn't mean the old
1943 * object isn't a dir.
1944 */
1945 if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS)
1946 (void)clear_nochange_fflags(a);
1947 if (unlink(a->name) == 0) {
1948 /* We removed it, reset cached stat. */
1949 a->pst = NULL;
1950 } else if (errno == ENOENT) {
1951 /* File didn't exist, that's just as good. */
1952 } else if (rmdir(a->name) == 0) {
1953 /* It was a dir, but now it's gone. */
1954 a->pst = NULL;
1955 } else {
1956 /* We tried, but couldn't get rid of it. */
1957 archive_set_error(&a->archive, errno,
1958 "Could not unlink");
1959 return(ARCHIVE_FAILED);
1960 }
1961 }
1962
1963 /* Try creating it first; if this fails, we'll try to recover. */
1964 en = create_filesystem_object(a);
1965
1966 if ((en == ENOTDIR || en == ENOENT)
1967 && !(a->flags & ARCHIVE_EXTRACT_NO_AUTODIR)) {
1968 /* If the parent dir doesn't exist, try creating it. */
1969 create_parent_dir(a, a->name);
1970 /* Now try to create the object again. */
1971 en = create_filesystem_object(a);
1972 }
1973
1974 if ((en == ENOENT) && (archive_entry_hardlink(a->entry) != NULL)) {
1975 archive_set_error(&a->archive, en,
1976 "Hard-link target '%s' does not exist.",
1977 archive_entry_hardlink(a->entry));
1978 return (ARCHIVE_FAILED);
1979 }
1980
1981 if ((en == EISDIR || en == EEXIST)
1982 && (a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) {
1983 /* If we're not overwriting, we're done. */
1984 if (S_ISDIR(a->mode)) {
1985 /* Don't overwrite any settings on existing directories. */
1986 a->todo = 0;
1987 }
1988 archive_entry_unset_size(a->entry);
1989 return (ARCHIVE_OK);
1990 }
1991
1992 /*
1993 * Some platforms return EISDIR if you call
1994 * open(O_WRONLY | O_EXCL | O_CREAT) on a directory, some
1995 * return EEXIST. POSIX is ambiguous, requiring EISDIR
1996 * for open(O_WRONLY) on a dir and EEXIST for open(O_EXCL | O_CREAT)
1997 * on an existing item.
1998 */
1999 if (en == EISDIR) {
2000 /* A dir is in the way of a non-dir, rmdir it. */
2001 if (rmdir(a->name) != 0) {
2002 archive_set_error(&a->archive, errno,
2003 "Can't remove already-existing dir");
2004 return (ARCHIVE_FAILED);
2005 }
2006 a->pst = NULL;
2007 /* Try again. */
2008 en = create_filesystem_object(a);
2009 } else if (en == EEXIST) {
2010 /*
2011 * We know something is in the way, but we don't know what;
2012 * we need to find out before we go any further.
2013 */
2014 int r = 0;
2015 /*
2016 * The SECURE_SYMLINKS logic has already removed a
2017 * symlink to a dir if the client wants that. So
2018 * follow the symlink if we're creating a dir.
2019 */
2020 if (S_ISDIR(a->mode))
2021 r = stat(a->name, &a->st);
2022 /*
2023 * If it's not a dir (or it's a broken symlink),
2024 * then don't follow it.
2025 */
2026 if (r != 0 || !S_ISDIR(a->mode))
2027 r = lstat(a->name, &a->st);
2028 if (r != 0) {
2029 archive_set_error(&a->archive, errno,
2030 "Can't stat existing object");
2031 return (ARCHIVE_FAILED);
2032 }
2033
2034 /*
2035 * NO_OVERWRITE_NEWER doesn't apply to directories.
2036 */
2037 if ((a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER)
2038 && !S_ISDIR(a->st.st_mode)) {
2039 if (!older(&(a->st), a->entry)) {
2040 archive_entry_unset_size(a->entry);
2041 return (ARCHIVE_OK);
2042 }
2043 }
2044
2045 /* If it's our archive, we're done. */
2046 if (a->skip_file_set &&
2047 a->st.st_dev == (dev_t)a->skip_file_dev &&
2048 a->st.st_ino == (ino_t)a->skip_file_ino) {
2049 archive_set_error(&a->archive, 0,
2050 "Refusing to overwrite archive");
2051 return (ARCHIVE_FAILED);
2052 }
2053
2054 if (!S_ISDIR(a->st.st_mode)) {
2055 /* A non-dir is in the way, unlink it. */
2056 if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS)
2057 (void)clear_nochange_fflags(a);
2058 if (unlink(a->name) != 0) {
2059 archive_set_error(&a->archive, errno,
2060 "Can't unlink already-existing object");
2061 return (ARCHIVE_FAILED);
2062 }
2063 a->pst = NULL;
2064 /* Try again. */
2065 en = create_filesystem_object(a);
2066 } else if (!S_ISDIR(a->mode)) {
2067 /* A dir is in the way of a non-dir, rmdir it. */
2068 if (a->flags & ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS)
2069 (void)clear_nochange_fflags(a);
2070 if (rmdir(a->name) != 0) {
2071 archive_set_error(&a->archive, errno,
2072 "Can't replace existing directory with non-directory");
2073 return (ARCHIVE_FAILED);
2074 }
2075 /* Try again. */
2076 en = create_filesystem_object(a);
2077 } else {
2078 /*
2079 * There's a dir in the way of a dir. Don't
2080 * waste time with rmdir()/mkdir(), just fix
2081 * up the permissions on the existing dir.
2082 * Note that we don't change perms on existing
2083 * dirs unless _EXTRACT_PERM is specified.
2084 */
2085 if ((a->mode != a->st.st_mode)
2086 && (a->todo & TODO_MODE_FORCE))
2087 a->deferred |= (a->todo & TODO_MODE);
2088 /* Ownership doesn't need deferred fixup. */
2089 en = 0; /* Forget the EEXIST. */
2090 }
2091 }
2092
2093 if (en) {
2094 /* Everything failed; give up here. */
2095 if ((&a->archive)->error == NULL)
2096 archive_set_error(&a->archive, en, "Can't create '%s'",
2097 a->name);
2098 return (ARCHIVE_FAILED);
2099 }
2100
2101 a->pst = NULL; /* Cached stat data no longer valid. */
2102 return (ret);
2103 }
2104
2105 /*
2106 * Returns 0 if creation succeeds, or else returns errno value from
2107 * the failed system call. Note: This function should only ever perform
2108 * a single system call.
2109 */
2110 static int
create_filesystem_object(struct archive_write_disk * a)2111 create_filesystem_object(struct archive_write_disk *a)
2112 {
2113 /* Create the entry. */
2114 const char *linkname;
2115 mode_t final_mode, mode;
2116 int r;
2117 /* these for check_symlinks_fsobj */
2118 char *linkname_copy; /* non-const copy of linkname */
2119 struct stat st;
2120 struct archive_string error_string;
2121 int error_number;
2122
2123 /* We identify hard/symlinks according to the link names. */
2124 /* Since link(2) and symlink(2) don't handle modes, we're done here. */
2125 linkname = archive_entry_hardlink(a->entry);
2126 if (linkname != NULL) {
2127 #if !HAVE_LINK
2128 return (EPERM);
2129 #else
2130 archive_string_init(&error_string);
2131 linkname_copy = strdup(linkname);
2132 if (linkname_copy == NULL) {
2133 return (EPERM);
2134 }
2135 /*
2136 * TODO: consider using the cleaned-up path as the link
2137 * target?
2138 */
2139 r = cleanup_pathname_fsobj(linkname_copy, &error_number,
2140 &error_string, a->flags);
2141 if (r != ARCHIVE_OK) {
2142 archive_set_error(&a->archive, error_number, "%s",
2143 error_string.s);
2144 free(linkname_copy);
2145 archive_string_free(&error_string);
2146 /*
2147 * EPERM is more appropriate than error_number for our
2148 * callers
2149 */
2150 return (EPERM);
2151 }
2152 r = check_symlinks_fsobj(linkname_copy, &error_number,
2153 &error_string, a->flags);
2154 if (r != ARCHIVE_OK) {
2155 archive_set_error(&a->archive, error_number, "%s",
2156 error_string.s);
2157 free(linkname_copy);
2158 archive_string_free(&error_string);
2159 /*
2160 * EPERM is more appropriate than error_number for our
2161 * callers
2162 */
2163 return (EPERM);
2164 }
2165 free(linkname_copy);
2166 archive_string_free(&error_string);
2167 r = link(linkname, a->name) ? errno : 0;
2168 /*
2169 * New cpio and pax formats allow hardlink entries
2170 * to carry data, so we may have to open the file
2171 * for hardlink entries.
2172 *
2173 * If the hardlink was successfully created and
2174 * the archive doesn't have carry data for it,
2175 * consider it to be non-authoritative for meta data.
2176 * This is consistent with GNU tar and BSD pax.
2177 * If the hardlink does carry data, let the last
2178 * archive entry decide ownership.
2179 */
2180 if (r == 0 && a->filesize <= 0) {
2181 a->todo = 0;
2182 a->deferred = 0;
2183 } else if (r == 0 && a->filesize > 0) {
2184 #ifdef HAVE_LSTAT
2185 r = lstat(a->name, &st);
2186 #else
2187 r = stat(a->name, &st);
2188 #endif
2189 if (r != 0)
2190 r = errno;
2191 else if ((st.st_mode & AE_IFMT) == AE_IFREG) {
2192 a->fd = open(a->name, O_WRONLY | O_TRUNC |
2193 O_BINARY | O_CLOEXEC | O_NOFOLLOW);
2194 __archive_ensure_cloexec_flag(a->fd);
2195 if (a->fd < 0)
2196 r = errno;
2197 }
2198 }
2199 return (r);
2200 #endif
2201 }
2202 linkname = archive_entry_symlink(a->entry);
2203 if (linkname != NULL) {
2204 #if HAVE_SYMLINK
2205 return symlink(linkname, a->name) ? errno : 0;
2206 #else
2207 return (EPERM);
2208 #endif
2209 }
2210
2211 /*
2212 * The remaining system calls all set permissions, so let's
2213 * try to take advantage of that to avoid an extra chmod()
2214 * call. (Recall that umask is set to zero right now!)
2215 */
2216
2217 /* Mode we want for the final restored object (w/o file type bits). */
2218 final_mode = a->mode & 07777;
2219 /*
2220 * The mode that will actually be restored in this step. Note
2221 * that SUID, SGID, etc, require additional work to ensure
2222 * security, so we never restore them at this point.
2223 */
2224 mode = final_mode & 0777 & ~a->user_umask;
2225
2226 switch (a->mode & AE_IFMT) {
2227 default:
2228 /* POSIX requires that we fall through here. */
2229 /* FALLTHROUGH */
2230 case AE_IFREG:
2231 a->fd = open(a->name,
2232 O_WRONLY | O_CREAT | O_EXCL | O_BINARY | O_CLOEXEC, mode);
2233 __archive_ensure_cloexec_flag(a->fd);
2234 r = (a->fd < 0);
2235 break;
2236 case AE_IFCHR:
2237 #ifdef HAVE_MKNOD
2238 /* Note: we use AE_IFCHR for the case label, and
2239 * S_IFCHR for the mknod() call. This is correct. */
2240 r = mknod(a->name, mode | S_IFCHR,
2241 archive_entry_rdev(a->entry));
2242 break;
2243 #else
2244 /* TODO: Find a better way to warn about our inability
2245 * to restore a char device node. */
2246 return (EINVAL);
2247 #endif /* HAVE_MKNOD */
2248 case AE_IFBLK:
2249 #ifdef HAVE_MKNOD
2250 r = mknod(a->name, mode | S_IFBLK,
2251 archive_entry_rdev(a->entry));
2252 break;
2253 #else
2254 /* TODO: Find a better way to warn about our inability
2255 * to restore a block device node. */
2256 return (EINVAL);
2257 #endif /* HAVE_MKNOD */
2258 case AE_IFDIR:
2259 mode = (mode | MINIMUM_DIR_MODE) & MAXIMUM_DIR_MODE;
2260 r = mkdir(a->name, mode);
2261 if (r == 0) {
2262 /* Defer setting dir times. */
2263 a->deferred |= (a->todo & TODO_TIMES);
2264 a->todo &= ~TODO_TIMES;
2265 /* Never use an immediate chmod(). */
2266 /* We can't avoid the chmod() entirely if EXTRACT_PERM
2267 * because of SysV SGID inheritance. */
2268 if ((mode != final_mode)
2269 || (a->flags & ARCHIVE_EXTRACT_PERM))
2270 a->deferred |= (a->todo & TODO_MODE);
2271 a->todo &= ~TODO_MODE;
2272 }
2273 break;
2274 case AE_IFIFO:
2275 #ifdef HAVE_MKFIFO
2276 r = mkfifo(a->name, mode);
2277 break;
2278 #else
2279 /* TODO: Find a better way to warn about our inability
2280 * to restore a fifo. */
2281 return (EINVAL);
2282 #endif /* HAVE_MKFIFO */
2283 }
2284
2285 /* All the system calls above set errno on failure. */
2286 if (r)
2287 return (errno);
2288
2289 /* If we managed to set the final mode, we've avoided a chmod(). */
2290 if (mode == final_mode)
2291 a->todo &= ~TODO_MODE;
2292 return (0);
2293 }
2294
2295 /*
2296 * Cleanup function for archive_extract. Mostly, this involves processing
2297 * the fixup list, which is used to address a number of problems:
2298 * * Dir permissions might prevent us from restoring a file in that
2299 * dir, so we restore the dir with minimum 0700 permissions first,
2300 * then correct the mode at the end.
2301 * * Similarly, the act of restoring a file touches the directory
2302 * and changes the timestamp on the dir, so we have to touch-up dir
2303 * timestamps at the end as well.
2304 * * Some file flags can interfere with the restore by, for example,
2305 * preventing the creation of hardlinks to those files.
2306 * * Mac OS extended metadata includes ACLs, so must be deferred on dirs.
2307 *
2308 * Note that tar/cpio do not require that archives be in a particular
2309 * order; there is no way to know when the last file has been restored
2310 * within a directory, so there's no way to optimize the memory usage
2311 * here by fixing up the directory any earlier than the
2312 * end-of-archive.
2313 *
2314 * XXX TODO: Directory ACLs should be restored here, for the same
2315 * reason we set directory perms here. XXX
2316 */
2317 static int
_archive_write_disk_close(struct archive * _a)2318 _archive_write_disk_close(struct archive *_a)
2319 {
2320 struct archive_write_disk *a = (struct archive_write_disk *)_a;
2321 struct fixup_entry *next, *p;
2322 int ret;
2323
2324 archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
2325 ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
2326 "archive_write_disk_close");
2327 ret = _archive_write_disk_finish_entry(&a->archive);
2328
2329 /* Sort dir list so directories are fixed up in depth-first order. */
2330 p = sort_dir_list(a->fixup_list);
2331
2332 while (p != NULL) {
2333 a->pst = NULL; /* Mark stat cache as out-of-date. */
2334 if (p->fixup & TODO_TIMES) {
2335 set_times(a, -1, p->mode, p->name,
2336 p->atime, p->atime_nanos,
2337 p->birthtime, p->birthtime_nanos,
2338 p->mtime, p->mtime_nanos,
2339 p->ctime, p->ctime_nanos);
2340 }
2341 if (p->fixup & TODO_MODE_BASE)
2342 chmod(p->name, p->mode);
2343 if (p->fixup & TODO_ACLS)
2344 archive_write_disk_set_acls(&a->archive, -1, p->name,
2345 &p->acl, p->mode);
2346 if (p->fixup & TODO_FFLAGS)
2347 set_fflags_platform(a, -1, p->name,
2348 p->mode, p->fflags_set, 0);
2349 if (p->fixup & TODO_MAC_METADATA)
2350 set_mac_metadata(a, p->name, p->mac_metadata,
2351 p->mac_metadata_size);
2352 next = p->next;
2353 archive_acl_clear(&p->acl);
2354 free(p->mac_metadata);
2355 free(p->name);
2356 free(p);
2357 p = next;
2358 }
2359 a->fixup_list = NULL;
2360 return (ret);
2361 }
2362
2363 static int
_archive_write_disk_free(struct archive * _a)2364 _archive_write_disk_free(struct archive *_a)
2365 {
2366 struct archive_write_disk *a;
2367 int ret;
2368 if (_a == NULL)
2369 return (ARCHIVE_OK);
2370 archive_check_magic(_a, ARCHIVE_WRITE_DISK_MAGIC,
2371 ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_disk_free");
2372 a = (struct archive_write_disk *)_a;
2373 ret = _archive_write_disk_close(&a->archive);
2374 archive_write_disk_set_group_lookup(&a->archive, NULL, NULL, NULL);
2375 archive_write_disk_set_user_lookup(&a->archive, NULL, NULL, NULL);
2376 if (a->entry)
2377 archive_entry_free(a->entry);
2378 archive_string_free(&a->_name_data);
2379 archive_string_free(&a->archive.error_string);
2380 archive_string_free(&a->path_safe);
2381 a->archive.magic = 0;
2382 __archive_clean(&a->archive);
2383 free(a->decmpfs_header_p);
2384 free(a->resource_fork);
2385 free(a->compressed_buffer);
2386 free(a->uncompressed_buffer);
2387 #if defined(__APPLE__) && defined(UF_COMPRESSED) && defined(HAVE_SYS_XATTR_H)\
2388 && defined(HAVE_ZLIB_H)
2389 if (a->stream_valid) {
2390 switch (deflateEnd(&a->stream)) {
2391 case Z_OK:
2392 break;
2393 default:
2394 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2395 "Failed to clean up compressor");
2396 ret = ARCHIVE_FATAL;
2397 break;
2398 }
2399 }
2400 #endif
2401 free(a);
2402 return (ret);
2403 }
2404
2405 /*
2406 * Simple O(n log n) merge sort to order the fixup list. In
2407 * particular, we want to restore dir timestamps depth-first.
2408 */
2409 static struct fixup_entry *
sort_dir_list(struct fixup_entry * p)2410 sort_dir_list(struct fixup_entry *p)
2411 {
2412 struct fixup_entry *a, *b, *t;
2413
2414 if (p == NULL)
2415 return (NULL);
2416 /* A one-item list is already sorted. */
2417 if (p->next == NULL)
2418 return (p);
2419
2420 /* Step 1: split the list. */
2421 t = p;
2422 a = p->next->next;
2423 while (a != NULL) {
2424 /* Step a twice, t once. */
2425 a = a->next;
2426 if (a != NULL)
2427 a = a->next;
2428 t = t->next;
2429 }
2430 /* Now, t is at the mid-point, so break the list here. */
2431 b = t->next;
2432 t->next = NULL;
2433 a = p;
2434
2435 /* Step 2: Recursively sort the two sub-lists. */
2436 a = sort_dir_list(a);
2437 b = sort_dir_list(b);
2438
2439 /* Step 3: Merge the returned lists. */
2440 /* Pick the first element for the merged list. */
2441 if (strcmp(a->name, b->name) > 0) {
2442 t = p = a;
2443 a = a->next;
2444 } else {
2445 t = p = b;
2446 b = b->next;
2447 }
2448
2449 /* Always put the later element on the list first. */
2450 while (a != NULL && b != NULL) {
2451 if (strcmp(a->name, b->name) > 0) {
2452 t->next = a;
2453 a = a->next;
2454 } else {
2455 t->next = b;
2456 b = b->next;
2457 }
2458 t = t->next;
2459 }
2460
2461 /* Only one list is non-empty, so just splice it on. */
2462 if (a != NULL)
2463 t->next = a;
2464 if (b != NULL)
2465 t->next = b;
2466
2467 return (p);
2468 }
2469
2470 /*
2471 * Returns a new, initialized fixup entry.
2472 *
2473 * TODO: Reduce the memory requirements for this list by using a tree
2474 * structure rather than a simple list of names.
2475 */
2476 static struct fixup_entry *
new_fixup(struct archive_write_disk * a,const char * pathname)2477 new_fixup(struct archive_write_disk *a, const char *pathname)
2478 {
2479 struct fixup_entry *fe;
2480
2481 fe = (struct fixup_entry *)calloc(1, sizeof(struct fixup_entry));
2482 if (fe == NULL) {
2483 archive_set_error(&a->archive, ENOMEM,
2484 "Can't allocate memory for a fixup");
2485 return (NULL);
2486 }
2487 fe->next = a->fixup_list;
2488 a->fixup_list = fe;
2489 fe->fixup = 0;
2490 fe->name = strdup(pathname);
2491 return (fe);
2492 }
2493
2494 /*
2495 * Returns a fixup structure for the current entry.
2496 */
2497 static struct fixup_entry *
current_fixup(struct archive_write_disk * a,const char * pathname)2498 current_fixup(struct archive_write_disk *a, const char *pathname)
2499 {
2500 if (a->current_fixup == NULL)
2501 a->current_fixup = new_fixup(a, pathname);
2502 return (a->current_fixup);
2503 }
2504
2505 /* Error helper for new *_fsobj functions */
2506 static void
fsobj_error(int * a_eno,struct archive_string * a_estr,int err,const char * errstr,const char * path)2507 fsobj_error(int *a_eno, struct archive_string *a_estr,
2508 int err, const char *errstr, const char *path)
2509 {
2510 if (a_eno)
2511 *a_eno = err;
2512 if (a_estr)
2513 archive_string_sprintf(a_estr, "%s%s", errstr, path);
2514 }
2515
2516 /*
2517 * TODO: Someday, integrate this with the deep dir support; they both
2518 * scan the path and both can be optimized by comparing against other
2519 * recent paths.
2520 */
2521 /* TODO: Extend this to support symlinks on Windows Vista and later. */
2522
2523 /*
2524 * Checks the given path to see if any elements along it are symlinks. Returns
2525 * ARCHIVE_OK if there are none, otherwise puts an error in errmsg.
2526 */
2527 static int
check_symlinks_fsobj(char * path,int * a_eno,struct archive_string * a_estr,int flags)2528 check_symlinks_fsobj(char *path, int *a_eno, struct archive_string *a_estr,
2529 int flags)
2530 {
2531 #if !defined(HAVE_LSTAT)
2532 /* Platform doesn't have lstat, so we can't look for symlinks. */
2533 (void)path; /* UNUSED */
2534 (void)error_number; /* UNUSED */
2535 (void)error_string; /* UNUSED */
2536 (void)flags; /* UNUSED */
2537 return (ARCHIVE_OK);
2538 #else
2539 int res = ARCHIVE_OK;
2540 char *tail;
2541 char *head;
2542 int last;
2543 char c;
2544 int r;
2545 struct stat st;
2546 int restore_pwd;
2547
2548 /* Nothing to do here if name is empty */
2549 if(path[0] == '\0')
2550 return (ARCHIVE_OK);
2551
2552 /*
2553 * Guard against symlink tricks. Reject any archive entry whose
2554 * destination would be altered by a symlink.
2555 *
2556 * Walk the filename in chunks separated by '/'. For each segment:
2557 * - if it doesn't exist, continue
2558 * - if it's symlink, abort or remove it
2559 * - if it's a directory and it's not the last chunk, cd into it
2560 * As we go:
2561 * head points to the current (relative) path
2562 * tail points to the temporary \0 terminating the segment we're
2563 * currently examining
2564 * c holds what used to be in *tail
2565 * last is 1 if this is the last tail
2566 */
2567 restore_pwd = open(".", O_RDONLY | O_BINARY | O_CLOEXEC);
2568 __archive_ensure_cloexec_flag(restore_pwd);
2569 if (restore_pwd < 0)
2570 return (ARCHIVE_FATAL);
2571 head = path;
2572 tail = path;
2573 last = 0;
2574 /* TODO: reintroduce a safe cache here? */
2575 /* Skip the root directory if the path is absolute. */
2576 if(tail == path && tail[0] == '/')
2577 ++tail;
2578 /* Keep going until we've checked the entire name.
2579 * head, tail, path all alias the same string, which is
2580 * temporarily zeroed at tail, so be careful restoring the
2581 * stashed (c=tail[0]) for error messages.
2582 * Exiting the loop with break is okay; continue is not.
2583 */
2584 while (!last) {
2585 /*
2586 * Skip the separator we just consumed, plus any adjacent ones
2587 */
2588 while (*tail == '/')
2589 ++tail;
2590 /* Skip the next path element. */
2591 while (*tail != '\0' && *tail != '/')
2592 ++tail;
2593 /* is this the last path component? */
2594 last = (tail[0] == '\0') || (tail[0] == '/' && tail[1] == '\0');
2595 /* temporarily truncate the string here */
2596 c = tail[0];
2597 tail[0] = '\0';
2598 /* Check that we haven't hit a symlink. */
2599 r = lstat(head, &st);
2600 if (r != 0) {
2601 tail[0] = c;
2602 /* We've hit a dir that doesn't exist; stop now. */
2603 if (errno == ENOENT) {
2604 break;
2605 } else {
2606 /*
2607 * Treat any other error as fatal - best to be
2608 * paranoid here.
2609 * Note: This effectively disables deep
2610 * directory support when security checks are
2611 * enabled. Otherwise, very long pathnames that
2612 * trigger an error here could evade the
2613 * sandbox.
2614 * TODO: We could do better, but it would
2615 * probably require merging the symlink checks
2616 * with the deep-directory editing.
2617 */
2618 fsobj_error(a_eno, a_estr, errno,
2619 "Could not stat ", path);
2620 res = ARCHIVE_FAILED;
2621 break;
2622 }
2623 } else if (S_ISDIR(st.st_mode)) {
2624 if (!last) {
2625 if (chdir(head) != 0) {
2626 tail[0] = c;
2627 fsobj_error(a_eno, a_estr, errno,
2628 "Could not chdir ", path);
2629 res = (ARCHIVE_FATAL);
2630 break;
2631 }
2632 /* Our view is now from inside this dir: */
2633 head = tail + 1;
2634 }
2635 } else if (S_ISLNK(st.st_mode)) {
2636 if (last) {
2637 /*
2638 * Last element is symlink; remove it
2639 * so we can overwrite it with the
2640 * item being extracted.
2641 */
2642 if (unlink(head)) {
2643 tail[0] = c;
2644 fsobj_error(a_eno, a_estr, errno,
2645 "Could not remove symlink ",
2646 path);
2647 res = ARCHIVE_FAILED;
2648 break;
2649 }
2650 /*
2651 * Even if we did remove it, a warning
2652 * is in order. The warning is silly,
2653 * though, if we're just replacing one
2654 * symlink with another symlink.
2655 */
2656 tail[0] = c;
2657 /*
2658 * FIXME: not sure how important this is to
2659 * restore
2660 */
2661 /*
2662 if (!S_ISLNK(path)) {
2663 fsobj_error(a_eno, a_estr, 0,
2664 "Removing symlink ", path);
2665 }
2666 */
2667 /* Symlink gone. No more problem! */
2668 res = ARCHIVE_OK;
2669 break;
2670 } else if (flags & ARCHIVE_EXTRACT_UNLINK) {
2671 /* User asked us to remove problems. */
2672 if (unlink(head) != 0) {
2673 tail[0] = c;
2674 fsobj_error(a_eno, a_estr, 0,
2675 "Cannot remove intervening "
2676 "symlink ", path);
2677 res = ARCHIVE_FAILED;
2678 break;
2679 }
2680 tail[0] = c;
2681 } else if ((flags &
2682 ARCHIVE_EXTRACT_SECURE_SYMLINKS) == 0) {
2683 /*
2684 * We are not the last element and we want to
2685 * follow symlinks if they are a directory.
2686 *
2687 * This is needed to extract hardlinks over
2688 * symlinks.
2689 */
2690 r = stat(head, &st);
2691 if (r != 0) {
2692 tail[0] = c;
2693 if (errno == ENOENT) {
2694 break;
2695 } else {
2696 fsobj_error(a_eno, a_estr,
2697 errno,
2698 "Could not stat ", path);
2699 res = (ARCHIVE_FAILED);
2700 break;
2701 }
2702 } else if (S_ISDIR(st.st_mode)) {
2703 if (chdir(head) != 0) {
2704 tail[0] = c;
2705 fsobj_error(a_eno, a_estr,
2706 errno,
2707 "Could not chdir ", path);
2708 res = (ARCHIVE_FATAL);
2709 break;
2710 }
2711 /*
2712 * Our view is now from inside
2713 * this dir:
2714 */
2715 head = tail + 1;
2716 } else {
2717 tail[0] = c;
2718 fsobj_error(a_eno, a_estr, 0,
2719 "Cannot extract through "
2720 "symlink ", path);
2721 res = ARCHIVE_FAILED;
2722 break;
2723 }
2724 } else {
2725 tail[0] = c;
2726 fsobj_error(a_eno, a_estr, 0,
2727 "Cannot extract through symlink ", path);
2728 res = ARCHIVE_FAILED;
2729 break;
2730 }
2731 }
2732 /* be sure to always maintain this */
2733 tail[0] = c;
2734 if (tail[0] != '\0')
2735 tail++; /* Advance to the next segment. */
2736 }
2737 /* Catches loop exits via break */
2738 tail[0] = c;
2739 #ifdef HAVE_FCHDIR
2740 /* If we changed directory above, restore it here. */
2741 if (restore_pwd >= 0) {
2742 r = fchdir(restore_pwd);
2743 if (r != 0) {
2744 fsobj_error(a_eno, a_estr, errno,
2745 "chdir() failure", "");
2746 }
2747 close(restore_pwd);
2748 restore_pwd = -1;
2749 if (r != 0) {
2750 res = (ARCHIVE_FATAL);
2751 }
2752 }
2753 #endif
2754 /* TODO: reintroduce a safe cache here? */
2755 return res;
2756 #endif
2757 }
2758
2759 /*
2760 * Check a->name for symlinks, returning ARCHIVE_OK if its clean, otherwise
2761 * calls archive_set_error and returns ARCHIVE_{FATAL,FAILED}
2762 */
2763 static int
check_symlinks(struct archive_write_disk * a)2764 check_symlinks(struct archive_write_disk *a)
2765 {
2766 struct archive_string error_string;
2767 int error_number;
2768 int rc;
2769 archive_string_init(&error_string);
2770 rc = check_symlinks_fsobj(a->name, &error_number, &error_string,
2771 a->flags);
2772 if (rc != ARCHIVE_OK) {
2773 archive_set_error(&a->archive, error_number, "%s",
2774 error_string.s);
2775 }
2776 archive_string_free(&error_string);
2777 a->pst = NULL; /* to be safe */
2778 return rc;
2779 }
2780
2781
2782 #if defined(__CYGWIN__)
2783 /*
2784 * 1. Convert a path separator from '\' to '/' .
2785 * We shouldn't check multibyte character directly because some
2786 * character-set have been using the '\' character for a part of
2787 * its multibyte character code.
2788 * 2. Replace unusable characters in Windows with underscore('_').
2789 * See also : http://msdn.microsoft.com/en-us/library/aa365247.aspx
2790 */
2791 static void
cleanup_pathname_win(char * path)2792 cleanup_pathname_win(char *path)
2793 {
2794 wchar_t wc;
2795 char *p;
2796 size_t alen, l;
2797 int mb, complete, utf8;
2798
2799 alen = 0;
2800 mb = 0;
2801 complete = 1;
2802 utf8 = (strcmp(nl_langinfo(CODESET), "UTF-8") == 0)? 1: 0;
2803 for (p = path; *p != '\0'; p++) {
2804 ++alen;
2805 if (*p == '\\') {
2806 /* If previous byte is smaller than 128,
2807 * this is not second byte of multibyte characters,
2808 * so we can replace '\' with '/'. */
2809 if (utf8 || !mb)
2810 *p = '/';
2811 else
2812 complete = 0;/* uncompleted. */
2813 } else if (*(unsigned char *)p > 127)
2814 mb = 1;
2815 else
2816 mb = 0;
2817 /* Rewrite the path name if its next character is unusable. */
2818 if (*p == ':' || *p == '*' || *p == '?' || *p == '"' ||
2819 *p == '<' || *p == '>' || *p == '|')
2820 *p = '_';
2821 }
2822 if (complete)
2823 return;
2824
2825 /*
2826 * Convert path separator in wide-character.
2827 */
2828 p = path;
2829 while (*p != '\0' && alen) {
2830 l = mbtowc(&wc, p, alen);
2831 if (l == (size_t)-1) {
2832 while (*p != '\0') {
2833 if (*p == '\\')
2834 *p = '/';
2835 ++p;
2836 }
2837 break;
2838 }
2839 if (l == 1 && wc == L'\\')
2840 *p = '/';
2841 p += l;
2842 alen -= l;
2843 }
2844 }
2845 #endif
2846
2847 /*
2848 * Canonicalize the pathname. In particular, this strips duplicate
2849 * '/' characters, '.' elements, and trailing '/'. It also raises an
2850 * error for an empty path, a trailing '..', (if _SECURE_NODOTDOT is
2851 * set) any '..' in the path or (if ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS
2852 * is set) if the path is absolute.
2853 */
2854 static int
cleanup_pathname_fsobj(char * path,int * a_eno,struct archive_string * a_estr,int flags)2855 cleanup_pathname_fsobj(char *path, int *a_eno, struct archive_string *a_estr,
2856 int flags)
2857 {
2858 char *dest, *src;
2859 char separator = '\0';
2860
2861 dest = src = path;
2862 if (*src == '\0') {
2863 fsobj_error(a_eno, a_estr, ARCHIVE_ERRNO_MISC,
2864 "Invalid empty ", "pathname");
2865 return (ARCHIVE_FAILED);
2866 }
2867
2868 #if defined(__CYGWIN__)
2869 cleanup_pathname_win(path);
2870 #endif
2871 /* Skip leading '/'. */
2872 if (*src == '/') {
2873 if (flags & ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS) {
2874 fsobj_error(a_eno, a_estr, ARCHIVE_ERRNO_MISC,
2875 "Path is ", "absolute");
2876 return (ARCHIVE_FAILED);
2877 }
2878
2879 separator = *src++;
2880 }
2881
2882 /* Scan the pathname one element at a time. */
2883 for (;;) {
2884 /* src points to first char after '/' */
2885 if (src[0] == '\0') {
2886 break;
2887 } else if (src[0] == '/') {
2888 /* Found '//', ignore second one. */
2889 src++;
2890 continue;
2891 } else if (src[0] == '.') {
2892 if (src[1] == '\0') {
2893 /* Ignore trailing '.' */
2894 break;
2895 } else if (src[1] == '/') {
2896 /* Skip './'. */
2897 src += 2;
2898 continue;
2899 } else if (src[1] == '.') {
2900 if (src[2] == '/' || src[2] == '\0') {
2901 /* Conditionally warn about '..' */
2902 if (flags
2903 & ARCHIVE_EXTRACT_SECURE_NODOTDOT) {
2904 fsobj_error(a_eno, a_estr,
2905 ARCHIVE_ERRNO_MISC,
2906 "Path contains ", "'..'");
2907 return (ARCHIVE_FAILED);
2908 }
2909 }
2910 /*
2911 * Note: Under no circumstances do we
2912 * remove '..' elements. In
2913 * particular, restoring
2914 * '/foo/../bar/' should create the
2915 * 'foo' dir as a side-effect.
2916 */
2917 }
2918 }
2919
2920 /* Copy current element, including leading '/'. */
2921 if (separator)
2922 *dest++ = '/';
2923 while (*src != '\0' && *src != '/') {
2924 *dest++ = *src++;
2925 }
2926
2927 if (*src == '\0')
2928 break;
2929
2930 /* Skip '/' separator. */
2931 separator = *src++;
2932 }
2933 /*
2934 * We've just copied zero or more path elements, not including the
2935 * final '/'.
2936 */
2937 if (dest == path) {
2938 /*
2939 * Nothing got copied. The path must have been something
2940 * like '.' or '/' or './' or '/././././/./'.
2941 */
2942 if (separator)
2943 *dest++ = '/';
2944 else
2945 *dest++ = '.';
2946 }
2947 /* Terminate the result. */
2948 *dest = '\0';
2949 return (ARCHIVE_OK);
2950 }
2951
2952 static int
cleanup_pathname(struct archive_write_disk * a)2953 cleanup_pathname(struct archive_write_disk *a)
2954 {
2955 struct archive_string error_string;
2956 int error_number;
2957 int rc;
2958 archive_string_init(&error_string);
2959 rc = cleanup_pathname_fsobj(a->name, &error_number, &error_string,
2960 a->flags);
2961 if (rc != ARCHIVE_OK) {
2962 archive_set_error(&a->archive, error_number, "%s",
2963 error_string.s);
2964 }
2965 archive_string_free(&error_string);
2966 return rc;
2967 }
2968
2969 /*
2970 * Create the parent directory of the specified path, assuming path
2971 * is already in mutable storage.
2972 */
2973 static int
create_parent_dir(struct archive_write_disk * a,char * path)2974 create_parent_dir(struct archive_write_disk *a, char *path)
2975 {
2976 char *slash;
2977 int r;
2978
2979 /* Remove tail element to obtain parent name. */
2980 slash = strrchr(path, '/');
2981 if (slash == NULL)
2982 return (ARCHIVE_OK);
2983 *slash = '\0';
2984 r = create_dir(a, path);
2985 *slash = '/';
2986 return (r);
2987 }
2988
2989 /*
2990 * Create the specified dir, recursing to create parents as necessary.
2991 *
2992 * Returns ARCHIVE_OK if the path exists when we're done here.
2993 * Otherwise, returns ARCHIVE_FAILED.
2994 * Assumes path is in mutable storage; path is unchanged on exit.
2995 */
2996 static int
create_dir(struct archive_write_disk * a,char * path)2997 create_dir(struct archive_write_disk *a, char *path)
2998 {
2999 struct stat st;
3000 struct fixup_entry *le;
3001 char *slash, *base;
3002 mode_t mode_final, mode;
3003 int r;
3004
3005 /* Check for special names and just skip them. */
3006 slash = strrchr(path, '/');
3007 if (slash == NULL)
3008 base = path;
3009 else
3010 base = slash + 1;
3011
3012 if (base[0] == '\0' ||
3013 (base[0] == '.' && base[1] == '\0') ||
3014 (base[0] == '.' && base[1] == '.' && base[2] == '\0')) {
3015 /* Don't bother trying to create null path, '.', or '..'. */
3016 if (slash != NULL) {
3017 *slash = '\0';
3018 r = create_dir(a, path);
3019 *slash = '/';
3020 return (r);
3021 }
3022 return (ARCHIVE_OK);
3023 }
3024
3025 /*
3026 * Yes, this should be stat() and not lstat(). Using lstat()
3027 * here loses the ability to extract through symlinks. Also note
3028 * that this should not use the a->st cache.
3029 */
3030 if (stat(path, &st) == 0) {
3031 if (S_ISDIR(st.st_mode))
3032 return (ARCHIVE_OK);
3033 if ((a->flags & ARCHIVE_EXTRACT_NO_OVERWRITE)) {
3034 archive_set_error(&a->archive, EEXIST,
3035 "Can't create directory '%s'", path);
3036 return (ARCHIVE_FAILED);
3037 }
3038 if (unlink(path) != 0) {
3039 archive_set_error(&a->archive, errno,
3040 "Can't create directory '%s': "
3041 "Conflicting file cannot be removed",
3042 path);
3043 return (ARCHIVE_FAILED);
3044 }
3045 } else if (errno != ENOENT && errno != ENOTDIR) {
3046 /* Stat failed? */
3047 archive_set_error(&a->archive, errno,
3048 "Can't test directory '%s'", path);
3049 return (ARCHIVE_FAILED);
3050 } else if (slash != NULL) {
3051 *slash = '\0';
3052 r = create_dir(a, path);
3053 *slash = '/';
3054 if (r != ARCHIVE_OK)
3055 return (r);
3056 }
3057
3058 /*
3059 * Mode we want for the final restored directory. Per POSIX,
3060 * implicitly-created dirs must be created obeying the umask.
3061 * There's no mention whether this is different for privileged
3062 * restores (which the rest of this code handles by pretending
3063 * umask=0). I've chosen here to always obey the user's umask for
3064 * implicit dirs, even if _EXTRACT_PERM was specified.
3065 */
3066 mode_final = DEFAULT_DIR_MODE & ~a->user_umask;
3067 /* Mode we want on disk during the restore process. */
3068 mode = mode_final;
3069 mode |= MINIMUM_DIR_MODE;
3070 mode &= MAXIMUM_DIR_MODE;
3071 if (mkdir(path, mode) == 0) {
3072 if (mode != mode_final) {
3073 le = new_fixup(a, path);
3074 if (le == NULL)
3075 return (ARCHIVE_FATAL);
3076 le->fixup |=TODO_MODE_BASE;
3077 le->mode = mode_final;
3078 }
3079 return (ARCHIVE_OK);
3080 }
3081
3082 /*
3083 * Without the following check, a/b/../b/c/d fails at the
3084 * second visit to 'b', so 'd' can't be created. Note that we
3085 * don't add it to the fixup list here, as it's already been
3086 * added.
3087 */
3088 if (stat(path, &st) == 0 && S_ISDIR(st.st_mode))
3089 return (ARCHIVE_OK);
3090
3091 archive_set_error(&a->archive, errno, "Failed to create dir '%s'",
3092 path);
3093 return (ARCHIVE_FAILED);
3094 }
3095
3096 /*
3097 * Note: Although we can skip setting the user id if the desired user
3098 * id matches the current user, we cannot skip setting the group, as
3099 * many systems set the gid based on the containing directory. So
3100 * we have to perform a chown syscall if we want to set the SGID
3101 * bit. (The alternative is to stat() and then possibly chown(); it's
3102 * more efficient to skip the stat() and just always chown().) Note
3103 * that a successful chown() here clears the TODO_SGID_CHECK bit, which
3104 * allows set_mode to skip the stat() check for the GID.
3105 */
3106 static int
set_ownership(struct archive_write_disk * a)3107 set_ownership(struct archive_write_disk *a)
3108 {
3109 #ifndef __CYGWIN__
3110 /* unfortunately, on win32 there is no 'root' user with uid 0,
3111 so we just have to try the chown and see if it works */
3112
3113 /* If we know we can't change it, don't bother trying. */
3114 if (a->user_uid != 0 && a->user_uid != a->uid) {
3115 archive_set_error(&a->archive, errno,
3116 "Can't set UID=%jd", (intmax_t)a->uid);
3117 return (ARCHIVE_WARN);
3118 }
3119 #endif
3120
3121 #ifdef HAVE_FCHOWN
3122 /* If we have an fd, we can avoid a race. */
3123 if (a->fd >= 0 && fchown(a->fd, a->uid, a->gid) == 0) {
3124 /* We've set owner and know uid/gid are correct. */
3125 a->todo &= ~(TODO_OWNER | TODO_SGID_CHECK | TODO_SUID_CHECK);
3126 return (ARCHIVE_OK);
3127 }
3128 #endif
3129
3130 /* We prefer lchown() but will use chown() if that's all we have. */
3131 /* Of course, if we have neither, this will always fail. */
3132 #ifdef HAVE_LCHOWN
3133 if (lchown(a->name, a->uid, a->gid) == 0) {
3134 /* We've set owner and know uid/gid are correct. */
3135 a->todo &= ~(TODO_OWNER | TODO_SGID_CHECK | TODO_SUID_CHECK);
3136 return (ARCHIVE_OK);
3137 }
3138 #elif HAVE_CHOWN
3139 if (!S_ISLNK(a->mode) && chown(a->name, a->uid, a->gid) == 0) {
3140 /* We've set owner and know uid/gid are correct. */
3141 a->todo &= ~(TODO_OWNER | TODO_SGID_CHECK | TODO_SUID_CHECK);
3142 return (ARCHIVE_OK);
3143 }
3144 #endif
3145
3146 archive_set_error(&a->archive, errno,
3147 "Can't set user=%jd/group=%jd for %s",
3148 (intmax_t)a->uid, (intmax_t)a->gid, a->name);
3149 return (ARCHIVE_WARN);
3150 }
3151
3152 /*
3153 * Note: Returns 0 on success, non-zero on failure.
3154 */
3155 static int
set_time(int fd,int mode,const char * name,time_t atime,long atime_nsec,time_t mtime,long mtime_nsec)3156 set_time(int fd, int mode, const char *name,
3157 time_t atime, long atime_nsec,
3158 time_t mtime, long mtime_nsec)
3159 {
3160 /* Select the best implementation for this platform. */
3161 #if defined(HAVE_UTIMENSAT) && defined(HAVE_FUTIMENS)
3162 /*
3163 * utimensat() and futimens() are defined in
3164 * POSIX.1-2008. They support ns resolution and setting times
3165 * on fds and symlinks.
3166 */
3167 struct timespec ts[2];
3168 (void)mode; /* UNUSED */
3169 ts[0].tv_sec = atime;
3170 ts[0].tv_nsec = atime_nsec;
3171 ts[1].tv_sec = mtime;
3172 ts[1].tv_nsec = mtime_nsec;
3173 if (fd >= 0)
3174 return futimens(fd, ts);
3175 return utimensat(AT_FDCWD, name, ts, AT_SYMLINK_NOFOLLOW);
3176
3177 #elif HAVE_UTIMES
3178 /*
3179 * The utimes()-family functions support µs-resolution and
3180 * setting times fds and symlinks. utimes() is documented as
3181 * LEGACY by POSIX, futimes() and lutimes() are not described
3182 * in POSIX.
3183 */
3184 struct timeval times[2];
3185
3186 times[0].tv_sec = atime;
3187 times[0].tv_usec = atime_nsec / 1000;
3188 times[1].tv_sec = mtime;
3189 times[1].tv_usec = mtime_nsec / 1000;
3190
3191 #ifdef HAVE_FUTIMES
3192 if (fd >= 0)
3193 return (futimes(fd, times));
3194 #else
3195 (void)fd; /* UNUSED */
3196 #endif
3197 #ifdef HAVE_LUTIMES
3198 (void)mode; /* UNUSED */
3199 return (lutimes(name, times));
3200 #else
3201 if (S_ISLNK(mode))
3202 return (0);
3203 return (utimes(name, times));
3204 #endif
3205
3206 #elif defined(HAVE_UTIME)
3207 /*
3208 * utime() is POSIX-standard but only supports 1s resolution and
3209 * does not support fds or symlinks.
3210 */
3211 struct utimbuf times;
3212 (void)fd; /* UNUSED */
3213 (void)name; /* UNUSED */
3214 (void)atime_nsec; /* UNUSED */
3215 (void)mtime_nsec; /* UNUSED */
3216 times.actime = atime;
3217 times.modtime = mtime;
3218 if (S_ISLNK(mode))
3219 return (ARCHIVE_OK);
3220 return (utime(name, ×));
3221
3222 #else
3223 /*
3224 * We don't know how to set the time on this platform.
3225 */
3226 (void)fd; /* UNUSED */
3227 (void)mode; /* UNUSED */
3228 (void)name; /* UNUSED */
3229 (void)atime_nsec; /* UNUSED */
3230 (void)mtime_nsec; /* UNUSED */
3231 return (ARCHIVE_WARN);
3232 #endif
3233 }
3234
3235 #ifdef F_SETTIMES
3236 static int
set_time_tru64(int fd,int mode,const char * name,time_t atime,long atime_nsec,time_t mtime,long mtime_nsec,time_t ctime,long ctime_nsec)3237 set_time_tru64(int fd, int mode, const char *name,
3238 time_t atime, long atime_nsec,
3239 time_t mtime, long mtime_nsec,
3240 time_t ctime, long ctime_nsec)
3241 {
3242 struct attr_timbuf tstamp;
3243 tstamp.atime.tv_sec = atime;
3244 tstamp.mtime.tv_sec = mtime;
3245 tstamp.ctime.tv_sec = ctime;
3246 #if defined (__hpux) && defined (__ia64)
3247 tstamp.atime.tv_nsec = atime_nsec;
3248 tstamp.mtime.tv_nsec = mtime_nsec;
3249 tstamp.ctime.tv_nsec = ctime_nsec;
3250 #else
3251 tstamp.atime.tv_usec = atime_nsec / 1000;
3252 tstamp.mtime.tv_usec = mtime_nsec / 1000;
3253 tstamp.ctime.tv_usec = ctime_nsec / 1000;
3254 #endif
3255 return (fcntl(fd,F_SETTIMES,&tstamp));
3256 }
3257 #endif /* F_SETTIMES */
3258
3259 static int
set_times(struct archive_write_disk * a,int fd,int mode,const char * name,time_t atime,long atime_nanos,time_t birthtime,long birthtime_nanos,time_t mtime,long mtime_nanos,time_t cctime,long ctime_nanos)3260 set_times(struct archive_write_disk *a,
3261 int fd, int mode, const char *name,
3262 time_t atime, long atime_nanos,
3263 time_t birthtime, long birthtime_nanos,
3264 time_t mtime, long mtime_nanos,
3265 time_t cctime, long ctime_nanos)
3266 {
3267 /* Note: set_time doesn't use libarchive return conventions!
3268 * It uses syscall conventions. So 0 here instead of ARCHIVE_OK. */
3269 int r1 = 0, r2 = 0;
3270
3271 #ifdef F_SETTIMES
3272 /*
3273 * on Tru64 try own fcntl first which can restore even the
3274 * ctime, fall back to default code path below if it fails
3275 * or if we are not running as root
3276 */
3277 if (a->user_uid == 0 &&
3278 set_time_tru64(fd, mode, name,
3279 atime, atime_nanos, mtime,
3280 mtime_nanos, cctime, ctime_nanos) == 0) {
3281 return (ARCHIVE_OK);
3282 }
3283 #else /* Tru64 */
3284 (void)cctime; /* UNUSED */
3285 (void)ctime_nanos; /* UNUSED */
3286 #endif /* Tru64 */
3287
3288 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
3289 /*
3290 * If you have struct stat.st_birthtime, we assume BSD
3291 * birthtime semantics, in which {f,l,}utimes() updates
3292 * birthtime to earliest mtime. So we set the time twice,
3293 * first using the birthtime, then using the mtime. If
3294 * birthtime == mtime, this isn't necessary, so we skip it.
3295 * If birthtime > mtime, then this won't work, so we skip it.
3296 */
3297 if (birthtime < mtime
3298 || (birthtime == mtime && birthtime_nanos < mtime_nanos))
3299 r1 = set_time(fd, mode, name,
3300 atime, atime_nanos,
3301 birthtime, birthtime_nanos);
3302 #else
3303 (void)birthtime; /* UNUSED */
3304 (void)birthtime_nanos; /* UNUSED */
3305 #endif
3306 r2 = set_time(fd, mode, name,
3307 atime, atime_nanos,
3308 mtime, mtime_nanos);
3309 if (r1 != 0 || r2 != 0) {
3310 archive_set_error(&a->archive, errno,
3311 "Can't restore time");
3312 return (ARCHIVE_WARN);
3313 }
3314 return (ARCHIVE_OK);
3315 }
3316
3317 static int
set_times_from_entry(struct archive_write_disk * a)3318 set_times_from_entry(struct archive_write_disk *a)
3319 {
3320 time_t atime, birthtime, mtime, cctime;
3321 long atime_nsec, birthtime_nsec, mtime_nsec, ctime_nsec;
3322
3323 /* Suitable defaults. */
3324 atime = birthtime = mtime = cctime = a->start_time;
3325 atime_nsec = birthtime_nsec = mtime_nsec = ctime_nsec = 0;
3326
3327 /* If no time was provided, we're done. */
3328 if (!archive_entry_atime_is_set(a->entry)
3329 #if HAVE_STRUCT_STAT_ST_BIRTHTIME
3330 && !archive_entry_birthtime_is_set(a->entry)
3331 #endif
3332 && !archive_entry_mtime_is_set(a->entry))
3333 return (ARCHIVE_OK);
3334
3335 if (archive_entry_atime_is_set(a->entry)) {
3336 atime = archive_entry_atime(a->entry);
3337 atime_nsec = archive_entry_atime_nsec(a->entry);
3338 }
3339 if (archive_entry_birthtime_is_set(a->entry)) {
3340 birthtime = archive_entry_birthtime(a->entry);
3341 birthtime_nsec = archive_entry_birthtime_nsec(a->entry);
3342 }
3343 if (archive_entry_mtime_is_set(a->entry)) {
3344 mtime = archive_entry_mtime(a->entry);
3345 mtime_nsec = archive_entry_mtime_nsec(a->entry);
3346 }
3347 if (archive_entry_ctime_is_set(a->entry)) {
3348 cctime = archive_entry_ctime(a->entry);
3349 ctime_nsec = archive_entry_ctime_nsec(a->entry);
3350 }
3351
3352 return set_times(a, a->fd, a->mode, a->name,
3353 atime, atime_nsec,
3354 birthtime, birthtime_nsec,
3355 mtime, mtime_nsec,
3356 cctime, ctime_nsec);
3357 }
3358
3359 static int
set_mode(struct archive_write_disk * a,int mode)3360 set_mode(struct archive_write_disk *a, int mode)
3361 {
3362 int r = ARCHIVE_OK;
3363 mode &= 07777; /* Strip off file type bits. */
3364
3365 if (a->todo & TODO_SGID_CHECK) {
3366 /*
3367 * If we don't know the GID is right, we must stat()
3368 * to verify it. We can't just check the GID of this
3369 * process, since systems sometimes set GID from
3370 * the enclosing dir or based on ACLs.
3371 */
3372 if ((r = lazy_stat(a)) != ARCHIVE_OK)
3373 return (r);
3374 if (a->pst->st_gid != a->gid) {
3375 mode &= ~ S_ISGID;
3376 if (a->flags & ARCHIVE_EXTRACT_OWNER) {
3377 /*
3378 * This is only an error if you
3379 * requested owner restore. If you
3380 * didn't, we'll try to restore
3381 * sgid/suid, but won't consider it a
3382 * problem if we can't.
3383 */
3384 archive_set_error(&a->archive, -1,
3385 "Can't restore SGID bit");
3386 r = ARCHIVE_WARN;
3387 }
3388 }
3389 /* While we're here, double-check the UID. */
3390 if (a->pst->st_uid != a->uid
3391 && (a->todo & TODO_SUID)) {
3392 mode &= ~ S_ISUID;
3393 if (a->flags & ARCHIVE_EXTRACT_OWNER) {
3394 archive_set_error(&a->archive, -1,
3395 "Can't restore SUID bit");
3396 r = ARCHIVE_WARN;
3397 }
3398 }
3399 a->todo &= ~TODO_SGID_CHECK;
3400 a->todo &= ~TODO_SUID_CHECK;
3401 } else if (a->todo & TODO_SUID_CHECK) {
3402 /*
3403 * If we don't know the UID is right, we can just check
3404 * the user, since all systems set the file UID from
3405 * the process UID.
3406 */
3407 if (a->user_uid != a->uid) {
3408 mode &= ~ S_ISUID;
3409 if (a->flags & ARCHIVE_EXTRACT_OWNER) {
3410 archive_set_error(&a->archive, -1,
3411 "Can't make file SUID");
3412 r = ARCHIVE_WARN;
3413 }
3414 }
3415 a->todo &= ~TODO_SUID_CHECK;
3416 }
3417
3418 if (S_ISLNK(a->mode)) {
3419 #ifdef HAVE_LCHMOD
3420 /*
3421 * If this is a symlink, use lchmod(). If the
3422 * platform doesn't support lchmod(), just skip it. A
3423 * platform that doesn't provide a way to set
3424 * permissions on symlinks probably ignores
3425 * permissions on symlinks, so a failure here has no
3426 * impact.
3427 */
3428 if (lchmod(a->name, mode) != 0) {
3429 switch (errno) {
3430 case ENOTSUP:
3431 case ENOSYS:
3432 #if ENOTSUP != EOPNOTSUPP
3433 case EOPNOTSUPP:
3434 #endif
3435 /*
3436 * if lchmod is defined but the platform
3437 * doesn't support it, silently ignore
3438 * error
3439 */
3440 break;
3441 default:
3442 archive_set_error(&a->archive, errno,
3443 "Can't set permissions to 0%o", (int)mode);
3444 r = ARCHIVE_WARN;
3445 }
3446 }
3447 #endif
3448 } else if (!S_ISDIR(a->mode)) {
3449 /*
3450 * If it's not a symlink and not a dir, then use
3451 * fchmod() or chmod(), depending on whether we have
3452 * an fd. Dirs get their perms set during the
3453 * post-extract fixup, which is handled elsewhere.
3454 */
3455 #ifdef HAVE_FCHMOD
3456 if (a->fd >= 0) {
3457 if (fchmod(a->fd, mode) != 0) {
3458 archive_set_error(&a->archive, errno,
3459 "Can't set permissions to 0%o", (int)mode);
3460 r = ARCHIVE_WARN;
3461 }
3462 } else
3463 #endif
3464 /* If this platform lacks fchmod(), then
3465 * we'll just use chmod(). */
3466 if (chmod(a->name, mode) != 0) {
3467 archive_set_error(&a->archive, errno,
3468 "Can't set permissions to 0%o", (int)mode);
3469 r = ARCHIVE_WARN;
3470 }
3471 }
3472 return (r);
3473 }
3474
3475 static int
set_fflags(struct archive_write_disk * a)3476 set_fflags(struct archive_write_disk *a)
3477 {
3478 struct fixup_entry *le;
3479 unsigned long set, clear;
3480 int r;
3481 int critical_flags;
3482 mode_t mode = archive_entry_mode(a->entry);
3483
3484 /*
3485 * Make 'critical_flags' hold all file flags that can't be
3486 * immediately restored. For example, on BSD systems,
3487 * SF_IMMUTABLE prevents hardlinks from being created, so
3488 * should not be set until after any hardlinks are created. To
3489 * preserve some semblance of portability, this uses #ifdef
3490 * extensively. Ugly, but it works.
3491 *
3492 * Yes, Virginia, this does create a security race. It's mitigated
3493 * somewhat by the practice of creating dirs 0700 until the extract
3494 * is done, but it would be nice if we could do more than that.
3495 * People restoring critical file systems should be wary of
3496 * other programs that might try to muck with files as they're
3497 * being restored.
3498 */
3499 /* Hopefully, the compiler will optimize this mess into a constant. */
3500 critical_flags = 0;
3501 #ifdef SF_IMMUTABLE
3502 critical_flags |= SF_IMMUTABLE;
3503 #endif
3504 #ifdef UF_IMMUTABLE
3505 critical_flags |= UF_IMMUTABLE;
3506 #endif
3507 #ifdef SF_APPEND
3508 critical_flags |= SF_APPEND;
3509 #endif
3510 #ifdef UF_APPEND
3511 critical_flags |= UF_APPEND;
3512 #endif
3513 #if defined(FS_APPEND_FL)
3514 critical_flags |= FS_APPEND_FL;
3515 #elif defined(EXT2_APPEND_FL)
3516 critical_flags |= EXT2_APPEND_FL;
3517 #endif
3518 #if defined(FS_IMMUTABLE_FL)
3519 critical_flags |= FS_IMMUTABLE_FL;
3520 #elif defined(EXT2_IMMUTABLE_FL)
3521 critical_flags |= EXT2_IMMUTABLE_FL;
3522 #endif
3523 #ifdef FS_JOURNAL_DATA_FL
3524 critical_flags |= FS_JOURNAL_DATA_FL;
3525 #endif
3526
3527 if (a->todo & TODO_FFLAGS) {
3528 archive_entry_fflags(a->entry, &set, &clear);
3529
3530 /*
3531 * The first test encourages the compiler to eliminate
3532 * all of this if it's not necessary.
3533 */
3534 if ((critical_flags != 0) && (set & critical_flags)) {
3535 le = current_fixup(a, a->name);
3536 if (le == NULL)
3537 return (ARCHIVE_FATAL);
3538 le->fixup |= TODO_FFLAGS;
3539 le->fflags_set = set;
3540 /* Store the mode if it's not already there. */
3541 if ((le->fixup & TODO_MODE) == 0)
3542 le->mode = mode;
3543 } else {
3544 r = set_fflags_platform(a, a->fd,
3545 a->name, mode, set, clear);
3546 if (r != ARCHIVE_OK)
3547 return (r);
3548 }
3549 }
3550 return (ARCHIVE_OK);
3551 }
3552
3553 static int
clear_nochange_fflags(struct archive_write_disk * a)3554 clear_nochange_fflags(struct archive_write_disk *a)
3555 {
3556 int nochange_flags;
3557 mode_t mode = archive_entry_mode(a->entry);
3558
3559 /* Hopefully, the compiler will optimize this mess into a constant. */
3560 nochange_flags = 0;
3561 #ifdef SF_IMMUTABLE
3562 nochange_flags |= SF_IMMUTABLE;
3563 #endif
3564 #ifdef UF_IMMUTABLE
3565 nochange_flags |= UF_IMMUTABLE;
3566 #endif
3567 #ifdef SF_APPEND
3568 nochange_flags |= SF_APPEND;
3569 #endif
3570 #ifdef UF_APPEND
3571 nochange_flags |= UF_APPEND;
3572 #endif
3573 #ifdef EXT2_APPEND_FL
3574 nochange_flags |= EXT2_APPEND_FL;
3575 #endif
3576 #ifdef EXT2_IMMUTABLE_FL
3577 nochange_flags |= EXT2_IMMUTABLE_FL;
3578 #endif
3579
3580 return (set_fflags_platform(a, a->fd, a->name, mode, 0,
3581 nochange_flags));
3582 }
3583
3584
3585 #if ( defined(HAVE_LCHFLAGS) || defined(HAVE_CHFLAGS) || defined(HAVE_FCHFLAGS) ) && defined(HAVE_STRUCT_STAT_ST_FLAGS)
3586 /*
3587 * BSD reads flags using stat() and sets them with one of {f,l,}chflags()
3588 */
3589 static int
set_fflags_platform(struct archive_write_disk * a,int fd,const char * name,mode_t mode,unsigned long set,unsigned long clear)3590 set_fflags_platform(struct archive_write_disk *a, int fd, const char *name,
3591 mode_t mode, unsigned long set, unsigned long clear)
3592 {
3593 int r;
3594
3595 (void)mode; /* UNUSED */
3596 if (set == 0 && clear == 0)
3597 return (ARCHIVE_OK);
3598
3599 /*
3600 * XXX Is the stat here really necessary? Or can I just use
3601 * the 'set' flags directly? In particular, I'm not sure
3602 * about the correct approach if we're overwriting an existing
3603 * file that already has flags on it. XXX
3604 */
3605 if ((r = lazy_stat(a)) != ARCHIVE_OK)
3606 return (r);
3607
3608 a->st.st_flags &= ~clear;
3609 a->st.st_flags |= set;
3610 #ifdef HAVE_FCHFLAGS
3611 /* If platform has fchflags() and we were given an fd, use it. */
3612 if (fd >= 0 && fchflags(fd, a->st.st_flags) == 0)
3613 return (ARCHIVE_OK);
3614 #endif
3615 /*
3616 * If we can't use the fd to set the flags, we'll use the
3617 * pathname to set flags. We prefer lchflags() but will use
3618 * chflags() if we must.
3619 */
3620 #ifdef HAVE_LCHFLAGS
3621 if (lchflags(name, a->st.st_flags) == 0)
3622 return (ARCHIVE_OK);
3623 #elif defined(HAVE_CHFLAGS)
3624 if (S_ISLNK(a->st.st_mode)) {
3625 archive_set_error(&a->archive, errno,
3626 "Can't set file flags on symlink.");
3627 return (ARCHIVE_WARN);
3628 }
3629 if (chflags(name, a->st.st_flags) == 0)
3630 return (ARCHIVE_OK);
3631 #endif
3632 archive_set_error(&a->archive, errno,
3633 "Failed to set file flags");
3634 return (ARCHIVE_WARN);
3635 }
3636
3637 #elif (defined(FS_IOC_GETFLAGS) && defined(FS_IOC_SETFLAGS) && \
3638 defined(HAVE_WORKING_FS_IOC_GETFLAGS)) || \
3639 (defined(EXT2_IOC_GETFLAGS) && defined(EXT2_IOC_SETFLAGS) && \
3640 defined(HAVE_WORKING_EXT2_IOC_GETFLAGS))
3641 /*
3642 * Linux uses ioctl() to read and write file flags.
3643 */
3644 static int
set_fflags_platform(struct archive_write_disk * a,int fd,const char * name,mode_t mode,unsigned long set,unsigned long clear)3645 set_fflags_platform(struct archive_write_disk *a, int fd, const char *name,
3646 mode_t mode, unsigned long set, unsigned long clear)
3647 {
3648 int ret;
3649 int myfd = fd;
3650 int newflags, oldflags;
3651 int sf_mask = 0;
3652
3653 if (set == 0 && clear == 0)
3654 return (ARCHIVE_OK);
3655 /* Only regular files and dirs can have flags. */
3656 if (!S_ISREG(mode) && !S_ISDIR(mode))
3657 return (ARCHIVE_OK);
3658
3659 /* If we weren't given an fd, open it ourselves. */
3660 if (myfd < 0) {
3661 myfd = open(name, O_RDONLY | O_NONBLOCK | O_BINARY | O_CLOEXEC);
3662 __archive_ensure_cloexec_flag(myfd);
3663 }
3664 if (myfd < 0)
3665 return (ARCHIVE_OK);
3666
3667 /*
3668 * Linux has no define for the flags that are only settable by
3669 * the root user. This code may seem a little complex, but
3670 * there seem to be some Linux systems that lack these
3671 * defines. (?) The code below degrades reasonably gracefully
3672 * if sf_mask is incomplete.
3673 */
3674 #if defined(FS_IMMUTABLE_FL)
3675 sf_mask |= FS_IMMUTABLE_FL;
3676 #elif defined(EXT2_IMMUTABLE_FL)
3677 sf_mask |= EXT2_IMMUTABLE_FL;
3678 #endif
3679 #if defined(FS_APPEND_FL)
3680 sf_mask |= FS_APPEND_FL;
3681 #elif defined(EXT2_APPEND_FL)
3682 sf_mask |= EXT2_APPEND_FL;
3683 #endif
3684 #if defined(FS_JOURNAL_DATA_FL)
3685 sf_mask |= FS_JOURNAL_DATA_FL;
3686 #endif
3687 /*
3688 * XXX As above, this would be way simpler if we didn't have
3689 * to read the current flags from disk. XXX
3690 */
3691 ret = ARCHIVE_OK;
3692
3693 /* Read the current file flags. */
3694 if (ioctl(myfd,
3695 #ifdef FS_IOC_GETFLAGS
3696 FS_IOC_GETFLAGS,
3697 #else
3698 EXT2_IOC_GETFLAGS,
3699 #endif
3700 &oldflags) < 0)
3701 goto fail;
3702
3703 /* Try setting the flags as given. */
3704 newflags = (oldflags & ~clear) | set;
3705 if (ioctl(myfd,
3706 #ifdef FS_IOC_SETFLAGS
3707 FS_IOC_SETFLAGS,
3708 #else
3709 EXT2_IOC_SETFLAGS,
3710 #endif
3711 &newflags) >= 0)
3712 goto cleanup;
3713 if (errno != EPERM)
3714 goto fail;
3715
3716 /* If we couldn't set all the flags, try again with a subset. */
3717 newflags &= ~sf_mask;
3718 oldflags &= sf_mask;
3719 newflags |= oldflags;
3720 if (ioctl(myfd,
3721 #ifdef FS_IOC_SETFLAGS
3722 FS_IOC_SETFLAGS,
3723 #else
3724 EXT2_IOC_SETFLAGS,
3725 #endif
3726 &newflags) >= 0)
3727 goto cleanup;
3728
3729 /* We couldn't set the flags, so report the failure. */
3730 fail:
3731 archive_set_error(&a->archive, errno,
3732 "Failed to set file flags");
3733 ret = ARCHIVE_WARN;
3734 cleanup:
3735 if (fd < 0)
3736 close(myfd);
3737 return (ret);
3738 }
3739
3740 #else
3741
3742 /*
3743 * Of course, some systems have neither BSD chflags() nor Linux' flags
3744 * support through ioctl().
3745 */
3746 static int
set_fflags_platform(struct archive_write_disk * a,int fd,const char * name,mode_t mode,unsigned long set,unsigned long clear)3747 set_fflags_platform(struct archive_write_disk *a, int fd, const char *name,
3748 mode_t mode, unsigned long set, unsigned long clear)
3749 {
3750 (void)a; /* UNUSED */
3751 (void)fd; /* UNUSED */
3752 (void)name; /* UNUSED */
3753 (void)mode; /* UNUSED */
3754 (void)set; /* UNUSED */
3755 (void)clear; /* UNUSED */
3756 return (ARCHIVE_OK);
3757 }
3758
3759 #endif /* __linux */
3760
3761 #ifndef HAVE_COPYFILE_H
3762 /* Default is to simply drop Mac extended metadata. */
3763 static int
set_mac_metadata(struct archive_write_disk * a,const char * pathname,const void * metadata,size_t metadata_size)3764 set_mac_metadata(struct archive_write_disk *a, const char *pathname,
3765 const void *metadata, size_t metadata_size)
3766 {
3767 (void)a; /* UNUSED */
3768 (void)pathname; /* UNUSED */
3769 (void)metadata; /* UNUSED */
3770 (void)metadata_size; /* UNUSED */
3771 return (ARCHIVE_OK);
3772 }
3773
3774 static int
fixup_appledouble(struct archive_write_disk * a,const char * pathname)3775 fixup_appledouble(struct archive_write_disk *a, const char *pathname)
3776 {
3777 (void)a; /* UNUSED */
3778 (void)pathname; /* UNUSED */
3779 return (ARCHIVE_OK);
3780 }
3781 #else
3782
3783 /*
3784 * On Mac OS, we use copyfile() to unpack the metadata and
3785 * apply it to the target file.
3786 */
3787
3788 #if defined(HAVE_SYS_XATTR_H)
3789 static int
copy_xattrs(struct archive_write_disk * a,int tmpfd,int dffd)3790 copy_xattrs(struct archive_write_disk *a, int tmpfd, int dffd)
3791 {
3792 ssize_t xattr_size;
3793 char *xattr_names = NULL, *xattr_val = NULL;
3794 int ret = ARCHIVE_OK, xattr_i;
3795
3796 xattr_size = flistxattr(tmpfd, NULL, 0, 0);
3797 if (xattr_size == -1) {
3798 archive_set_error(&a->archive, errno,
3799 "Failed to read metadata(xattr)");
3800 ret = ARCHIVE_WARN;
3801 goto exit_xattr;
3802 }
3803 xattr_names = malloc(xattr_size);
3804 if (xattr_names == NULL) {
3805 archive_set_error(&a->archive, ENOMEM,
3806 "Can't allocate memory for metadata(xattr)");
3807 ret = ARCHIVE_FATAL;
3808 goto exit_xattr;
3809 }
3810 xattr_size = flistxattr(tmpfd, xattr_names, xattr_size, 0);
3811 if (xattr_size == -1) {
3812 archive_set_error(&a->archive, errno,
3813 "Failed to read metadata(xattr)");
3814 ret = ARCHIVE_WARN;
3815 goto exit_xattr;
3816 }
3817 for (xattr_i = 0; xattr_i < xattr_size;
3818 xattr_i += strlen(xattr_names + xattr_i) + 1) {
3819 char *xattr_val_saved;
3820 ssize_t s;
3821 int f;
3822
3823 s = fgetxattr(tmpfd, xattr_names + xattr_i, NULL, 0, 0, 0);
3824 if (s == -1) {
3825 archive_set_error(&a->archive, errno,
3826 "Failed to get metadata(xattr)");
3827 ret = ARCHIVE_WARN;
3828 goto exit_xattr;
3829 }
3830 xattr_val_saved = xattr_val;
3831 xattr_val = realloc(xattr_val, s);
3832 if (xattr_val == NULL) {
3833 archive_set_error(&a->archive, ENOMEM,
3834 "Failed to get metadata(xattr)");
3835 ret = ARCHIVE_WARN;
3836 free(xattr_val_saved);
3837 goto exit_xattr;
3838 }
3839 s = fgetxattr(tmpfd, xattr_names + xattr_i, xattr_val, s, 0, 0);
3840 if (s == -1) {
3841 archive_set_error(&a->archive, errno,
3842 "Failed to get metadata(xattr)");
3843 ret = ARCHIVE_WARN;
3844 goto exit_xattr;
3845 }
3846 f = fsetxattr(dffd, xattr_names + xattr_i, xattr_val, s, 0, 0);
3847 if (f == -1) {
3848 archive_set_error(&a->archive, errno,
3849 "Failed to get metadata(xattr)");
3850 ret = ARCHIVE_WARN;
3851 goto exit_xattr;
3852 }
3853 }
3854 exit_xattr:
3855 free(xattr_names);
3856 free(xattr_val);
3857 return (ret);
3858 }
3859 #endif
3860
3861 static int
copy_acls(struct archive_write_disk * a,int tmpfd,int dffd)3862 copy_acls(struct archive_write_disk *a, int tmpfd, int dffd)
3863 {
3864 #ifndef HAVE_SYS_ACL_H
3865 return 0;
3866 #else
3867 acl_t acl, dfacl = NULL;
3868 int acl_r, ret = ARCHIVE_OK;
3869
3870 acl = acl_get_fd(tmpfd);
3871 if (acl == NULL) {
3872 if (errno == ENOENT)
3873 /* There are not any ACLs. */
3874 return (ret);
3875 archive_set_error(&a->archive, errno,
3876 "Failed to get metadata(acl)");
3877 ret = ARCHIVE_WARN;
3878 goto exit_acl;
3879 }
3880 dfacl = acl_dup(acl);
3881 acl_r = acl_set_fd(dffd, dfacl);
3882 if (acl_r == -1) {
3883 archive_set_error(&a->archive, errno,
3884 "Failed to get metadata(acl)");
3885 ret = ARCHIVE_WARN;
3886 goto exit_acl;
3887 }
3888 exit_acl:
3889 if (acl)
3890 acl_free(acl);
3891 if (dfacl)
3892 acl_free(dfacl);
3893 return (ret);
3894 #endif
3895 }
3896
3897 static int
create_tempdatafork(struct archive_write_disk * a,const char * pathname)3898 create_tempdatafork(struct archive_write_disk *a, const char *pathname)
3899 {
3900 struct archive_string tmpdatafork;
3901 int tmpfd;
3902
3903 archive_string_init(&tmpdatafork);
3904 archive_strcpy(&tmpdatafork, "tar.md.XXXXXX");
3905 tmpfd = mkstemp(tmpdatafork.s);
3906 if (tmpfd < 0) {
3907 archive_set_error(&a->archive, errno,
3908 "Failed to mkstemp");
3909 archive_string_free(&tmpdatafork);
3910 return (-1);
3911 }
3912 if (copyfile(pathname, tmpdatafork.s, 0,
3913 COPYFILE_UNPACK | COPYFILE_NOFOLLOW
3914 | COPYFILE_ACL | COPYFILE_XATTR) < 0) {
3915 archive_set_error(&a->archive, errno,
3916 "Failed to restore metadata");
3917 close(tmpfd);
3918 tmpfd = -1;
3919 }
3920 unlink(tmpdatafork.s);
3921 archive_string_free(&tmpdatafork);
3922 return (tmpfd);
3923 }
3924
3925 static int
copy_metadata(struct archive_write_disk * a,const char * metadata,const char * datafork,int datafork_compressed)3926 copy_metadata(struct archive_write_disk *a, const char *metadata,
3927 const char *datafork, int datafork_compressed)
3928 {
3929 int ret = ARCHIVE_OK;
3930
3931 if (datafork_compressed) {
3932 int dffd, tmpfd;
3933
3934 tmpfd = create_tempdatafork(a, metadata);
3935 if (tmpfd == -1)
3936 return (ARCHIVE_WARN);
3937
3938 /*
3939 * Do not open the data fork compressed by HFS+ compression
3940 * with at least a writing mode(O_RDWR or O_WRONLY). it
3941 * makes the data fork uncompressed.
3942 */
3943 dffd = open(datafork, 0);
3944 if (dffd == -1) {
3945 archive_set_error(&a->archive, errno,
3946 "Failed to open the data fork for metadata");
3947 close(tmpfd);
3948 return (ARCHIVE_WARN);
3949 }
3950
3951 #if defined(HAVE_SYS_XATTR_H)
3952 ret = copy_xattrs(a, tmpfd, dffd);
3953 if (ret == ARCHIVE_OK)
3954 #endif
3955 ret = copy_acls(a, tmpfd, dffd);
3956 close(tmpfd);
3957 close(dffd);
3958 } else {
3959 if (copyfile(metadata, datafork, 0,
3960 COPYFILE_UNPACK | COPYFILE_NOFOLLOW
3961 | COPYFILE_ACL | COPYFILE_XATTR) < 0) {
3962 archive_set_error(&a->archive, errno,
3963 "Failed to restore metadata");
3964 ret = ARCHIVE_WARN;
3965 }
3966 }
3967 return (ret);
3968 }
3969
3970 static int
set_mac_metadata(struct archive_write_disk * a,const char * pathname,const void * metadata,size_t metadata_size)3971 set_mac_metadata(struct archive_write_disk *a, const char *pathname,
3972 const void *metadata, size_t metadata_size)
3973 {
3974 struct archive_string tmp;
3975 ssize_t written;
3976 int fd;
3977 int ret = ARCHIVE_OK;
3978
3979 /* This would be simpler if copyfile() could just accept the
3980 * metadata as a block of memory; then we could sidestep this
3981 * silly dance of writing the data to disk just so that
3982 * copyfile() can read it back in again. */
3983 archive_string_init(&tmp);
3984 archive_strcpy(&tmp, pathname);
3985 archive_strcat(&tmp, ".XXXXXX");
3986 fd = mkstemp(tmp.s);
3987
3988 if (fd < 0) {
3989 archive_set_error(&a->archive, errno,
3990 "Failed to restore metadata");
3991 archive_string_free(&tmp);
3992 return (ARCHIVE_WARN);
3993 }
3994 written = write(fd, metadata, metadata_size);
3995 close(fd);
3996 if ((size_t)written != metadata_size) {
3997 archive_set_error(&a->archive, errno,
3998 "Failed to restore metadata");
3999 ret = ARCHIVE_WARN;
4000 } else {
4001 int compressed;
4002
4003 #if defined(UF_COMPRESSED)
4004 if ((a->todo & TODO_HFS_COMPRESSION) != 0 &&
4005 (ret = lazy_stat(a)) == ARCHIVE_OK)
4006 compressed = a->st.st_flags & UF_COMPRESSED;
4007 else
4008 #endif
4009 compressed = 0;
4010 ret = copy_metadata(a, tmp.s, pathname, compressed);
4011 }
4012 unlink(tmp.s);
4013 archive_string_free(&tmp);
4014 return (ret);
4015 }
4016
4017 static int
fixup_appledouble(struct archive_write_disk * a,const char * pathname)4018 fixup_appledouble(struct archive_write_disk *a, const char *pathname)
4019 {
4020 char buff[8];
4021 struct stat st;
4022 const char *p;
4023 struct archive_string datafork;
4024 int fd = -1, ret = ARCHIVE_OK;
4025
4026 archive_string_init(&datafork);
4027 /* Check if the current file name is a type of the resource
4028 * fork file. */
4029 p = strrchr(pathname, '/');
4030 if (p == NULL)
4031 p = pathname;
4032 else
4033 p++;
4034 if (p[0] != '.' || p[1] != '_')
4035 goto skip_appledouble;
4036
4037 /*
4038 * Check if the data fork file exists.
4039 *
4040 * TODO: Check if this write disk object has handled it.
4041 */
4042 archive_strncpy(&datafork, pathname, p - pathname);
4043 archive_strcat(&datafork, p + 2);
4044 if (lstat(datafork.s, &st) == -1 ||
4045 (st.st_mode & AE_IFMT) != AE_IFREG)
4046 goto skip_appledouble;
4047
4048 /*
4049 * Check if the file is in the AppleDouble form.
4050 */
4051 fd = open(pathname, O_RDONLY | O_BINARY | O_CLOEXEC);
4052 __archive_ensure_cloexec_flag(fd);
4053 if (fd == -1) {
4054 archive_set_error(&a->archive, errno,
4055 "Failed to open a restoring file");
4056 ret = ARCHIVE_WARN;
4057 goto skip_appledouble;
4058 }
4059 if (read(fd, buff, 8) == -1) {
4060 archive_set_error(&a->archive, errno,
4061 "Failed to read a restoring file");
4062 close(fd);
4063 ret = ARCHIVE_WARN;
4064 goto skip_appledouble;
4065 }
4066 close(fd);
4067 /* Check AppleDouble Magic Code. */
4068 if (archive_be32dec(buff) != 0x00051607)
4069 goto skip_appledouble;
4070 /* Check AppleDouble Version. */
4071 if (archive_be32dec(buff+4) != 0x00020000)
4072 goto skip_appledouble;
4073
4074 ret = copy_metadata(a, pathname, datafork.s,
4075 #if defined(UF_COMPRESSED)
4076 st.st_flags & UF_COMPRESSED);
4077 #else
4078 0);
4079 #endif
4080 if (ret == ARCHIVE_OK) {
4081 unlink(pathname);
4082 ret = ARCHIVE_EOF;
4083 }
4084 skip_appledouble:
4085 archive_string_free(&datafork);
4086 return (ret);
4087 }
4088 #endif
4089
4090 #if ARCHIVE_XATTR_LINUX || ARCHIVE_XATTR_DARWIN || ARCHIVE_XATTR_AIX
4091 /*
4092 * Restore extended attributes - Linux, Darwin and AIX implementations:
4093 * AIX' ea interface is syntaxwise identical to the Linux xattr interface.
4094 */
4095 static int
set_xattrs(struct archive_write_disk * a)4096 set_xattrs(struct archive_write_disk *a)
4097 {
4098 struct archive_entry *entry = a->entry;
4099 struct archive_string errlist;
4100 int ret = ARCHIVE_OK;
4101 int i = archive_entry_xattr_reset(entry);
4102 short fail = 0;
4103
4104 archive_string_init(&errlist);
4105
4106 while (i--) {
4107 const char *name;
4108 const void *value;
4109 size_t size;
4110 int e;
4111
4112 archive_entry_xattr_next(entry, &name, &value, &size);
4113
4114 if (name == NULL)
4115 continue;
4116 #if ARCHIVE_XATTR_LINUX
4117 /* Linux: quietly skip POSIX.1e ACL extended attributes */
4118 if (strncmp(name, "system.", 7) == 0 &&
4119 (strcmp(name + 7, "posix_acl_access") == 0 ||
4120 strcmp(name + 7, "posix_acl_default") == 0))
4121 continue;
4122 if (strncmp(name, "trusted.SGI_", 12) == 0 &&
4123 (strcmp(name + 12, "ACL_DEFAULT") == 0 ||
4124 strcmp(name + 12, "ACL_FILE") == 0))
4125 continue;
4126
4127 /* Linux: xfsroot namespace is obsolete and unsupported */
4128 if (strncmp(name, "xfsroot.", 8) == 0) {
4129 fail = 1;
4130 archive_strcat(&errlist, name);
4131 archive_strappend_char(&errlist, ' ');
4132 continue;
4133 }
4134 #endif
4135
4136 if (a->fd >= 0) {
4137 #if ARCHIVE_XATTR_LINUX
4138 e = fsetxattr(a->fd, name, value, size, 0);
4139 #elif ARCHIVE_XATTR_DARWIN
4140 e = fsetxattr(a->fd, name, value, size, 0, 0);
4141 #elif ARCHIVE_XATTR_AIX
4142 e = fsetea(a->fd, name, value, size, 0);
4143 #endif
4144 } else {
4145 #if ARCHIVE_XATTR_LINUX
4146 e = lsetxattr(archive_entry_pathname(entry),
4147 name, value, size, 0);
4148 #elif ARCHIVE_XATTR_DARWIN
4149 e = setxattr(archive_entry_pathname(entry),
4150 name, value, size, 0, XATTR_NOFOLLOW);
4151 #elif ARCHIVE_XATTR_AIX
4152 e = lsetea(archive_entry_pathname(entry),
4153 name, value, size, 0);
4154 #endif
4155 }
4156 if (e == -1) {
4157 ret = ARCHIVE_WARN;
4158 archive_strcat(&errlist, name);
4159 archive_strappend_char(&errlist, ' ');
4160 if (errno != ENOTSUP && errno != ENOSYS)
4161 fail = 1;
4162 }
4163 }
4164
4165 if (ret == ARCHIVE_WARN) {
4166 if (fail && errlist.length > 0) {
4167 errlist.length--;
4168 errlist.s[errlist.length] = '\0';
4169 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
4170 "Cannot restore extended attributes: %s",
4171 errlist.s);
4172 } else
4173 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
4174 "Cannot restore extended "
4175 "attributes on this file system.");
4176 }
4177
4178 archive_string_free(&errlist);
4179 return (ret);
4180 }
4181 #elif ARCHIVE_XATTR_FREEBSD
4182 /*
4183 * Restore extended attributes - FreeBSD implementation
4184 */
4185 static int
set_xattrs(struct archive_write_disk * a)4186 set_xattrs(struct archive_write_disk *a)
4187 {
4188 struct archive_entry *entry = a->entry;
4189 struct archive_string errlist;
4190 int ret = ARCHIVE_OK;
4191 int i = archive_entry_xattr_reset(entry);
4192 short fail = 0;
4193
4194 archive_string_init(&errlist);
4195
4196 while (i--) {
4197 const char *name;
4198 const void *value;
4199 size_t size;
4200 archive_entry_xattr_next(entry, &name, &value, &size);
4201 if (name != NULL) {
4202 int e;
4203 int namespace;
4204
4205 if (strncmp(name, "user.", 5) == 0) {
4206 /* "user." attributes go to user namespace */
4207 name += 5;
4208 namespace = EXTATTR_NAMESPACE_USER;
4209 } else {
4210 /* Other namespaces are unsupported */
4211 archive_strcat(&errlist, name);
4212 archive_strappend_char(&errlist, ' ');
4213 fail = 1;
4214 ret = ARCHIVE_WARN;
4215 continue;
4216 }
4217
4218 if (a->fd >= 0) {
4219 e = extattr_set_fd(a->fd, namespace, name,
4220 value, size);
4221 } else {
4222 e = extattr_set_link(
4223 archive_entry_pathname(entry), namespace,
4224 name, value, size);
4225 }
4226 if (e != (int)size) {
4227 archive_strcat(&errlist, name);
4228 archive_strappend_char(&errlist, ' ');
4229 ret = ARCHIVE_WARN;
4230 if (errno != ENOTSUP && errno != ENOSYS)
4231 fail = 1;
4232 }
4233 }
4234 }
4235
4236 if (ret == ARCHIVE_WARN) {
4237 if (fail && errlist.length > 0) {
4238 errlist.length--;
4239 errlist.s[errlist.length] = '\0';
4240
4241 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
4242 "Cannot restore extended attributes: %s",
4243 errlist.s);
4244 } else
4245 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
4246 "Cannot restore extended "
4247 "attributes on this file system.");
4248 }
4249
4250 archive_string_free(&errlist);
4251 return (ret);
4252 }
4253 #else
4254 /*
4255 * Restore extended attributes - stub implementation for unsupported systems
4256 */
4257 static int
set_xattrs(struct archive_write_disk * a)4258 set_xattrs(struct archive_write_disk *a)
4259 {
4260 static int warning_done = 0;
4261
4262 /* If there aren't any extended attributes, then it's okay not
4263 * to extract them, otherwise, issue a single warning. */
4264 if (archive_entry_xattr_count(a->entry) != 0 && !warning_done) {
4265 warning_done = 1;
4266 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
4267 "Cannot restore extended attributes on this system");
4268 return (ARCHIVE_WARN);
4269 }
4270 /* Warning was already emitted; suppress further warnings. */
4271 return (ARCHIVE_OK);
4272 }
4273 #endif
4274
4275 /*
4276 * Test if file on disk is older than entry.
4277 */
4278 static int
older(struct stat * st,struct archive_entry * entry)4279 older(struct stat *st, struct archive_entry *entry)
4280 {
4281 /* First, test the seconds and return if we have a definite answer. */
4282 /* Definitely older. */
4283 if (to_int64_time(st->st_mtime) < to_int64_time(archive_entry_mtime(entry)))
4284 return (1);
4285 /* Definitely younger. */
4286 if (to_int64_time(st->st_mtime) > to_int64_time(archive_entry_mtime(entry)))
4287 return (0);
4288 /* If this platform supports fractional seconds, try those. */
4289 #if HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC
4290 /* Definitely older. */
4291 if (st->st_mtimespec.tv_nsec < archive_entry_mtime_nsec(entry))
4292 return (1);
4293 #elif HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
4294 /* Definitely older. */
4295 if (st->st_mtim.tv_nsec < archive_entry_mtime_nsec(entry))
4296 return (1);
4297 #elif HAVE_STRUCT_STAT_ST_MTIME_N
4298 /* older. */
4299 if (st->st_mtime_n < archive_entry_mtime_nsec(entry))
4300 return (1);
4301 #elif HAVE_STRUCT_STAT_ST_UMTIME
4302 /* older. */
4303 if (st->st_umtime * 1000 < archive_entry_mtime_nsec(entry))
4304 return (1);
4305 #elif HAVE_STRUCT_STAT_ST_MTIME_USEC
4306 /* older. */
4307 if (st->st_mtime_usec * 1000 < archive_entry_mtime_nsec(entry))
4308 return (1);
4309 #else
4310 /* This system doesn't have high-res timestamps. */
4311 #endif
4312 /* Same age or newer, so not older. */
4313 return (0);
4314 }
4315
4316 #ifndef ARCHIVE_ACL_SUPPORT
4317 int
archive_write_disk_set_acls(struct archive * a,int fd,const char * name,struct archive_acl * abstract_acl,__LA_MODE_T mode)4318 archive_write_disk_set_acls(struct archive *a, int fd, const char *name,
4319 struct archive_acl *abstract_acl, __LA_MODE_T mode)
4320 {
4321 (void)a; /* UNUSED */
4322 (void)fd; /* UNUSED */
4323 (void)name; /* UNUSED */
4324 (void)abstract_acl; /* UNUSED */
4325 (void)mode; /* UNUSED */
4326 return (ARCHIVE_OK);
4327 }
4328 #endif
4329
4330 #endif /* !_WIN32 || __CYGWIN__ */
4331
4332