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 part of wimlib, a library for working with WIM files.
10 * wimlib is free software; you can redistribute it and/or modify it under the
11 * terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 3 of the License, or (at your option)
15 * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
16 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 * A PARTICULAR PURPOSE. See the GNU General Public License for more
20 * You should have received a copy of the GNU General Public License
21 * along with wimlib; if not, see http://www.gnu.org/licenses/.
28 #include "wimlib/apply.h"
29 #include "wimlib/dentry.h"
30 #include "wimlib/error.h"
31 #include "wimlib/file_io.h"
32 #include "wimlib/reparse.h"
33 #include "wimlib/timestamp.h"
41 #include <sys/types.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 */
66 #define MAX_OPEN_FDS 1024 /* TODO: Add special case for when the number of
67 identical streams exceeds this number. */
69 struct unix_apply_ctx {
70 /* Extract flags, the pointer to the WIMStruct, etc. */
71 struct apply_ctx common;
73 /* Buffers for building extraction paths (allocated). */
74 char *pathbufs[NUM_PATHBUFS];
76 /* Index of next pathbuf to use */
77 unsigned which_pathbuf;
79 /* Currently open file descriptors for extraction */
80 struct filedes open_fds[MAX_OPEN_FDS];
82 /* Number of currently open file descriptors in open_fds, starting from
83 * the beginning of the array. */
84 unsigned num_open_fds;
86 /* Buffer for reading reparse data streams into memory */
87 u8 reparse_data[REPARSE_DATA_MAX_SIZE];
89 /* Pointer to the next byte in @reparse_data to fill */
92 /* Absolute path to the target directory (allocated buffer). Only set
93 * if needed for absolute symbolic link fixups. */
96 /* Number of characters in target_abspath. */
97 size_t target_abspath_nchars;
100 /* Returns the number of characters needed to represent the path to the
101 * specified @dentry when extracted, not including the null terminator or the
102 * path to the target directory itself. */
104 unix_dentry_path_length(const struct wim_dentry *dentry)
107 const struct wim_dentry *d;
111 len += d->d_extraction_name_nchars + 1;
113 } while (!dentry_is_root(d) && will_extract_dentry(d));
118 /* Returns the maximum number of characters needed to represent the path to any
119 * dentry in @dentry_list when extracted, including the null terminator and the
120 * path to the target directory itself. */
122 unix_compute_path_max(const struct list_head *dentry_list,
123 const struct unix_apply_ctx *ctx)
127 const struct wim_dentry *dentry;
129 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
130 len = unix_dentry_path_length(dentry);
135 /* Account for target and null terminator. */
136 return ctx->common.target_nchars + max + 1;
139 /* Builds and returns the filesystem path to which to extract @dentry.
140 * This cycles through NUM_PATHBUFS different buffers. */
142 unix_build_extraction_path(const struct wim_dentry *dentry,
143 struct unix_apply_ctx *ctx)
147 const struct wim_dentry *d;
149 pathbuf = ctx->pathbufs[ctx->which_pathbuf];
150 ctx->which_pathbuf = (ctx->which_pathbuf + 1) % NUM_PATHBUFS;
152 p = &pathbuf[ctx->common.target_nchars +
153 unix_dentry_path_length(dentry)];
157 p -= d->d_extraction_name_nchars;
158 memcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
161 } while (!dentry_is_root(d) && will_extract_dentry(d));
166 /* This causes the next call to unix_build_extraction_path() to use the same
167 * path buffer as the previous call. */
169 unix_reuse_pathbuf(struct unix_apply_ctx *ctx)
171 ctx->which_pathbuf = (ctx->which_pathbuf - 1) % NUM_PATHBUFS;
174 /* Builds and returns the filesystem path to which to extract an unspecified
175 * alias of the @inode. This cycles through NUM_PATHBUFS different buffers. */
177 unix_build_inode_extraction_path(const struct wim_inode *inode,
178 struct unix_apply_ctx *ctx)
180 return unix_build_extraction_path(inode_first_extraction_dentry(inode), ctx);
183 /* Sets the timestamps on a file being extracted.
185 * Either @fd or @path must be specified (not -1 and not NULL, respectively).
188 unix_set_timestamps(int fd, const char *path, u64 atime, u64 mtime)
191 struct timespec times[2];
193 times[0] = wim_timestamp_to_timespec(atime);
194 times[1] = wim_timestamp_to_timespec(mtime);
198 if (fd >= 0 && !futimens(fd, times))
201 #ifdef HAVE_UTIMENSAT
202 if (fd < 0 && !utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW))
206 return WIMLIB_ERR_SET_TIMESTAMPS;
209 struct timeval times[2];
211 times[0] = wim_timestamp_to_timeval(atime);
212 times[1] = wim_timestamp_to_timeval(mtime);
214 if (fd >= 0 && !futimes(fd, times))
216 if (fd < 0 && !lutimes(path, times))
218 return WIMLIB_ERR_SET_TIMESTAMPS;
223 unix_set_owner_and_group(int fd, const char *path, uid_t uid, gid_t gid)
225 if (fd >= 0 && !fchown(fd, uid, gid))
227 if (fd < 0 && !lchown(path, uid, gid))
229 return WIMLIB_ERR_SET_SECURITY;
233 unix_set_mode(int fd, const char *path, mode_t mode)
235 if (fd >= 0 && !fchmod(fd, mode))
237 if (fd < 0 && !chmod(path, mode))
239 return WIMLIB_ERR_SET_SECURITY;
243 * Set metadata on an extracted file.
245 * @fd is an open file descriptor to the extracted file, or -1. @path is the
246 * path to the extracted file, or NULL. If valid, this function uses @fd.
247 * Otherwise, if valid, it uses @path. Otherwise, it calculates the path to one
248 * alias of the extracted file and uses it.
251 unix_set_metadata(int fd, const struct wim_inode *inode,
252 const char *path, struct unix_apply_ctx *ctx)
257 path = unix_build_inode_extraction_path(inode, ctx);
259 if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA)
260 && inode_has_unix_data(inode))
262 u32 uid = inode->i_unix_data.uid;
263 u32 gid = inode->i_unix_data.gid;
264 u32 mode = inode->i_unix_data.mode;
266 ret = unix_set_owner_and_group(fd, path, uid, gid);
269 path = unix_build_inode_extraction_path(inode, ctx);
270 if (ctx->common.extract_flags &
271 WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
273 ERROR_WITH_ERRNO("Can't set uid=%"PRIu32" and "
274 "gid=%"PRIu32" on \"%s\"",
278 WARNING_WITH_ERRNO("Can't set uid=%"PRIu32" and "
279 "gid=%"PRIu32" on \"%s\"",
285 if (!inode_is_symlink(inode))
286 ret = unix_set_mode(fd, path, mode);
289 path = unix_build_inode_extraction_path(inode, ctx);
290 if (ctx->common.extract_flags &
291 WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
293 ERROR_WITH_ERRNO("Can't set mode=0%"PRIo32" "
294 "on \"%s\"", mode, path);
297 WARNING_WITH_ERRNO("Can't set mode=0%"PRIo32" "
298 "on \"%s\"", mode, path);
303 ret = unix_set_timestamps(fd, path,
304 inode->i_last_access_time,
305 inode->i_last_write_time);
308 path = unix_build_inode_extraction_path(inode, ctx);
309 if (ctx->common.extract_flags &
310 WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS)
312 ERROR_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
315 WARNING_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
321 /* Extract all needed aliases of the @inode, where one alias, corresponding to
322 * @first_dentry, has already been extracted to @first_path. */
324 unix_create_hardlinks(const struct wim_inode *inode,
325 const struct wim_dentry *first_dentry,
326 const char *first_path, struct unix_apply_ctx *ctx)
328 const struct wim_dentry *dentry;
331 list_for_each_entry(dentry, &inode->i_extraction_aliases,
332 d_extraction_alias_node)
334 if (dentry == first_dentry)
337 newpath = unix_build_extraction_path(dentry, ctx);
339 if (link(first_path, newpath)) {
340 if (errno == EEXIST && !unlink(newpath))
342 ERROR_WITH_ERRNO("Can't create hard link "
343 "\"%s\" => \"%s\"", newpath, first_path);
344 return WIMLIB_ERR_LINK;
346 unix_reuse_pathbuf(ctx);
351 /* If @dentry represents a directory, create it. */
353 unix_create_if_directory(const struct wim_dentry *dentry,
354 struct unix_apply_ctx *ctx)
359 if (!dentry_is_directory(dentry))
362 path = unix_build_extraction_path(dentry, ctx);
363 if (mkdir(path, 0755) &&
364 /* It's okay if the path already exists, as long as it's a
366 !(errno == EEXIST && !lstat(path, &stbuf) && S_ISDIR(stbuf.st_mode)))
368 ERROR_WITH_ERRNO("Can't create directory \"%s\"", path);
369 return WIMLIB_ERR_MKDIR;
374 /* If @dentry represents an empty regular file, create it, set its metadata, and
375 * create any needed hard links. */
377 unix_extract_if_empty_file(const struct wim_dentry *dentry,
378 struct unix_apply_ctx *ctx)
380 const struct wim_inode *inode;
385 inode = dentry->d_inode;
387 /* Extract all aliases only when the "first" comes up. */
388 if (dentry != inode_first_extraction_dentry(inode))
391 /* Not an empty regular file? */
392 if (inode_is_directory(inode) || inode_is_symlink(inode) ||
393 inode_unnamed_lte_resolved(inode))
396 path = unix_build_extraction_path(dentry, ctx);
398 fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
400 if (errno == EEXIST && !unlink(path))
402 ERROR_WITH_ERRNO("Can't create regular file \"%s\"", path);
403 return WIMLIB_ERR_OPEN;
405 /* On empty files, we can set timestamps immediately because we don't
406 * need to write any data to them. */
407 ret = unix_set_metadata(fd, inode, path, ctx);
408 if (close(fd) && !ret) {
409 ERROR_WITH_ERRNO("Error closing \"%s\"", path);
410 ret = WIMLIB_ERR_WRITE;
415 return unix_create_hardlinks(inode, dentry, path, ctx);
419 unix_create_dirs_and_empty_files(const struct list_head *dentry_list,
420 struct unix_apply_ctx *ctx)
422 const struct wim_dentry *dentry;
425 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
426 ret = unix_create_if_directory(dentry, ctx);
430 list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
431 ret = unix_extract_if_empty_file(dentry, ctx);
439 unix_create_symlink(const struct wim_inode *inode, const char *path,
440 const u8 *rpdata, u16 rpdatalen, bool rpfix,
441 const char *apply_dir, size_t apply_dir_nchars)
443 char link_target[REPARSE_DATA_MAX_SIZE];
445 struct wim_lookup_table_entry lte_override;
447 lte_override.resource_location = RESOURCE_IN_ATTACHED_BUFFER;
448 lte_override.attached_buffer = (void *)rpdata;
449 lte_override.size = rpdatalen;
451 ret = wim_inode_readlink(inode, link_target,
452 sizeof(link_target) - 1, <e_override);
455 return WIMLIB_ERR_READLINK;
458 link_target[ret] = 0;
460 if (rpfix && link_target[0] == '/') {
462 /* "Fix" the absolute symbolic link by prepending the absolute
463 * path to the target directory. */
465 if (sizeof(link_target) - (ret + 1) < apply_dir_nchars) {
466 errno = ENAMETOOLONG;
467 return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED;
469 memmove(link_target + apply_dir_nchars, link_target,
471 memcpy(link_target, apply_dir, apply_dir_nchars);
474 if (symlink(link_target, path)) {
475 if (errno == EEXIST && !unlink(path))
477 return WIMLIB_ERR_LINK;
483 unix_cleanup_open_fds(struct unix_apply_ctx *ctx, unsigned offset)
485 for (unsigned i = offset; i < ctx->num_open_fds; i++)
486 filedes_close(&ctx->open_fds[i]);
487 ctx->num_open_fds = 0;
491 unix_begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
492 const struct wim_inode *inode,
493 struct unix_apply_ctx *ctx)
495 const struct wim_dentry *first_dentry;
496 const char *first_path;
499 if (inode_is_symlink(inode)) {
500 /* On UNIX, symbolic links must be created with symlink(), which
501 * requires that the full link target be available. */
502 if (stream->size > REPARSE_DATA_MAX_SIZE) {
503 ERROR_WITH_ERRNO("Reparse data of \"%s\" has size "
504 "%"PRIu64" bytes (exceeds %u bytes)",
505 inode_first_full_path(inode),
506 stream->size, REPARSE_DATA_MAX_SIZE);
507 return WIMLIB_ERR_INVALID_REPARSE_DATA;
509 ctx->reparse_ptr = ctx->reparse_data;
513 first_dentry = inode_first_extraction_dentry(inode);
514 first_path = unix_build_extraction_path(first_dentry, ctx);
516 fd = open(first_path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
518 if (errno == EEXIST && !unlink(first_path))
520 ERROR_WITH_ERRNO("Can't create regular file \"%s\"", first_path);
521 return WIMLIB_ERR_OPEN;
523 filedes_init(&ctx->open_fds[ctx->num_open_fds++], fd);
524 return unix_create_hardlinks(inode, first_dentry, first_path, ctx);
527 /* Called when starting to read a single-instance stream for extraction */
529 unix_begin_extract_stream(struct wim_lookup_table_entry *stream,
530 u32 flags, void *_ctx)
532 struct unix_apply_ctx *ctx = _ctx;
533 const struct stream_owner *owners = stream_owners(stream);
536 for (u32 i = 0; i < stream->out_refcnt; i++) {
537 const struct wim_inode *inode = owners[i].inode;
539 ret = unix_begin_extract_stream_instance(stream, inode, ctx);
541 ctx->reparse_ptr = NULL;
542 unix_cleanup_open_fds(ctx, 0);
549 /* Called when the next chunk of a single-instance stream has been read for
552 unix_extract_chunk(const void *chunk, size_t size, void *_ctx)
554 struct unix_apply_ctx *ctx = _ctx;
557 for (unsigned i = 0; i < ctx->num_open_fds; i++) {
558 ret = full_write(&ctx->open_fds[i], chunk, size);
560 ERROR_WITH_ERRNO("Error writing data to filesystem");
564 if (ctx->reparse_ptr)
565 ctx->reparse_ptr = mempcpy(ctx->reparse_ptr, chunk, size);
569 /* Called when a single-instance stream has been fully read for extraction */
571 unix_end_extract_stream(struct wim_lookup_table_entry *stream, int status,
574 struct unix_apply_ctx *ctx = _ctx;
577 const struct stream_owner *owners = stream_owners(stream);
579 ctx->reparse_ptr = NULL;
582 unix_cleanup_open_fds(ctx, 0);
588 for (u32 i = 0; i < stream->out_refcnt; i++) {
589 struct wim_inode *inode = owners[i].inode;
591 if (inode_is_symlink(inode)) {
592 /* We finally have the symlink data, so we can create
596 path = unix_build_inode_extraction_path(inode, ctx);
597 ret = unix_create_symlink(inode, path,
600 (ctx->common.extract_flags &
601 WIMLIB_EXTRACT_FLAG_RPFIX),
603 ctx->target_abspath_nchars);
605 ERROR_WITH_ERRNO("Can't create symbolic link "
609 ret = unix_set_metadata(-1, inode, path, ctx);
613 /* Set metadata on regular file just before closing it.
615 struct filedes *fd = &ctx->open_fds[j];
617 ret = unix_set_metadata(fd->fd, inode, NULL, ctx);
621 if (filedes_close(fd)) {
622 ERROR_WITH_ERRNO("Error closing \"%s\"",
623 unix_build_inode_extraction_path(inode, ctx));
624 ret = WIMLIB_ERR_WRITE;
630 unix_cleanup_open_fds(ctx, j);
635 unix_set_dir_metadata(struct list_head *dentry_list, struct unix_apply_ctx *ctx)
637 const struct wim_dentry *dentry;
640 list_for_each_entry_reverse(dentry, dentry_list, d_extraction_list_node) {
641 if (dentry_is_directory(dentry)) {
642 ret = unix_set_metadata(-1, dentry->d_inode, NULL, ctx);
651 unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
654 struct unix_apply_ctx *ctx = (struct unix_apply_ctx *)_ctx;
657 /* Compute the maximum path length that will be needed, then allocate
658 * some path buffers. */
659 path_max = unix_compute_path_max(dentry_list, ctx);
661 for (unsigned i = 0; i < NUM_PATHBUFS; i++) {
662 ctx->pathbufs[i] = MALLOC(path_max);
663 if (!ctx->pathbufs[i]) {
664 ret = WIMLIB_ERR_NOMEM;
667 /* Pre-fill the target in each path buffer. We'll just append
668 * the rest of the paths after this. */
669 memcpy(ctx->pathbufs[i],
670 ctx->common.target, ctx->common.target_nchars);
673 /* Extract directories and empty regular files. Directories are needed
674 * because we can't extract any other files until their directories
675 * exist. Empty files are needed because they don't have
676 * representatives in the stream list. */
677 ret = unix_create_dirs_and_empty_files(dentry_list, ctx);
681 /* Get full path to target if needed for absolute symlink fixups. */
682 if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) &&
683 ctx->common.required_features.symlink_reparse_points)
685 ctx->target_abspath = realpath(ctx->common.target, NULL);
686 if (!ctx->target_abspath) {
687 ret = WIMLIB_ERR_NOMEM;
690 ctx->target_abspath_nchars = strlen(ctx->target_abspath);
693 /* Extract nonempty regular files and symbolic links. */
695 struct read_stream_list_callbacks cbs = {
696 .begin_stream = unix_begin_extract_stream,
697 .begin_stream_ctx = ctx,
698 .consume_chunk = unix_extract_chunk,
699 .consume_chunk_ctx = ctx,
700 .end_stream = unix_end_extract_stream,
701 .end_stream_ctx = ctx,
703 ret = extract_stream_list(&ctx->common, &cbs);
707 /* Set directory metadata. We do this last so that we get the right
708 * directory timestamps. */
709 ret = unix_set_dir_metadata(dentry_list, ctx);
711 for (unsigned i = 0; i < NUM_PATHBUFS; i++)
712 FREE(ctx->pathbufs[i]);
713 FREE(ctx->target_abspath);
717 const struct apply_operations unix_apply_ops = {
719 .get_supported_features = unix_get_supported_features,
720 .extract = unix_extract,
721 .context_size = sizeof(struct unix_apply_ctx),