X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Funix_apply.c;h=f1962d9884b63752892217f3eed71b29393a777c;hp=c4f5318b23b0694c0e6737c19128e0dab9cc6798;hb=0469bcaaa79d7b6031fbdc0a26f38ee7e22ced37;hpb=cc7b6ee47d4037ae8fa11b4c2d5154091d543704 diff --git a/src/unix_apply.c b/src/unix_apply.c index c4f5318b..f1962d98 100644 --- a/src/unix_apply.c +++ b/src/unix_apply.c @@ -5,42 +5,42 @@ /* * Copyright (C) 2012, 2013, 2014 Eric Biggers * - * This file is part of wimlib, a library for working with WIM files. + * This file is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 3 of the License, or (at your option) any + * later version. * - * wimlib is free software; you can redistribute it and/or modify it under the - * terms of the GNU General Public License as published by the Free - * Software Foundation; either version 3 of the License, or (at your option) - * any later version. - * - * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY - * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU General Public License for more + * This file is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * - * You should have received a copy of the GNU General Public License - * along with wimlib; if not, see http://www.gnu.org/licenses/. + * You should have received a copy of the GNU Lesser General Public License + * along with this file; if not, see http://www.gnu.org/licenses/. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif -#include "wimlib/apply.h" -#include "wimlib/dentry.h" -#include "wimlib/error.h" -#include "wimlib/file_io.h" -#include "wimlib/reparse.h" -#include "wimlib/timestamp.h" - #include #include -#include #include #include #include #include #include +#include "wimlib/apply.h" +#include "wimlib/assert.h" +#include "wimlib/blob_table.h" +#include "wimlib/dentry.h" +#include "wimlib/error.h" +#include "wimlib/file_io.h" +#include "wimlib/reparse.h" +#include "wimlib/timestamp.h" +#include "wimlib/unix_data.h" + /* We don't require O_NOFOLLOW, but the advantage of having it is that if we * need to extract a file to a location at which there exists a symbolic link, * open(..., O_NOFOLLOW | ...) recognizes the symbolic link rather than @@ -63,8 +63,6 @@ unix_get_supported_features(const char *target, } #define NUM_PATHBUFS 2 /* We need 2 when creating hard links */ -#define MAX_OPEN_FDS 1024 /* TODO: Add special case for when the number of - identical streams exceeds this number. */ struct unix_apply_ctx { /* Extract flags, the pointer to the WIMStruct, etc. */ @@ -77,13 +75,13 @@ struct unix_apply_ctx { unsigned which_pathbuf; /* Currently open file descriptors for extraction */ - struct filedes open_fds[MAX_OPEN_FDS]; + struct filedes open_fds[MAX_OPEN_FILES]; /* Number of currently open file descriptors in open_fds, starting from * the beginning of the array. */ unsigned num_open_fds; - /* Buffer for reading reparse data streams into memory */ + /* Buffer for reading reparse point data into memory */ u8 reparse_data[REPARSE_DATA_MAX_SIZE]; /* Pointer to the next byte in @reparse_data to fill */ @@ -95,6 +93,9 @@ struct unix_apply_ctx { /* Number of characters in target_abspath. */ size_t target_abspath_nchars; + + /* Number of special files we couldn't create due to EPERM */ + unsigned long num_special_files_ignored; }; /* Returns the number of characters needed to represent the path to the @@ -109,7 +110,7 @@ unix_dentry_path_length(const struct wim_dentry *dentry) d = dentry; do { len += d->d_extraction_name_nchars + 1; - d = d->parent; + d = d->d_parent; } while (!dentry_is_root(d) && will_extract_dentry(d)); return len; @@ -157,7 +158,7 @@ unix_build_extraction_path(const struct wim_dentry *dentry, p -= d->d_extraction_name_nchars; memcpy(p, d->d_extraction_name, d->d_extraction_name_nchars); *--p = '/'; - d = d->parent; + d = d->d_parent; } while (!dentry_is_root(d) && will_extract_dentry(d)); return pathbuf; @@ -180,6 +181,17 @@ unix_build_inode_extraction_path(const struct wim_inode *inode, return unix_build_extraction_path(inode_first_extraction_dentry(inode), ctx); } +/* Should the specified file be extracted as a directory on UNIX? We extract + * the file as a directory if FILE_ATTRIBUTE_DIRECTORY is set and the file does + * not have a symlink or junction reparse point. It *may* have a different type + * of reparse point. */ +static inline bool +should_extract_as_directory(const struct wim_inode *inode) +{ + return (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) && + !inode_is_symlink(inode); +} + /* Sets the timestamps on a file being extracted. * * Either @fd or @path must be specified (not -1 and not NULL, respectively). @@ -219,6 +231,26 @@ unix_set_timestamps(int fd, const char *path, u64 atime, u64 mtime) } } +static int +unix_set_owner_and_group(int fd, const char *path, uid_t uid, gid_t gid) +{ + if (fd >= 0 && !fchown(fd, uid, gid)) + return 0; + if (fd < 0 && !lchown(path, uid, gid)) + return 0; + return WIMLIB_ERR_SET_SECURITY; +} + +static int +unix_set_mode(int fd, const char *path, mode_t mode) +{ + if (fd >= 0 && !fchmod(fd, mode)) + return 0; + if (fd < 0 && !chmod(path, mode)) + return 0; + return WIMLIB_ERR_SET_SECURITY; +} + /* * Set metadata on an extracted file. * @@ -232,10 +264,55 @@ unix_set_metadata(int fd, const struct wim_inode *inode, const char *path, struct unix_apply_ctx *ctx) { int ret; + struct wimlib_unix_data unix_data; if (fd < 0 && !path) path = unix_build_inode_extraction_path(inode, ctx); + if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) + && inode_get_unix_data(inode, &unix_data)) + { + u32 uid = unix_data.uid; + u32 gid = unix_data.gid; + u32 mode = unix_data.mode; + + ret = unix_set_owner_and_group(fd, path, uid, gid); + if (ret) { + if (!path) + path = unix_build_inode_extraction_path(inode, ctx); + if (ctx->common.extract_flags & + WIMLIB_EXTRACT_FLAG_STRICT_ACLS) + { + ERROR_WITH_ERRNO("Can't set uid=%"PRIu32" and " + "gid=%"PRIu32" on \"%s\"", + uid, gid, path); + return ret; + } else { + WARNING_WITH_ERRNO("Can't set uid=%"PRIu32" and " + "gid=%"PRIu32" on \"%s\"", + uid, gid, path); + } + } + + ret = 0; + if (!inode_is_symlink(inode)) + ret = unix_set_mode(fd, path, mode); + if (ret) { + if (!path) + path = unix_build_inode_extraction_path(inode, ctx); + if (ctx->common.extract_flags & + WIMLIB_EXTRACT_FLAG_STRICT_ACLS) + { + ERROR_WITH_ERRNO("Can't set mode=0%"PRIo32" " + "on \"%s\"", mode, path); + return ret; + } else { + WARNING_WITH_ERRNO("Can't set mode=0%"PRIo32" " + "on \"%s\"", mode, path); + } + } + } + ret = unix_set_timestamps(fd, path, inode->i_last_access_time, inode->i_last_write_time); @@ -264,9 +341,7 @@ unix_create_hardlinks(const struct wim_inode *inode, const struct wim_dentry *dentry; const char *newpath; - list_for_each_entry(dentry, &inode->i_extraction_aliases, - d_extraction_alias_node) - { + inode_for_each_extraction_alias(dentry, inode) { if (dentry == first_dentry) continue; @@ -292,7 +367,7 @@ unix_create_if_directory(const struct wim_dentry *dentry, const char *path; struct stat stbuf; - if (!dentry_is_directory(dentry)) + if (!should_extract_as_directory(dentry->d_inode)) return 0; path = unix_build_extraction_path(dentry, ctx); @@ -304,18 +379,19 @@ unix_create_if_directory(const struct wim_dentry *dentry, ERROR_WITH_ERRNO("Can't create directory \"%s\"", path); return WIMLIB_ERR_MKDIR; } - return 0; + + return report_file_created(&ctx->common); } -/* If @dentry represents an empty regular file, create it, set its metadata, and - * create any needed hard links. */ +/* If @dentry represents an empty regular file or a special file, create it, set + * its metadata, and create any needed hard links. */ static int unix_extract_if_empty_file(const struct wim_dentry *dentry, struct unix_apply_ctx *ctx) { const struct wim_inode *inode; + struct wimlib_unix_data unix_data; const char *path; - int fd; int ret; inode = dentry->d_inode; @@ -324,31 +400,63 @@ unix_extract_if_empty_file(const struct wim_dentry *dentry, if (dentry != inode_first_extraction_dentry(inode)) return 0; - /* Not an empty regular file? */ - if (inode_is_directory(inode) || inode_is_symlink(inode) || - inode_unnamed_lte_resolved(inode)) + /* Is this a directory, a symbolic link, or any type of nonempty file? + */ + if (should_extract_as_directory(inode) || inode_is_symlink(inode) || + inode_get_blob_for_unnamed_data_stream_resolved(inode)) return 0; - path = unix_build_extraction_path(dentry, ctx); -retry_create: - fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644); - if (fd < 0) { - if (errno == EEXIST && !unlink(path)) - goto retry_create; - ERROR_WITH_ERRNO("Can't create regular file \"%s\"", path); - return WIMLIB_ERR_OPEN; - } - /* On empty files, we can set timestamps immediately because we don't - * need to write any data to them. */ - ret = unix_set_metadata(fd, inode, path, ctx); - if (close(fd) && !ret) { - ERROR_WITH_ERRNO("Error closing \"%s\"", path); - ret = WIMLIB_ERR_WRITE; + /* Recognize special files in UNIX_DATA mode */ + if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) && + inode_get_unix_data(inode, &unix_data) && + !S_ISREG(unix_data.mode)) + { + path = unix_build_extraction_path(dentry, ctx); + retry_mknod: + if (mknod(path, unix_data.mode, unix_data.rdev)) { + if (errno == EPERM) { + WARNING_WITH_ERRNO("Can't create special " + "file \"%s\"", path); + ctx->num_special_files_ignored++; + return 0; + } + if (errno == EEXIST && !unlink(path)) + goto retry_mknod; + ERROR_WITH_ERRNO("Can't create special file \"%s\"", + path); + return WIMLIB_ERR_MKNOD; + } + /* On special files, we can set timestamps immediately because + * we don't need to write any data to them. */ + ret = unix_set_metadata(-1, inode, path, ctx); + } else { + int fd; + + path = unix_build_extraction_path(dentry, ctx); + retry_create: + fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644); + if (fd < 0) { + if (errno == EEXIST && !unlink(path)) + goto retry_create; + ERROR_WITH_ERRNO("Can't create regular file \"%s\"", path); + return WIMLIB_ERR_OPEN; + } + /* On empty files, we can set timestamps immediately because we + * don't need to write any data to them. */ + ret = unix_set_metadata(fd, inode, path, ctx); + if (close(fd) && !ret) { + ERROR_WITH_ERRNO("Error closing \"%s\"", path); + ret = WIMLIB_ERR_WRITE; + } } if (ret) return ret; - return unix_create_hardlinks(inode, dentry, path, ctx); + ret = unix_create_hardlinks(inode, dentry, path, ctx); + if (ret) + return ret; + + return report_file_created(&ctx->common); } static int @@ -371,43 +479,53 @@ unix_create_dirs_and_empty_files(const struct list_head *dentry_list, return 0; } +static void +unix_count_dentries(const struct list_head *dentry_list, + u64 *dir_count_ret, u64 *empty_file_count_ret) +{ + const struct wim_dentry *dentry; + u64 dir_count = 0; + u64 empty_file_count = 0; + + list_for_each_entry(dentry, dentry_list, d_extraction_list_node) { + + const struct wim_inode *inode = dentry->d_inode; + + if (should_extract_as_directory(inode)) + dir_count++; + else if ((dentry == inode_first_extraction_dentry(inode)) && + !inode_is_symlink(inode) && + !inode_get_blob_for_unnamed_data_stream_resolved(inode)) + empty_file_count++; + } + + *dir_count_ret = dir_count; + *empty_file_count_ret = empty_file_count; +} + static int unix_create_symlink(const struct wim_inode *inode, const char *path, - const u8 *rpdata, u16 rpdatalen, bool rpfix, - const char *apply_dir, size_t apply_dir_nchars) + size_t rpdatalen, struct unix_apply_ctx *ctx) { - char link_target[REPARSE_DATA_MAX_SIZE]; + char target[REPARSE_POINT_MAX_SIZE]; + struct blob_descriptor blob_override; int ret; - struct wim_lookup_table_entry lte_override; - lte_override.resource_location = RESOURCE_IN_ATTACHED_BUFFER; - lte_override.attached_buffer = (void *)rpdata; - lte_override.size = rpdatalen; + blob_set_is_located_in_attached_buffer(&blob_override, + ctx->reparse_data, rpdatalen); - ret = wim_inode_readlink(inode, link_target, - sizeof(link_target) - 1, <e_override); - if (ret < 0) { + ret = wim_inode_readlink(inode, target, sizeof(target) - 1, + &blob_override, + ctx->target_abspath, + ctx->target_abspath_nchars); + if (unlikely(ret < 0)) { errno = -ret; return WIMLIB_ERR_READLINK; } + target[ret] = '\0'; - link_target[ret] = 0; - - if (rpfix && link_target[0] == '/') { - - /* "Fix" the absolute symbolic link by prepending the absolute - * path to the target directory. */ - - if (sizeof(link_target) - (ret + 1) < apply_dir_nchars) { - errno = ENAMETOOLONG; - return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED; - } - memmove(link_target + apply_dir_nchars, link_target, - ret + 1); - memcpy(link_target, apply_dir, apply_dir_nchars); - } retry_symlink: - if (symlink(link_target, path)) { + if (symlink(target, path)) { if (errno == EEXIST && !unlink(path)) goto retry_symlink; return WIMLIB_ERR_LINK; @@ -424,28 +542,36 @@ unix_cleanup_open_fds(struct unix_apply_ctx *ctx, unsigned offset) } static int -unix_begin_extract_stream_instance(const struct wim_lookup_table_entry *stream, - const struct wim_inode *inode, - struct unix_apply_ctx *ctx) +unix_begin_extract_blob_instance(const struct blob_descriptor *blob, + const struct wim_inode *inode, + const struct wim_inode_stream *strm, + struct unix_apply_ctx *ctx) { const struct wim_dentry *first_dentry; const char *first_path; int fd; - if (inode_is_symlink(inode)) { + if (unlikely(strm->stream_type == STREAM_TYPE_REPARSE_POINT)) { /* On UNIX, symbolic links must be created with symlink(), which * requires that the full link target be available. */ - if (stream->size > REPARSE_DATA_MAX_SIZE) { + if (blob->size > REPARSE_DATA_MAX_SIZE) { ERROR_WITH_ERRNO("Reparse data of \"%s\" has size " "%"PRIu64" bytes (exceeds %u bytes)", - inode_first_full_path(inode), - stream->size, REPARSE_DATA_MAX_SIZE); + inode_any_full_path(inode), + blob->size, REPARSE_DATA_MAX_SIZE); return WIMLIB_ERR_INVALID_REPARSE_DATA; } ctx->reparse_ptr = ctx->reparse_data; return 0; } + wimlib_assert(stream_is_unnamed_data_stream(strm)); + + /* Unnamed data stream of "regular" file */ + + /* This should be ensured by extract_blob_list() */ + wimlib_assert(ctx->num_open_fds < MAX_OPEN_FILES); + first_dentry = inode_first_extraction_dentry(inode); first_path = unix_build_extraction_path(first_dentry, ctx); retry_create: @@ -460,19 +586,18 @@ retry_create: return unix_create_hardlinks(inode, first_dentry, first_path, ctx); } -/* Called when starting to read a single-instance stream for extraction */ +/* Called when starting to read a blob for extraction */ static int -unix_begin_extract_stream(struct wim_lookup_table_entry *stream, - u32 flags, void *_ctx) +unix_begin_extract_blob(struct blob_descriptor *blob, void *_ctx) { struct unix_apply_ctx *ctx = _ctx; - const struct stream_owner *owners = stream_owners(stream); - int ret; + const struct blob_extraction_target *targets = blob_extraction_targets(blob); - for (u32 i = 0; i < stream->out_refcnt; i++) { - const struct wim_inode *inode = owners[i].inode; - - ret = unix_begin_extract_stream_instance(stream, inode, ctx); + for (u32 i = 0; i < blob->out_refcnt; i++) { + int ret = unix_begin_extract_blob_instance(blob, + targets[i].inode, + targets[i].stream, + ctx); if (ret) { ctx->reparse_ptr = NULL; unix_cleanup_open_fds(ctx, 0); @@ -482,8 +607,7 @@ unix_begin_extract_stream(struct wim_lookup_table_entry *stream, return 0; } -/* Called when the next chunk of a single-instance stream has been read for - * extraction */ +/* Called when the next chunk of a blob has been read for extraction */ static int unix_extract_chunk(const void *chunk, size_t size, void *_ctx) { @@ -502,15 +626,14 @@ unix_extract_chunk(const void *chunk, size_t size, void *_ctx) return 0; } -/* Called when a single-instance stream has been fully read for extraction */ +/* Called when a blob has been fully read for extraction */ static int -unix_end_extract_stream(struct wim_lookup_table_entry *stream, int status, - void *_ctx) +unix_end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx) { struct unix_apply_ctx *ctx = _ctx; int ret; unsigned j; - const struct stream_owner *owners = stream_owners(stream); + const struct blob_extraction_target *targets = blob_extraction_targets(blob); ctx->reparse_ptr = NULL; @@ -521,8 +644,8 @@ unix_end_extract_stream(struct wim_lookup_table_entry *stream, int status, j = 0; ret = 0; - for (u32 i = 0; i < stream->out_refcnt; i++) { - struct wim_inode *inode = owners[i].inode; + for (u32 i = 0; i < blob->out_refcnt; i++) { + struct wim_inode *inode = targets[i].inode; if (inode_is_symlink(inode)) { /* We finally have the symlink data, so we can create @@ -530,13 +653,7 @@ unix_end_extract_stream(struct wim_lookup_table_entry *stream, int status, const char *path; path = unix_build_inode_extraction_path(inode, ctx); - ret = unix_create_symlink(inode, path, - ctx->reparse_data, - stream->size, - (ctx->common.extract_flags & - WIMLIB_EXTRACT_FLAG_RPFIX), - ctx->target_abspath, - ctx->target_abspath_nchars); + ret = unix_create_symlink(inode, path, blob->size, ctx); if (ret) { ERROR_WITH_ERRNO("Can't create symbolic link " "\"%s\"", path); @@ -574,10 +691,13 @@ unix_set_dir_metadata(struct list_head *dentry_list, struct unix_apply_ctx *ctx) int ret; list_for_each_entry_reverse(dentry, dentry_list, d_extraction_list_node) { - if (dentry_is_directory(dentry)) { + if (should_extract_as_directory(dentry->d_inode)) { ret = unix_set_metadata(-1, dentry->d_inode, NULL, ctx); if (ret) return ret; + ret = report_file_metadata_applied(&ctx->common); + if (ret) + return ret; } } return 0; @@ -589,6 +709,8 @@ unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) int ret; struct unix_apply_ctx *ctx = (struct unix_apply_ctx *)_ctx; size_t path_max; + u64 dir_count; + u64 empty_file_count; /* Compute the maximum path length that will be needed, then allocate * some path buffers. */ @@ -609,11 +731,22 @@ unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) /* Extract directories and empty regular files. Directories are needed * because we can't extract any other files until their directories * exist. Empty files are needed because they don't have - * representatives in the stream list. */ + * representatives in the blob list. */ + + unix_count_dentries(dentry_list, &dir_count, &empty_file_count); + + ret = start_file_structure_phase(&ctx->common, dir_count + empty_file_count); + if (ret) + goto out; + ret = unix_create_dirs_and_empty_files(dentry_list, ctx); if (ret) goto out; + ret = end_file_structure_phase(&ctx->common); + if (ret) + goto out; + /* Get full path to target if needed for absolute symlink fixups. */ if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) && ctx->common.required_features.symlink_reparse_points) @@ -628,21 +761,35 @@ unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) /* Extract nonempty regular files and symbolic links. */ - struct read_stream_list_callbacks cbs = { - .begin_stream = unix_begin_extract_stream, - .begin_stream_ctx = ctx, - .consume_chunk = unix_extract_chunk, - .consume_chunk_ctx = ctx, - .end_stream = unix_end_extract_stream, - .end_stream_ctx = ctx, + struct read_blob_callbacks cbs = { + .begin_blob = unix_begin_extract_blob, + .consume_chunk = unix_extract_chunk, + .end_blob = unix_end_extract_blob, + .ctx = ctx, }; - ret = extract_stream_list(&ctx->common, &cbs); + ret = extract_blob_list(&ctx->common, &cbs); if (ret) goto out; + /* Set directory metadata. We do this last so that we get the right * directory timestamps. */ + ret = start_file_metadata_phase(&ctx->common, dir_count); + if (ret) + goto out; + ret = unix_set_dir_metadata(dentry_list, ctx); + if (ret) + goto out; + + ret = end_file_metadata_phase(&ctx->common); + if (ret) + goto out; + + if (ctx->num_special_files_ignored) { + WARNING("%lu special files were not extracted due to EPERM!", + ctx->num_special_files_ignored); + } out: for (unsigned i = 0; i < NUM_PATHBUFS; i++) FREE(ctx->pathbufs[i]);