X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Funix_apply.c;h=daadfc9ec15d31c86a90251fbe699c7a2eb40668;hp=e6bd2321276baeae20b1f177c21b211a24cd45df;hb=da76dcea3a09c6de9cf865609f1e1732fc2c521a;hpb=3abe6501c7ebb20a0ead1cd69ebd93cbe6b917e1 diff --git a/src/unix_apply.c b/src/unix_apply.c index e6bd2321..daadfc9e 100644 --- a/src/unix_apply.c +++ b/src/unix_apply.c @@ -3,7 +3,7 @@ */ /* - * Copyright (C) 2012, 2013, 2014 Eric Biggers + * Copyright (C) 2012-2016 Eric Biggers * * 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 @@ -29,6 +29,9 @@ #include #include #include +#ifdef HAVE_SYS_XATTR_H +# include +#endif #include #include "wimlib/apply.h" @@ -40,6 +43,7 @@ #include "wimlib/reparse.h" #include "wimlib/timestamp.h" #include "wimlib/unix_data.h" +#include "wimlib/xattr.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, @@ -54,11 +58,15 @@ static int unix_get_supported_features(const char *target, struct wim_features *supported_features) { + supported_features->sparse_files = 1; supported_features->hard_links = 1; supported_features->symlink_reparse_points = 1; supported_features->unix_data = 1; supported_features->timestamps = 1; supported_features->case_sensitive_filenames = 1; +#ifdef HAVE_XATTR_SUPPORT + supported_features->linux_xattrs = 1; +#endif return 0; } @@ -81,6 +89,13 @@ struct unix_apply_ctx { * the beginning of the array. */ unsigned num_open_fds; + /* For each currently open file, whether we're writing to it in "sparse" + * mode or not. */ + bool is_sparse_file[MAX_OPEN_FILES]; + + /* Whether is_sparse_file[] is true for any currently open file */ + bool any_sparse_files; + /* Buffer for reading reparse point data into memory */ u8 reparse_data[REPARSE_DATA_MAX_SIZE]; @@ -156,7 +171,9 @@ unix_build_extraction_path(const struct wim_dentry *dentry, d = dentry; do { p -= d->d_extraction_name_nchars; - memcpy(p, d->d_extraction_name, d->d_extraction_name_nchars); + if (d->d_extraction_name_nchars) + memcpy(p, d->d_extraction_name, + d->d_extraction_name_nchars); *--p = '/'; d = d->d_parent; } while (!dentry_is_root(d) && will_extract_dentry(d)); @@ -181,6 +198,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). @@ -240,70 +268,165 @@ unix_set_mode(int fd, const char *path, mode_t mode) return WIMLIB_ERR_SET_SECURITY; } +#ifdef HAVE_XATTR_SUPPORT +/* Apply extended attributes to a file */ +static int +apply_linux_xattrs(int fd, const struct wim_inode *inode, + const char *path, struct unix_apply_ctx *ctx, + const void *entries, size_t entries_size) +{ + const void * const entries_end = entries + entries_size; + char name[XATTR_NAME_MAX + 1]; + + for (const struct wimlib_xattr_entry *entry = entries; + (void *)entry < entries_end; entry = xattr_entry_next(entry)) + { + u16 name_len; + const void *value; + u32 value_len; + int res; + + if (!valid_xattr_entry(entry, entries_end - (void *)entry)) { + if (!path) { + path = unix_build_inode_extraction_path(inode, + ctx); + } + ERROR("\"%s\": extended attribute is corrupt", path); + return WIMLIB_ERR_INVALID_XATTR; + } + name_len = le16_to_cpu(entry->name_len); + memcpy(name, entry->name, name_len); + name[name_len] = '\0'; + + value = entry->name + name_len; + value_len = le32_to_cpu(entry->value_len); + + if (fd >= 0) + res = fsetxattr(fd, name, value, value_len, 0); + else + res = lsetxattr(path, name, value, value_len, 0); + + if (unlikely(res != 0)) { + if (!path) { + path = unix_build_inode_extraction_path(inode, + ctx); + } + if (is_security_xattr(name) && + (ctx->common.extract_flags & + WIMLIB_EXTRACT_FLAG_STRICT_ACLS)) + { + ERROR_WITH_ERRNO("\"%s\": unable to set extended attribute \"%s\"", + path, name); + return WIMLIB_ERR_SET_XATTR; + } + WARNING_WITH_ERRNO("\"%s\": unable to set extended attribute \"%s\"", + path, name); + } + } + return 0; +} +#endif /* HAVE_XATTR_SUPPORT */ + /* - * Set metadata on an extracted file. + * Apply UNIX-specific metadata to a file if available. This includes standard + * UNIX permissions (uid, gid, and mode) and possibly extended attributes too. * - * @fd is an open file descriptor to the extracted file, or -1. @path is the - * path to the extracted file, or NULL. If valid, this function uses @fd. - * Otherwise, if valid, it uses @path. Otherwise, it calculates the path to one - * alias of the extracted file and uses it. + * Note that some xattrs which grant privileges, e.g. security.capability, are + * cleared by Linux on chown(), even when running as root. Also, when running + * as non-root, if we need to chmod() the file to readonly, we can't do that + * before setting xattrs because setxattr() requires write permission. These + * restrictions result in the following ordering which we follow: chown(), + * setxattr(), then chmod(). + * + * N.B. the file may be specified by either 'fd' (for regular files) or 'path', + * and it may be a symlink. For symlinks we need lchown() and lsetxattr() but + * need to skip the chmod(), since mode bits are not meaningful for symlinks. */ static int -unix_set_metadata(int fd, const struct wim_inode *inode, - const char *path, struct unix_apply_ctx *ctx) +apply_unix_metadata(int fd, const struct wim_inode *inode, + const char *path, struct unix_apply_ctx *ctx) { + bool have_dat; + struct wimlib_unix_data dat; +#ifdef HAVE_XATTR_SUPPORT + const void *entries; + u32 entries_size; +#endif 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; + have_dat = inode_get_unix_data(inode, &dat); - ret = unix_set_owner_and_group(fd, path, uid, gid); + if (have_dat) { + ret = unix_set_owner_and_group(fd, path, dat.uid, dat.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); + ERROR_WITH_ERRNO("\"%s\": unable to set uid=%"PRIu32" and gid=%"PRIu32, + path, dat.uid, dat.gid); return ret; - } else { - WARNING_WITH_ERRNO("Can't set uid=%"PRIu32" and " - "gid=%"PRIu32" on \"%s\"", - uid, gid, path); } + WARNING_WITH_ERRNO("\"%s\": unable to set uid=%"PRIu32" and gid=%"PRIu32, + path, dat.uid, dat.gid); } + } + +#if HAVE_XATTR_SUPPORT + entries = inode_get_linux_xattrs(inode, &entries_size); + if (entries) { + ret = apply_linux_xattrs(fd, inode, path, ctx, + entries, entries_size); + if (ret) + return ret; + } +#endif - ret = 0; - if (!inode_is_symlink(inode)) - ret = unix_set_mode(fd, path, mode); + if (have_dat && !inode_is_symlink(inode)) { + ret = unix_set_mode(fd, path, dat.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); + ERROR_WITH_ERRNO("\"%s\": unable to set mode=0%"PRIo32, + path, dat.mode); return ret; - } else { - WARNING_WITH_ERRNO("Can't set mode=0%"PRIo32" " - "on \"%s\"", mode, path); } + WARNING_WITH_ERRNO("\"%s\": unable to set mode=0%"PRIo32, + path, dat.mode); } } - ret = unix_set_timestamps(fd, path, - inode->i_last_access_time, + return 0; +} + +/* + * Set metadata on an extracted file. + * + * @fd is an open file descriptor to the extracted file, or -1. @path is the + * path to the extracted file, or NULL. If valid, this function uses @fd. + * Otherwise, if valid, it uses @path. Otherwise, it calculates the path to one + * alias of the extracted file and uses it. + */ +static int +unix_set_metadata(int fd, const struct wim_inode *inode, + const char *path, struct unix_apply_ctx *ctx) +{ + int ret; + + if (fd < 0 && !path) + path = unix_build_inode_extraction_path(inode, ctx); + + if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) { + ret = apply_unix_metadata(fd, inode, path, ctx); + if (ret) + return ret; + } + + ret = unix_set_timestamps(fd, path, inode->i_last_access_time, inode->i_last_write_time); if (ret) { if (!path) @@ -311,12 +434,12 @@ unix_set_metadata(int fd, const struct wim_inode *inode, if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS) { - ERROR_WITH_ERRNO("Can't set timestamps on \"%s\"", path); + ERROR_WITH_ERRNO("\"%s\": unable to set timestamps", path); return ret; - } else { - WARNING_WITH_ERRNO("Can't set timestamps on \"%s\"", path); } + WARNING_WITH_ERRNO("\"%s\": unable to set timestamps", path); } + return 0; } @@ -330,9 +453,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; @@ -358,7 +479,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); @@ -393,7 +514,7 @@ unix_extract_if_empty_file(const struct wim_dentry *dentry, /* Is this a directory, a symbolic link, or any type of nonempty file? */ - if (inode_is_directory(inode) || inode_is_symlink(inode) || + if (should_extract_as_directory(inode) || inode_is_symlink(inode) || inode_get_blob_for_unnamed_data_stream_resolved(inode)) return 0; @@ -425,7 +546,7 @@ unix_extract_if_empty_file(const struct wim_dentry *dentry, path = unix_build_extraction_path(dentry, ctx); retry_create: - fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644); + fd = open(path, O_EXCL | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644); if (fd < 0) { if (errno == EEXIST && !unlink(path)) goto retry_create; @@ -472,17 +593,17 @@ unix_create_dirs_and_empty_files(const struct list_head *dentry_list, static void unix_count_dentries(const struct list_head *dentry_list, - uint64_t *dir_count_ret, uint64_t *empty_file_count_ret) + u64 *dir_count_ret, u64 *empty_file_count_ret) { const struct wim_dentry *dentry; - uint64_t dir_count = 0; - uint64_t empty_file_count = 0; + 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 (inode_is_directory(inode)) + if (should_extract_as_directory(inode)) dir_count++; else if ((dentry == inode_first_extraction_dentry(inode)) && !inode_is_symlink(inode) && @@ -496,40 +617,27 @@ unix_count_dentries(const struct list_head *dentry_list, 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]; - int ret; + char target[REPARSE_POINT_MAX_SIZE]; struct blob_descriptor blob_override; + int ret; blob_set_is_located_in_attached_buffer(&blob_override, - (void *)rpdata, rpdatalen); + ctx->reparse_data, rpdatalen); - ret = wim_inode_readlink(inode, link_target, - sizeof(link_target) - 1, &blob_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; @@ -543,6 +651,7 @@ unix_cleanup_open_fds(struct unix_apply_ctx *ctx, unsigned offset) for (unsigned i = offset; i < ctx->num_open_fds; i++) filedes_close(&ctx->open_fds[i]); ctx->num_open_fds = 0; + ctx->any_sparse_files = false; } static int @@ -561,7 +670,7 @@ unix_begin_extract_blob_instance(const struct blob_descriptor *blob, 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), + inode_any_full_path(inode), blob->size, REPARSE_DATA_MAX_SIZE); return WIMLIB_ERR_INVALID_REPARSE_DATA; } @@ -579,13 +688,22 @@ unix_begin_extract_blob_instance(const struct blob_descriptor *blob, first_dentry = inode_first_extraction_dentry(inode); first_path = unix_build_extraction_path(first_dentry, ctx); retry_create: - fd = open(first_path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644); + fd = open(first_path, O_EXCL | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644); if (fd < 0) { if (errno == EEXIST && !unlink(first_path)) goto retry_create; ERROR_WITH_ERRNO("Can't create regular file \"%s\"", first_path); return WIMLIB_ERR_OPEN; } + if (inode->i_attributes & FILE_ATTRIBUTE_SPARSE_FILE) { + ctx->is_sparse_file[ctx->num_open_fds] = true; + ctx->any_sparse_files = true; + } else { + ctx->is_sparse_file[ctx->num_open_fds] = false; +#ifdef HAVE_POSIX_FALLOCATE + posix_fallocate(fd, 0, blob->size); +#endif + } filedes_init(&ctx->open_fds[ctx->num_open_fds++], fd); return unix_create_hardlinks(inode, first_dentry, first_path, ctx); } @@ -613,21 +731,41 @@ unix_begin_extract_blob(struct blob_descriptor *blob, void *_ctx) /* 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) +unix_extract_chunk(const struct blob_descriptor *blob, u64 offset, + const void *chunk, size_t size, void *_ctx) { struct unix_apply_ctx *ctx = _ctx; + const void * const end = chunk + size; + const void *p; + bool zeroes; + size_t len; + unsigned i; int ret; - for (unsigned i = 0; i < ctx->num_open_fds; i++) { - ret = full_write(&ctx->open_fds[i], chunk, size); - if (ret) { - ERROR_WITH_ERRNO("Error writing data to filesystem"); - return ret; + /* + * For sparse files, only write nonzero regions. This lets the + * filesystem use holes to represent zero regions. + */ + for (p = chunk; p != end; p += len, offset += len) { + zeroes = maybe_detect_sparse_region(p, end - p, &len, + ctx->any_sparse_files); + for (i = 0; i < ctx->num_open_fds; i++) { + if (!zeroes || !ctx->is_sparse_file[i]) { + ret = full_pwrite(&ctx->open_fds[i], + p, len, offset); + if (ret) + goto err; + } } } + if (ctx->reparse_ptr) ctx->reparse_ptr = mempcpy(ctx->reparse_ptr, chunk, size); return 0; + +err: + ERROR_WITH_ERRNO("Error writing data to filesystem"); + return ret; } /* Called when a blob has been fully read for extraction */ @@ -655,19 +793,9 @@ unix_end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx) /* We finally have the symlink data, so we can create * the symlink. */ const char *path; - bool rpfix; - - rpfix = (ctx->common.extract_flags & - WIMLIB_EXTRACT_FLAG_RPFIX) && - !inode->i_not_rpfixed; path = unix_build_inode_extraction_path(inode, ctx); - ret = unix_create_symlink(inode, path, - ctx->reparse_data, - blob->size, - 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); @@ -677,10 +805,17 @@ unix_end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx) if (ret) break; } else { - /* Set metadata on regular file just before closing it. - */ struct filedes *fd = &ctx->open_fds[j]; + /* If the file is sparse, extend it to its final size. */ + if (ctx->is_sparse_file[j] && ftruncate(fd->fd, blob->size)) { + ERROR_WITH_ERRNO("Error extending \"%s\" to final size", + unix_build_inode_extraction_path(inode, ctx)); + ret = WIMLIB_ERR_WRITE; + break; + } + + /* Set metadata on regular file just before closing. */ ret = unix_set_metadata(fd->fd, inode, NULL, ctx); if (ret) break; @@ -705,7 +840,7 @@ 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; @@ -723,8 +858,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; - uint64_t dir_count; - uint64_t empty_file_count; + u64 dir_count; + u64 empty_file_count; /* Compute the maximum path length that will be needed, then allocate * some path buffers. */ @@ -775,13 +910,11 @@ unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) /* Extract nonempty regular files and symbolic links. */ - struct read_blob_list_callbacks cbs = { - .begin_blob = unix_begin_extract_blob, - .begin_blob_ctx = ctx, - .consume_chunk = unix_extract_chunk, - .consume_chunk_ctx = ctx, - .end_blob = unix_end_extract_blob, - .end_blob_ctx = ctx, + struct read_blob_callbacks cbs = { + .begin_blob = unix_begin_extract_blob, + .continue_blob = unix_extract_chunk, + .end_blob = unix_end_extract_blob, + .ctx = ctx, }; ret = extract_blob_list(&ctx->common, &cbs); if (ret)