2 * unix_apply.c - Code to apply files from a WIM image on UNIX.
6 * Copyright (C) 2012-2016 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/.
31 #include <sys/types.h>
34 #include "wimlib/apply.h"
35 #include "wimlib/assert.h"
36 #include "wimlib/blob_table.h"
37 #include "wimlib/dentry.h"
38 #include "wimlib/error.h"
39 #include "wimlib/file_io.h"
40 #include "wimlib/reparse.h"
41 #include "wimlib/timestamp.h"
42 #include "wimlib/unix_data.h"
44 /* We don't require O_NOFOLLOW, but the advantage of having it is that if we
45 * need to extract a file to a location at which there exists a symbolic link,
46 * open(..., O_NOFOLLOW | ...) recognizes the symbolic link rather than
47 * following it and creating the file somewhere else. (Equivalent to
48 * FILE_OPEN_REPARSE_POINT on Windows.) */
54 unix_get_supported_features(const char *target,
55 struct wim_features *supported_features)
57 supported_features->hard_links = 1;
58 supported_features->symlink_reparse_points = 1;
59 supported_features->unix_data = 1;
60 supported_features->timestamps = 1;
61 supported_features->case_sensitive_filenames = 1;
65 #define NUM_PATHBUFS 2 /* We need 2 when creating hard links */
67 struct unix_apply_ctx {
68 /* Extract flags, the pointer to the WIMStruct, etc. */
69 struct apply_ctx common;
71 /* Buffers for building extraction paths (allocated). */
72 char *pathbufs[NUM_PATHBUFS];
74 /* Index of next pathbuf to use */
75 unsigned which_pathbuf;
77 /* Currently open file descriptors for extraction */
78 struct filedes open_fds[MAX_OPEN_FILES];
80 /* Number of currently open file descriptors in open_fds, starting from
81 * the beginning of the array. */
82 unsigned num_open_fds;
84 /* Buffer for reading reparse point data into memory */
85 u8 reparse_data[REPARSE_DATA_MAX_SIZE];
87 /* Pointer to the next byte in @reparse_data to fill */
90 /* Absolute path to the target directory (allocated buffer). Only set
91 * if needed for absolute symbolic link fixups. */
94 /* Number of characters in target_abspath. */
95 size_t target_abspath_nchars;
97 /* Number of special files we couldn't create due to EPERM */
98 unsigned long num_special_files_ignored;
101 /* Returns the number of characters needed to represent the path to the
102 * specified @dentry when extracted, not including the null terminator or the
103 * path to the target directory itself. */
105 unix_dentry_path_length(const struct wim_dentry *dentry)
108 const struct wim_dentry *d;
112 len += d->d_extraction_name_nchars + 1;
114 } while (!dentry_is_root(d) && will_extract_dentry(d));
119 /* Returns the maximum number of characters needed to represent the path to any
120 * dentry in @dentry_list when extracted, including the null terminator and the
121 * path to the target directory itself. */
123 unix_compute_path_max(const struct list_head *dentry_list,
124 const struct unix_apply_ctx *ctx)
128 const struct wim_dentry *dentry;
130 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
131 len = unix_dentry_path_length(dentry);
136 /* Account for target and null terminator. */
137 return ctx->common.target_nchars + max + 1;
140 /* Builds and returns the filesystem path to which to extract @dentry.
141 * This cycles through NUM_PATHBUFS different buffers. */
143 unix_build_extraction_path(const struct wim_dentry *dentry,
144 struct unix_apply_ctx *ctx)
148 const struct wim_dentry *d;
150 pathbuf = ctx->pathbufs[ctx->which_pathbuf];
151 ctx->which_pathbuf = (ctx->which_pathbuf + 1) % NUM_PATHBUFS;
153 p = &pathbuf[ctx->common.target_nchars +
154 unix_dentry_path_length(dentry)];
158 p -= d->d_extraction_name_nchars;
159 if (d->d_extraction_name_nchars)
160 memcpy(p, d->d_extraction_name,
161 d->d_extraction_name_nchars);
164 } while (!dentry_is_root(d) && will_extract_dentry(d));
169 /* This causes the next call to unix_build_extraction_path() to use the same
170 * path buffer as the previous call. */
172 unix_reuse_pathbuf(struct unix_apply_ctx *ctx)
174 ctx->which_pathbuf = (ctx->which_pathbuf - 1) % NUM_PATHBUFS;
177 /* Builds and returns the filesystem path to which to extract an unspecified
178 * alias of the @inode. This cycles through NUM_PATHBUFS different buffers. */
180 unix_build_inode_extraction_path(const struct wim_inode *inode,
181 struct unix_apply_ctx *ctx)
183 return unix_build_extraction_path(inode_first_extraction_dentry(inode), ctx);
186 /* Should the specified file be extracted as a directory on UNIX? We extract
187 * the file as a directory if FILE_ATTRIBUTE_DIRECTORY is set and the file does
188 * not have a symlink or junction reparse point. It *may* have a different type
189 * of reparse point. */
191 should_extract_as_directory(const struct wim_inode *inode)
193 return (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) &&
194 !inode_is_symlink(inode);
197 /* Sets the timestamps on a file being extracted.
199 * Either @fd or @path must be specified (not -1 and not NULL, respectively).
202 unix_set_timestamps(int fd, const char *path, u64 atime, u64 mtime)
205 struct timespec times[2];
207 times[0] = wim_timestamp_to_timespec(atime);
208 times[1] = wim_timestamp_to_timespec(mtime);
212 if (fd >= 0 && !futimens(fd, times))
215 #ifdef HAVE_UTIMENSAT
216 if (fd < 0 && !utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW))
220 return WIMLIB_ERR_SET_TIMESTAMPS;
223 struct timeval times[2];
225 times[0] = wim_timestamp_to_timeval(atime);
226 times[1] = wim_timestamp_to_timeval(mtime);
228 if (fd >= 0 && !futimes(fd, times))
230 if (fd < 0 && !lutimes(path, times))
232 return WIMLIB_ERR_SET_TIMESTAMPS;
237 unix_set_owner_and_group(int fd, const char *path, uid_t uid, gid_t gid)
239 if (fd >= 0 && !fchown(fd, uid, gid))
241 if (fd < 0 && !lchown(path, uid, gid))
243 return WIMLIB_ERR_SET_SECURITY;
247 unix_set_mode(int fd, const char *path, mode_t mode)
249 if (fd >= 0 && !fchmod(fd, mode))
251 if (fd < 0 && !chmod(path, mode))
253 return WIMLIB_ERR_SET_SECURITY;
257 * Set metadata on an extracted file.
259 * @fd is an open file descriptor to the extracted file, or -1. @path is the
260 * path to the extracted file, or NULL. If valid, this function uses @fd.
261 * Otherwise, if valid, it uses @path. Otherwise, it calculates the path to one
262 * alias of the extracted file and uses it.
265 unix_set_metadata(int fd, const struct wim_inode *inode,
266 const char *path, struct unix_apply_ctx *ctx)
269 struct wimlib_unix_data unix_data;
272 path = unix_build_inode_extraction_path(inode, ctx);
274 if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA)
275 && inode_get_unix_data(inode, &unix_data))
277 u32 uid = unix_data.uid;
278 u32 gid = unix_data.gid;
279 u32 mode = unix_data.mode;
281 ret = unix_set_owner_and_group(fd, path, uid, gid);
284 path = unix_build_inode_extraction_path(inode, ctx);
285 if (ctx->common.extract_flags &
286 WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
288 ERROR_WITH_ERRNO("Can't set uid=%"PRIu32" and "
289 "gid=%"PRIu32" on \"%s\"",
293 WARNING_WITH_ERRNO("Can't set uid=%"PRIu32" and "
294 "gid=%"PRIu32" on \"%s\"",
300 if (!inode_is_symlink(inode))
301 ret = unix_set_mode(fd, path, mode);
304 path = unix_build_inode_extraction_path(inode, ctx);
305 if (ctx->common.extract_flags &
306 WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
308 ERROR_WITH_ERRNO("Can't set mode=0%"PRIo32" "
309 "on \"%s\"", mode, path);
312 WARNING_WITH_ERRNO("Can't set mode=0%"PRIo32" "
313 "on \"%s\"", mode, path);
318 ret = unix_set_timestamps(fd, path,
319 inode->i_last_access_time,
320 inode->i_last_write_time);
323 path = unix_build_inode_extraction_path(inode, ctx);
324 if (ctx->common.extract_flags &
325 WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS)
327 ERROR_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
330 WARNING_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
336 /* Extract all needed aliases of the @inode, where one alias, corresponding to
337 * @first_dentry, has already been extracted to @first_path. */
339 unix_create_hardlinks(const struct wim_inode *inode,
340 const struct wim_dentry *first_dentry,
341 const char *first_path, struct unix_apply_ctx *ctx)
343 const struct wim_dentry *dentry;
346 inode_for_each_extraction_alias(dentry, inode) {
347 if (dentry == first_dentry)
350 newpath = unix_build_extraction_path(dentry, ctx);
352 if (link(first_path, newpath)) {
353 if (errno == EEXIST && !unlink(newpath))
355 ERROR_WITH_ERRNO("Can't create hard link "
356 "\"%s\" => \"%s\"", newpath, first_path);
357 return WIMLIB_ERR_LINK;
359 unix_reuse_pathbuf(ctx);
364 /* If @dentry represents a directory, create it. */
366 unix_create_if_directory(const struct wim_dentry *dentry,
367 struct unix_apply_ctx *ctx)
372 if (!should_extract_as_directory(dentry->d_inode))
375 path = unix_build_extraction_path(dentry, ctx);
376 if (mkdir(path, 0755) &&
377 /* It's okay if the path already exists, as long as it's a
379 !(errno == EEXIST && !lstat(path, &stbuf) && S_ISDIR(stbuf.st_mode)))
381 ERROR_WITH_ERRNO("Can't create directory \"%s\"", path);
382 return WIMLIB_ERR_MKDIR;
385 return report_file_created(&ctx->common);
388 /* If @dentry represents an empty regular file or a special file, create it, set
389 * its metadata, and create any needed hard links. */
391 unix_extract_if_empty_file(const struct wim_dentry *dentry,
392 struct unix_apply_ctx *ctx)
394 const struct wim_inode *inode;
395 struct wimlib_unix_data unix_data;
399 inode = dentry->d_inode;
401 /* Extract all aliases only when the "first" comes up. */
402 if (dentry != inode_first_extraction_dentry(inode))
405 /* Is this a directory, a symbolic link, or any type of nonempty file?
407 if (should_extract_as_directory(inode) || inode_is_symlink(inode) ||
408 inode_get_blob_for_unnamed_data_stream_resolved(inode))
411 /* Recognize special files in UNIX_DATA mode */
412 if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) &&
413 inode_get_unix_data(inode, &unix_data) &&
414 !S_ISREG(unix_data.mode))
416 path = unix_build_extraction_path(dentry, ctx);
418 if (mknod(path, unix_data.mode, unix_data.rdev)) {
419 if (errno == EPERM) {
420 WARNING_WITH_ERRNO("Can't create special "
421 "file \"%s\"", path);
422 ctx->num_special_files_ignored++;
425 if (errno == EEXIST && !unlink(path))
427 ERROR_WITH_ERRNO("Can't create special file \"%s\"",
429 return WIMLIB_ERR_MKNOD;
431 /* On special files, we can set timestamps immediately because
432 * we don't need to write any data to them. */
433 ret = unix_set_metadata(-1, inode, path, ctx);
437 path = unix_build_extraction_path(dentry, ctx);
439 fd = open(path, O_EXCL | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
441 if (errno == EEXIST && !unlink(path))
443 ERROR_WITH_ERRNO("Can't create regular file \"%s\"", path);
444 return WIMLIB_ERR_OPEN;
446 /* On empty files, we can set timestamps immediately because we
447 * don't need to write any data to them. */
448 ret = unix_set_metadata(fd, inode, path, ctx);
449 if (close(fd) && !ret) {
450 ERROR_WITH_ERRNO("Error closing \"%s\"", path);
451 ret = WIMLIB_ERR_WRITE;
457 ret = unix_create_hardlinks(inode, dentry, path, ctx);
461 return report_file_created(&ctx->common);
465 unix_create_dirs_and_empty_files(const struct list_head *dentry_list,
466 struct unix_apply_ctx *ctx)
468 const struct wim_dentry *dentry;
471 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
472 ret = unix_create_if_directory(dentry, ctx);
476 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
477 ret = unix_extract_if_empty_file(dentry, ctx);
485 unix_count_dentries(const struct list_head *dentry_list,
486 u64 *dir_count_ret, u64 *empty_file_count_ret)
488 const struct wim_dentry *dentry;
490 u64 empty_file_count = 0;
492 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
494 const struct wim_inode *inode = dentry->d_inode;
496 if (should_extract_as_directory(inode))
498 else if ((dentry == inode_first_extraction_dentry(inode)) &&
499 !inode_is_symlink(inode) &&
500 !inode_get_blob_for_unnamed_data_stream_resolved(inode))
504 *dir_count_ret = dir_count;
505 *empty_file_count_ret = empty_file_count;
509 unix_create_symlink(const struct wim_inode *inode, const char *path,
510 size_t rpdatalen, struct unix_apply_ctx *ctx)
512 char target[REPARSE_POINT_MAX_SIZE];
513 struct blob_descriptor blob_override;
516 blob_set_is_located_in_attached_buffer(&blob_override,
517 ctx->reparse_data, rpdatalen);
519 ret = wim_inode_readlink(inode, target, sizeof(target) - 1,
522 ctx->target_abspath_nchars);
523 if (unlikely(ret < 0)) {
525 return WIMLIB_ERR_READLINK;
530 if (symlink(target, path)) {
531 if (errno == EEXIST && !unlink(path))
533 return WIMLIB_ERR_LINK;
539 unix_cleanup_open_fds(struct unix_apply_ctx *ctx, unsigned offset)
541 for (unsigned i = offset; i < ctx->num_open_fds; i++)
542 filedes_close(&ctx->open_fds[i]);
543 ctx->num_open_fds = 0;
547 unix_begin_extract_blob_instance(const struct blob_descriptor *blob,
548 const struct wim_inode *inode,
549 const struct wim_inode_stream *strm,
550 struct unix_apply_ctx *ctx)
552 const struct wim_dentry *first_dentry;
553 const char *first_path;
556 if (unlikely(strm->stream_type == STREAM_TYPE_REPARSE_POINT)) {
557 /* On UNIX, symbolic links must be created with symlink(), which
558 * requires that the full link target be available. */
559 if (blob->size > REPARSE_DATA_MAX_SIZE) {
560 ERROR_WITH_ERRNO("Reparse data of \"%s\" has size "
561 "%"PRIu64" bytes (exceeds %u bytes)",
562 inode_any_full_path(inode),
563 blob->size, REPARSE_DATA_MAX_SIZE);
564 return WIMLIB_ERR_INVALID_REPARSE_DATA;
566 ctx->reparse_ptr = ctx->reparse_data;
570 wimlib_assert(stream_is_unnamed_data_stream(strm));
572 /* Unnamed data stream of "regular" file */
574 /* This should be ensured by extract_blob_list() */
575 wimlib_assert(ctx->num_open_fds < MAX_OPEN_FILES);
577 first_dentry = inode_first_extraction_dentry(inode);
578 first_path = unix_build_extraction_path(first_dentry, ctx);
580 fd = open(first_path, O_EXCL | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
582 if (errno == EEXIST && !unlink(first_path))
584 ERROR_WITH_ERRNO("Can't create regular file \"%s\"", first_path);
585 return WIMLIB_ERR_OPEN;
587 filedes_init(&ctx->open_fds[ctx->num_open_fds++], fd);
588 return unix_create_hardlinks(inode, first_dentry, first_path, ctx);
591 /* Called when starting to read a blob for extraction */
593 unix_begin_extract_blob(struct blob_descriptor *blob, void *_ctx)
595 struct unix_apply_ctx *ctx = _ctx;
596 const struct blob_extraction_target *targets = blob_extraction_targets(blob);
598 for (u32 i = 0; i < blob->out_refcnt; i++) {
599 int ret = unix_begin_extract_blob_instance(blob,
604 ctx->reparse_ptr = NULL;
605 unix_cleanup_open_fds(ctx, 0);
612 /* Called when the next chunk of a blob has been read for extraction */
614 unix_extract_chunk(const struct blob_descriptor *blob, u64 offset,
615 const void *chunk, size_t size, void *_ctx)
617 struct unix_apply_ctx *ctx = _ctx;
620 for (unsigned i = 0; i < ctx->num_open_fds; i++) {
621 ret = full_write(&ctx->open_fds[i], chunk, size);
623 ERROR_WITH_ERRNO("Error writing data to filesystem");
627 if (ctx->reparse_ptr)
628 ctx->reparse_ptr = mempcpy(ctx->reparse_ptr, chunk, size);
632 /* Called when a blob has been fully read for extraction */
634 unix_end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx)
636 struct unix_apply_ctx *ctx = _ctx;
639 const struct blob_extraction_target *targets = blob_extraction_targets(blob);
641 ctx->reparse_ptr = NULL;
644 unix_cleanup_open_fds(ctx, 0);
650 for (u32 i = 0; i < blob->out_refcnt; i++) {
651 struct wim_inode *inode = targets[i].inode;
653 if (inode_is_symlink(inode)) {
654 /* We finally have the symlink data, so we can create
658 path = unix_build_inode_extraction_path(inode, ctx);
659 ret = unix_create_symlink(inode, path, blob->size, ctx);
661 ERROR_WITH_ERRNO("Can't create symbolic link "
665 ret = unix_set_metadata(-1, inode, path, ctx);
669 /* Set metadata on regular file just before closing it.
671 struct filedes *fd = &ctx->open_fds[j];
673 ret = unix_set_metadata(fd->fd, inode, NULL, ctx);
677 if (filedes_close(fd)) {
678 ERROR_WITH_ERRNO("Error closing \"%s\"",
679 unix_build_inode_extraction_path(inode, ctx));
680 ret = WIMLIB_ERR_WRITE;
686 unix_cleanup_open_fds(ctx, j);
691 unix_set_dir_metadata(struct list_head *dentry_list, struct unix_apply_ctx *ctx)
693 const struct wim_dentry *dentry;
696 list_for_each_entry_reverse(dentry, dentry_list, d_extraction_list_node) {
697 if (should_extract_as_directory(dentry->d_inode)) {
698 ret = unix_set_metadata(-1, dentry->d_inode, NULL, ctx);
701 ret = report_file_metadata_applied(&ctx->common);
710 unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
713 struct unix_apply_ctx *ctx = (struct unix_apply_ctx *)_ctx;
716 u64 empty_file_count;
718 /* Compute the maximum path length that will be needed, then allocate
719 * some path buffers. */
720 path_max = unix_compute_path_max(dentry_list, ctx);
722 for (unsigned i = 0; i < NUM_PATHBUFS; i++) {
723 ctx->pathbufs[i] = MALLOC(path_max);
724 if (!ctx->pathbufs[i]) {
725 ret = WIMLIB_ERR_NOMEM;
728 /* Pre-fill the target in each path buffer. We'll just append
729 * the rest of the paths after this. */
730 memcpy(ctx->pathbufs[i],
731 ctx->common.target, ctx->common.target_nchars);
734 /* Extract directories and empty regular files. Directories are needed
735 * because we can't extract any other files until their directories
736 * exist. Empty files are needed because they don't have
737 * representatives in the blob list. */
739 unix_count_dentries(dentry_list, &dir_count, &empty_file_count);
741 ret = start_file_structure_phase(&ctx->common, dir_count + empty_file_count);
745 ret = unix_create_dirs_and_empty_files(dentry_list, ctx);
749 ret = end_file_structure_phase(&ctx->common);
753 /* Get full path to target if needed for absolute symlink fixups. */
754 if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) &&
755 ctx->common.required_features.symlink_reparse_points)
757 ctx->target_abspath = realpath(ctx->common.target, NULL);
758 if (!ctx->target_abspath) {
759 ret = WIMLIB_ERR_NOMEM;
762 ctx->target_abspath_nchars = strlen(ctx->target_abspath);
765 /* Extract nonempty regular files and symbolic links. */
767 struct read_blob_callbacks cbs = {
768 .begin_blob = unix_begin_extract_blob,
769 .continue_blob = unix_extract_chunk,
770 .end_blob = unix_end_extract_blob,
773 ret = extract_blob_list(&ctx->common, &cbs);
778 /* Set directory metadata. We do this last so that we get the right
779 * directory timestamps. */
780 ret = start_file_metadata_phase(&ctx->common, dir_count);
784 ret = unix_set_dir_metadata(dentry_list, ctx);
788 ret = end_file_metadata_phase(&ctx->common);
792 if (ctx->num_special_files_ignored) {
793 WARNING("%lu special files were not extracted due to EPERM!",
794 ctx->num_special_files_ignored);
797 for (unsigned i = 0; i < NUM_PATHBUFS; i++)
798 FREE(ctx->pathbufs[i]);
799 FREE(ctx->target_abspath);
803 const struct apply_operations unix_apply_ops = {
805 .get_supported_features = unix_get_supported_features,
806 .extract = unix_extract,
807 .context_size = sizeof(struct unix_apply_ctx),