x86_cpu_features.c: include "config.h"

[wimlib] / src / unix_apply.c

diff --git a/src/unix_apply.c b/src/unix_apply.c
index a0b62519c02a974b46a7df8a80f341703c24621b..122e1163580b3397ab1d733de984c877844a83ff 100644 (file)
--- a/src/unix_apply.c
+++ b/src/unix_apply.c
@@ -330,9 +330,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;
 
@@ -472,11 +470,11 @@ 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) {
 
@@ -496,41 +494,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_override.blob_location = BLOB_IN_ATTACHED_BUFFER;
-       blob_override.attached_buffer = (void *)rpdata;
-       blob_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, &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;
@@ -562,7 +546,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;
                }
@@ -656,19 +640,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);
@@ -724,8 +698,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.  */
@@ -776,13 +750,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,
+               .consume_chunk  = unix_extract_chunk,
+               .end_blob       = unix_end_extract_blob,
+               .ctx            = ctx,
        };
        ret = extract_blob_list(&ctx->common, &cbs);
        if (ret)