2 * unix_apply.c - Code to apply files from a WIM image on UNIX.
6 * Copyright (C) 2012, 2013, 2014 Eric Biggers
8 * This file is free software; you can redistribute it and/or modify it under
9 * the terms of the GNU Lesser General Public License as published by the Free
10 * Software Foundation; either version 3 of the License, or (at your option) any
13 * This file is distributed in the hope that it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this file; if not, see http://www.gnu.org/licenses/.
26 #include "wimlib/apply.h"
27 #include "wimlib/assert.h"
28 #include "wimlib/dentry.h"
29 #include "wimlib/error.h"
30 #include "wimlib/file_io.h"
31 #include "wimlib/lookup_table.h"
32 #include "wimlib/reparse.h"
33 #include "wimlib/timestamp.h"
34 #include "wimlib/unix_data.h"
42 #include <sys/types.h>
45 /* We don't require O_NOFOLLOW, but the advantage of having it is that if we
46 * need to extract a file to a location at which there exists a symbolic link,
47 * open(..., O_NOFOLLOW | ...) recognizes the symbolic link rather than
48 * following it and creating the file somewhere else. (Equivalent to
49 * FILE_OPEN_REPARSE_POINT on Windows.) */
55 unix_get_supported_features(const char *target,
56 struct wim_features *supported_features)
58 supported_features->hard_links = 1;
59 supported_features->symlink_reparse_points = 1;
60 supported_features->unix_data = 1;
61 supported_features->timestamps = 1;
62 supported_features->case_sensitive_filenames = 1;
66 #define NUM_PATHBUFS 2 /* We need 2 when creating hard links */
68 struct unix_apply_ctx {
69 /* Extract flags, the pointer to the WIMStruct, etc. */
70 struct apply_ctx common;
72 /* Buffers for building extraction paths (allocated). */
73 char *pathbufs[NUM_PATHBUFS];
75 /* Index of next pathbuf to use */
76 unsigned which_pathbuf;
78 /* Currently open file descriptors for extraction */
79 struct filedes open_fds[MAX_OPEN_STREAMS];
81 /* Number of currently open file descriptors in open_fds, starting from
82 * the beginning of the array. */
83 unsigned num_open_fds;
85 /* Buffer for reading reparse data streams into memory */
86 u8 reparse_data[REPARSE_DATA_MAX_SIZE];
88 /* Pointer to the next byte in @reparse_data to fill */
91 /* Absolute path to the target directory (allocated buffer). Only set
92 * if needed for absolute symbolic link fixups. */
95 /* Number of characters in target_abspath. */
96 size_t target_abspath_nchars;
98 /* Number of special files we couldn't create due to EPERM */
99 unsigned long num_special_files_ignored;
102 /* Returns the number of characters needed to represent the path to the
103 * specified @dentry when extracted, not including the null terminator or the
104 * path to the target directory itself. */
106 unix_dentry_path_length(const struct wim_dentry *dentry)
109 const struct wim_dentry *d;
113 len += d->d_extraction_name_nchars + 1;
115 } while (!dentry_is_root(d) && will_extract_dentry(d));
120 /* Returns the maximum number of characters needed to represent the path to any
121 * dentry in @dentry_list when extracted, including the null terminator and the
122 * path to the target directory itself. */
124 unix_compute_path_max(const struct list_head *dentry_list,
125 const struct unix_apply_ctx *ctx)
129 const struct wim_dentry *dentry;
131 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
132 len = unix_dentry_path_length(dentry);
137 /* Account for target and null terminator. */
138 return ctx->common.target_nchars + max + 1;
141 /* Builds and returns the filesystem path to which to extract @dentry.
142 * This cycles through NUM_PATHBUFS different buffers. */
144 unix_build_extraction_path(const struct wim_dentry *dentry,
145 struct unix_apply_ctx *ctx)
149 const struct wim_dentry *d;
151 pathbuf = ctx->pathbufs[ctx->which_pathbuf];
152 ctx->which_pathbuf = (ctx->which_pathbuf + 1) % NUM_PATHBUFS;
154 p = &pathbuf[ctx->common.target_nchars +
155 unix_dentry_path_length(dentry)];
159 p -= d->d_extraction_name_nchars;
160 memcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
163 } while (!dentry_is_root(d) && will_extract_dentry(d));
168 /* This causes the next call to unix_build_extraction_path() to use the same
169 * path buffer as the previous call. */
171 unix_reuse_pathbuf(struct unix_apply_ctx *ctx)
173 ctx->which_pathbuf = (ctx->which_pathbuf - 1) % NUM_PATHBUFS;
176 /* Builds and returns the filesystem path to which to extract an unspecified
177 * alias of the @inode. This cycles through NUM_PATHBUFS different buffers. */
179 unix_build_inode_extraction_path(const struct wim_inode *inode,
180 struct unix_apply_ctx *ctx)
182 return unix_build_extraction_path(inode_first_extraction_dentry(inode), ctx);
185 /* Sets the timestamps on a file being extracted.
187 * Either @fd or @path must be specified (not -1 and not NULL, respectively).
190 unix_set_timestamps(int fd, const char *path, u64 atime, u64 mtime)
193 struct timespec times[2];
195 times[0] = wim_timestamp_to_timespec(atime);
196 times[1] = wim_timestamp_to_timespec(mtime);
200 if (fd >= 0 && !futimens(fd, times))
203 #ifdef HAVE_UTIMENSAT
204 if (fd < 0 && !utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW))
208 return WIMLIB_ERR_SET_TIMESTAMPS;
211 struct timeval times[2];
213 times[0] = wim_timestamp_to_timeval(atime);
214 times[1] = wim_timestamp_to_timeval(mtime);
216 if (fd >= 0 && !futimes(fd, times))
218 if (fd < 0 && !lutimes(path, times))
220 return WIMLIB_ERR_SET_TIMESTAMPS;
225 unix_set_owner_and_group(int fd, const char *path, uid_t uid, gid_t gid)
227 if (fd >= 0 && !fchown(fd, uid, gid))
229 if (fd < 0 && !lchown(path, uid, gid))
231 return WIMLIB_ERR_SET_SECURITY;
235 unix_set_mode(int fd, const char *path, mode_t mode)
237 if (fd >= 0 && !fchmod(fd, mode))
239 if (fd < 0 && !chmod(path, mode))
241 return WIMLIB_ERR_SET_SECURITY;
245 * Set metadata on an extracted file.
247 * @fd is an open file descriptor to the extracted file, or -1. @path is the
248 * path to the extracted file, or NULL. If valid, this function uses @fd.
249 * Otherwise, if valid, it uses @path. Otherwise, it calculates the path to one
250 * alias of the extracted file and uses it.
253 unix_set_metadata(int fd, const struct wim_inode *inode,
254 const char *path, struct unix_apply_ctx *ctx)
257 struct wimlib_unix_data unix_data;
260 path = unix_build_inode_extraction_path(inode, ctx);
262 if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA)
263 && inode_get_unix_data(inode, &unix_data))
265 u32 uid = unix_data.uid;
266 u32 gid = unix_data.gid;
267 u32 mode = unix_data.mode;
269 ret = unix_set_owner_and_group(fd, path, uid, gid);
272 path = unix_build_inode_extraction_path(inode, ctx);
273 if (ctx->common.extract_flags &
274 WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
276 ERROR_WITH_ERRNO("Can't set uid=%"PRIu32" and "
277 "gid=%"PRIu32" on \"%s\"",
281 WARNING_WITH_ERRNO("Can't set uid=%"PRIu32" and "
282 "gid=%"PRIu32" on \"%s\"",
288 if (!inode_is_symlink(inode))
289 ret = unix_set_mode(fd, path, mode);
292 path = unix_build_inode_extraction_path(inode, ctx);
293 if (ctx->common.extract_flags &
294 WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
296 ERROR_WITH_ERRNO("Can't set mode=0%"PRIo32" "
297 "on \"%s\"", mode, path);
300 WARNING_WITH_ERRNO("Can't set mode=0%"PRIo32" "
301 "on \"%s\"", mode, path);
306 ret = unix_set_timestamps(fd, path,
307 inode->i_last_access_time,
308 inode->i_last_write_time);
311 path = unix_build_inode_extraction_path(inode, ctx);
312 if (ctx->common.extract_flags &
313 WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS)
315 ERROR_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
318 WARNING_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
324 /* Extract all needed aliases of the @inode, where one alias, corresponding to
325 * @first_dentry, has already been extracted to @first_path. */
327 unix_create_hardlinks(const struct wim_inode *inode,
328 const struct wim_dentry *first_dentry,
329 const char *first_path, struct unix_apply_ctx *ctx)
331 const struct wim_dentry *dentry;
334 list_for_each_entry(dentry, &inode->i_extraction_aliases,
335 d_extraction_alias_node)
337 if (dentry == first_dentry)
340 newpath = unix_build_extraction_path(dentry, ctx);
342 if (link(first_path, newpath)) {
343 if (errno == EEXIST && !unlink(newpath))
345 ERROR_WITH_ERRNO("Can't create hard link "
346 "\"%s\" => \"%s\"", newpath, first_path);
347 return WIMLIB_ERR_LINK;
349 unix_reuse_pathbuf(ctx);
354 /* If @dentry represents a directory, create it. */
356 unix_create_if_directory(const struct wim_dentry *dentry,
357 struct unix_apply_ctx *ctx)
362 if (!dentry_is_directory(dentry))
365 path = unix_build_extraction_path(dentry, ctx);
366 if (mkdir(path, 0755) &&
367 /* It's okay if the path already exists, as long as it's a
369 !(errno == EEXIST && !lstat(path, &stbuf) && S_ISDIR(stbuf.st_mode)))
371 ERROR_WITH_ERRNO("Can't create directory \"%s\"", path);
372 return WIMLIB_ERR_MKDIR;
375 return report_file_created(&ctx->common);
378 /* If @dentry represents an empty regular file or a special file, create it, set
379 * its metadata, and create any needed hard links. */
381 unix_extract_if_empty_file(const struct wim_dentry *dentry,
382 struct unix_apply_ctx *ctx)
384 const struct wim_inode *inode;
385 struct wimlib_unix_data unix_data;
389 inode = dentry->d_inode;
391 /* Extract all aliases only when the "first" comes up. */
392 if (dentry != inode_first_extraction_dentry(inode))
395 /* Is this a directory, a symbolic link, or any type of nonempty file?
397 if (inode_is_directory(inode) || inode_is_symlink(inode) ||
398 inode_unnamed_lte_resolved(inode))
401 /* Recognize special files in UNIX_DATA mode */
402 if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) &&
403 inode_get_unix_data(inode, &unix_data) &&
404 !S_ISREG(unix_data.mode))
406 path = unix_build_extraction_path(dentry, ctx);
408 if (mknod(path, unix_data.mode, unix_data.rdev)) {
409 if (errno == EPERM) {
410 WARNING_WITH_ERRNO("Can't create special "
411 "file \"%s\"", path);
412 ctx->num_special_files_ignored++;
415 if (errno == EEXIST && !unlink(path))
417 ERROR_WITH_ERRNO("Can't create special file \"%s\"",
419 return WIMLIB_ERR_MKNOD;
421 /* On special files, we can set timestamps immediately because
422 * we don't need to write any data to them. */
423 ret = unix_set_metadata(-1, inode, path, ctx);
427 path = unix_build_extraction_path(dentry, ctx);
429 fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
431 if (errno == EEXIST && !unlink(path))
433 ERROR_WITH_ERRNO("Can't create regular file \"%s\"", path);
434 return WIMLIB_ERR_OPEN;
436 /* On empty files, we can set timestamps immediately because we
437 * don't need to write any data to them. */
438 ret = unix_set_metadata(fd, inode, path, ctx);
439 if (close(fd) && !ret) {
440 ERROR_WITH_ERRNO("Error closing \"%s\"", path);
441 ret = WIMLIB_ERR_WRITE;
447 ret = unix_create_hardlinks(inode, dentry, path, ctx);
451 return report_file_created(&ctx->common);
455 unix_create_dirs_and_empty_files(const struct list_head *dentry_list,
456 struct unix_apply_ctx *ctx)
458 const struct wim_dentry *dentry;
461 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
462 ret = unix_create_if_directory(dentry, ctx);
466 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
467 ret = unix_extract_if_empty_file(dentry, ctx);
475 unix_count_dentries(const struct list_head *dentry_list,
476 uint64_t *dir_count_ret, uint64_t *empty_file_count_ret)
478 const struct wim_dentry *dentry;
479 uint64_t dir_count = 0;
480 uint64_t empty_file_count = 0;
482 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
484 const struct wim_inode *inode = dentry->d_inode;
486 if (inode_is_directory(inode))
488 else if ((dentry == inode_first_extraction_dentry(inode)) &&
489 !inode_unnamed_lte_resolved(inode))
493 *dir_count_ret = dir_count;
494 *empty_file_count_ret = empty_file_count;
498 unix_create_symlink(const struct wim_inode *inode, const char *path,
499 const u8 *rpdata, u16 rpdatalen, bool rpfix,
500 const char *apply_dir, size_t apply_dir_nchars)
502 char link_target[REPARSE_DATA_MAX_SIZE];
504 struct wim_lookup_table_entry lte_override;
506 lte_override.resource_location = RESOURCE_IN_ATTACHED_BUFFER;
507 lte_override.attached_buffer = (void *)rpdata;
508 lte_override.size = rpdatalen;
510 ret = wim_inode_readlink(inode, link_target,
511 sizeof(link_target) - 1, <e_override);
514 return WIMLIB_ERR_READLINK;
517 link_target[ret] = 0;
519 if (rpfix && link_target[0] == '/') {
521 /* "Fix" the absolute symbolic link by prepending the absolute
522 * path to the target directory. */
524 if (sizeof(link_target) - (ret + 1) < apply_dir_nchars) {
525 errno = ENAMETOOLONG;
526 return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED;
528 memmove(link_target + apply_dir_nchars, link_target,
530 memcpy(link_target, apply_dir, apply_dir_nchars);
533 if (symlink(link_target, path)) {
534 if (errno == EEXIST && !unlink(path))
536 return WIMLIB_ERR_LINK;
542 unix_cleanup_open_fds(struct unix_apply_ctx *ctx, unsigned offset)
544 for (unsigned i = offset; i < ctx->num_open_fds; i++)
545 filedes_close(&ctx->open_fds[i]);
546 ctx->num_open_fds = 0;
550 unix_begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
551 const struct wim_inode *inode,
552 struct unix_apply_ctx *ctx)
554 const struct wim_dentry *first_dentry;
555 const char *first_path;
558 if (inode_is_symlink(inode)) {
559 /* On UNIX, symbolic links must be created with symlink(), which
560 * requires that the full link target be available. */
561 if (stream->size > REPARSE_DATA_MAX_SIZE) {
562 ERROR_WITH_ERRNO("Reparse data of \"%s\" has size "
563 "%"PRIu64" bytes (exceeds %u bytes)",
564 inode_first_full_path(inode),
565 stream->size, REPARSE_DATA_MAX_SIZE);
566 return WIMLIB_ERR_INVALID_REPARSE_DATA;
568 ctx->reparse_ptr = ctx->reparse_data;
572 /* This should be ensured by extract_stream_list() */
573 wimlib_assert(ctx->num_open_fds < MAX_OPEN_STREAMS);
575 first_dentry = inode_first_extraction_dentry(inode);
576 first_path = unix_build_extraction_path(first_dentry, ctx);
578 fd = open(first_path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
580 if (errno == EEXIST && !unlink(first_path))
582 ERROR_WITH_ERRNO("Can't create regular file \"%s\"", first_path);
583 return WIMLIB_ERR_OPEN;
585 filedes_init(&ctx->open_fds[ctx->num_open_fds++], fd);
586 return unix_create_hardlinks(inode, first_dentry, first_path, ctx);
589 /* Called when starting to read a single-instance stream for extraction */
591 unix_begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx)
593 struct unix_apply_ctx *ctx = _ctx;
594 const struct stream_owner *owners = stream_owners(stream);
597 for (u32 i = 0; i < stream->out_refcnt; i++) {
598 const struct wim_inode *inode = owners[i].inode;
600 ret = unix_begin_extract_stream_instance(stream, inode, ctx);
602 ctx->reparse_ptr = NULL;
603 unix_cleanup_open_fds(ctx, 0);
610 /* Called when the next chunk of a single-instance stream has been read for
613 unix_extract_chunk(const void *chunk, size_t size, void *_ctx)
615 struct unix_apply_ctx *ctx = _ctx;
618 for (unsigned i = 0; i < ctx->num_open_fds; i++) {
619 ret = full_write(&ctx->open_fds[i], chunk, size);
621 ERROR_WITH_ERRNO("Error writing data to filesystem");
625 if (ctx->reparse_ptr)
626 ctx->reparse_ptr = mempcpy(ctx->reparse_ptr, chunk, size);
630 /* Called when a single-instance stream has been fully read for extraction */
632 unix_end_extract_stream(struct wim_lookup_table_entry *stream, int status,
635 struct unix_apply_ctx *ctx = _ctx;
638 const struct stream_owner *owners = stream_owners(stream);
640 ctx->reparse_ptr = NULL;
643 unix_cleanup_open_fds(ctx, 0);
649 for (u32 i = 0; i < stream->out_refcnt; i++) {
650 struct wim_inode *inode = owners[i].inode;
652 if (inode_is_symlink(inode)) {
653 /* We finally have the symlink data, so we can create
658 rpfix = (ctx->common.extract_flags &
659 WIMLIB_EXTRACT_FLAG_RPFIX) &&
660 !inode->i_not_rpfixed;
662 path = unix_build_inode_extraction_path(inode, ctx);
663 ret = unix_create_symlink(inode, path,
668 ctx->target_abspath_nchars);
670 ERROR_WITH_ERRNO("Can't create symbolic link "
674 ret = unix_set_metadata(-1, inode, path, ctx);
678 /* Set metadata on regular file just before closing it.
680 struct filedes *fd = &ctx->open_fds[j];
682 ret = unix_set_metadata(fd->fd, inode, NULL, ctx);
686 if (filedes_close(fd)) {
687 ERROR_WITH_ERRNO("Error closing \"%s\"",
688 unix_build_inode_extraction_path(inode, ctx));
689 ret = WIMLIB_ERR_WRITE;
695 unix_cleanup_open_fds(ctx, j);
700 unix_set_dir_metadata(struct list_head *dentry_list, struct unix_apply_ctx *ctx)
702 const struct wim_dentry *dentry;
705 list_for_each_entry_reverse(dentry, dentry_list, d_extraction_list_node) {
706 if (dentry_is_directory(dentry)) {
707 ret = unix_set_metadata(-1, dentry->d_inode, NULL, ctx);
710 ret = report_file_metadata_applied(&ctx->common);
719 unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
722 struct unix_apply_ctx *ctx = (struct unix_apply_ctx *)_ctx;
725 uint64_t empty_file_count;
727 /* Compute the maximum path length that will be needed, then allocate
728 * some path buffers. */
729 path_max = unix_compute_path_max(dentry_list, ctx);
731 for (unsigned i = 0; i < NUM_PATHBUFS; i++) {
732 ctx->pathbufs[i] = MALLOC(path_max);
733 if (!ctx->pathbufs[i]) {
734 ret = WIMLIB_ERR_NOMEM;
737 /* Pre-fill the target in each path buffer. We'll just append
738 * the rest of the paths after this. */
739 memcpy(ctx->pathbufs[i],
740 ctx->common.target, ctx->common.target_nchars);
743 /* Extract directories and empty regular files. Directories are needed
744 * because we can't extract any other files until their directories
745 * exist. Empty files are needed because they don't have
746 * representatives in the stream list. */
748 unix_count_dentries(dentry_list, &dir_count, &empty_file_count);
750 ret = start_file_structure_phase(&ctx->common, dir_count + empty_file_count);
754 ret = unix_create_dirs_and_empty_files(dentry_list, ctx);
758 ret = end_file_structure_phase(&ctx->common);
762 /* Get full path to target if needed for absolute symlink fixups. */
763 if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) &&
764 ctx->common.required_features.symlink_reparse_points)
766 ctx->target_abspath = realpath(ctx->common.target, NULL);
767 if (!ctx->target_abspath) {
768 ret = WIMLIB_ERR_NOMEM;
771 ctx->target_abspath_nchars = strlen(ctx->target_abspath);
774 /* Extract nonempty regular files and symbolic links. */
776 struct read_stream_list_callbacks cbs = {
777 .begin_stream = unix_begin_extract_stream,
778 .begin_stream_ctx = ctx,
779 .consume_chunk = unix_extract_chunk,
780 .consume_chunk_ctx = ctx,
781 .end_stream = unix_end_extract_stream,
782 .end_stream_ctx = ctx,
784 ret = extract_stream_list(&ctx->common, &cbs);
789 /* Set directory metadata. We do this last so that we get the right
790 * directory timestamps. */
791 ret = start_file_metadata_phase(&ctx->common, dir_count);
795 ret = unix_set_dir_metadata(dentry_list, ctx);
799 ret = end_file_metadata_phase(&ctx->common);
803 if (ctx->num_special_files_ignored) {
804 WARNING("%lu special files were not extracted due to EPERM!",
805 ctx->num_special_files_ignored);
808 for (unsigned i = 0; i < NUM_PATHBUFS; i++)
809 FREE(ctx->pathbufs[i]);
810 FREE(ctx->target_abspath);
814 const struct apply_operations unix_apply_ops = {
816 .get_supported_features = unix_get_supported_features,
817 .extract = unix_extract,
818 .context_size = sizeof(struct unix_apply_ctx),