maybe_apply_dentry(): Treat encrypted directories as streamless

[wimlib] / src / extract_image.c

diff --git a/src/extract_image.c b/src/extract_image.c
index fffdcfd1f239fba3f8b00e672d2cc0f3428e7fde..e1096647ae5cd7e7346361c0d29abdc6e7deae7e 100644 (file)
--- a/src/extract_image.c
+++ b/src/extract_image.c
@@ -281,7 +281,7 @@ out_extract_unix_data:
                        ret = 0;
                else
                        ret = fd_apply_unix_data(out_fd, &unix_data);
-               if (ret != 0)
+               if (ret)
                        goto out;
        }
        if (lte)
@@ -324,9 +324,13 @@ extract_symlink(struct wim_dentry *dentry,
                struct apply_args *args,
                const char *output_path)
 {
-       char target[4096];
-       ssize_t ret = inode_readlink(dentry->d_inode, target,
-                                    sizeof(target), args->w, false);
+       char target[4096 + args->target_realpath_len];
+       char *fixed_target;
+       const struct wim_inode *inode = dentry->d_inode;
+
+       ssize_t ret = wim_inode_readlink(inode,
+                                        target + args->target_realpath_len,
+                                        sizeof(target) - args->target_realpath_len - 1);
        struct wim_lookup_table_entry *lte;
 
        if (ret <= 0) {
@@ -334,26 +338,39 @@ extract_symlink(struct wim_dentry *dentry,
                      dentry->_full_path);
                return WIMLIB_ERR_INVALID_DENTRY;
        }
-       ret = symlink(target, output_path);
-       if (ret != 0) {
+       target[args->target_realpath_len + ret] = '\0';
+       if (target[args->target_realpath_len] == '/' &&
+           args->extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX)
+       {
+               /* Fix absolute symbolic link target to point into the actual
+                * extraction destination */
+               memcpy(target, args->target_realpath,
+                      args->target_realpath_len);
+               fixed_target = target;
+       } else {
+               /* Keep same link target */
+               fixed_target = target + args->target_realpath_len;
+       }
+       ret = symlink(fixed_target, output_path);
+       if (ret) {
                ERROR_WITH_ERRNO("Failed to symlink `%s' to `%s'",
-                                output_path, target);
+                                output_path, fixed_target);
                return WIMLIB_ERR_LINK;
        }
-       lte = inode_unnamed_lte_resolved(dentry->d_inode);
-       wimlib_assert(lte != NULL);
        if (args->extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) {
                struct wimlib_unix_data unix_data;
-               ret = inode_get_unix_data(dentry->d_inode, &unix_data, NULL);
+               ret = inode_get_unix_data(inode, &unix_data, NULL);
                if (ret > 0)
                        ;
                else if (ret < 0)
                        ret = 0;
                else
                        ret = symlink_apply_unix_data(output_path, &unix_data);
-               if (ret != 0)
+               if (ret)
                        return ret;
        }
+       lte = inode_unnamed_lte_resolved(inode);
+       wimlib_assert(lte != NULL);
        args->progress.extract.completed_bytes += wim_resource_size(lte);
        return 0;
 }
@@ -407,10 +424,9 @@ dir_exists:
 }
 
 #ifndef __WIN32__
-static int unix_do_apply_dentry(const char *output_path,
-                               size_t output_path_len,
-                               struct wim_dentry *dentry,
-                               struct apply_args *args)
+static int
+unix_do_apply_dentry(const char *output_path, size_t output_path_len,
+                    struct wim_dentry *dentry, struct apply_args *args)
 {
        const struct wim_inode *inode = dentry->d_inode;
 
@@ -490,8 +506,8 @@ static int
 apply_dentry_normal(struct wim_dentry *dentry, void *arg)
 {
        struct apply_args *args = arg;
-       tchar *output_path;
        size_t len;
+       tchar *output_path;
 
        len = tstrlen(args->target);
        if (dentry_is_root(dentry)) {
@@ -532,7 +548,6 @@ apply_dentry_timestamps_normal(struct wim_dentry *dentry, void *arg)
                output_path[len] = T('\0');
        }
 
-
 #ifdef __WIN32__
        return win32_do_apply_dentry_timestamps(output_path, len, dentry, args);
 #else
@@ -552,7 +567,9 @@ maybe_apply_dentry(struct wim_dentry *dentry, void *arg)
                return 0;
 
        if (args->extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS)
-               if (inode_unnamed_lte_resolved(dentry->d_inode))
+               if (inode_unnamed_lte_resolved(dentry->d_inode) &&
+                   !(dentry->d_inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY |
+                                                      FILE_ATTRIBUTE_ENCRYPTED)))
                        return 0;
 
        if ((args->extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) &&
@@ -623,8 +640,21 @@ inode_find_streams_for_extraction(struct wim_inode *inode,
                list_add_tail(&inode->i_lte_inode_list, &lte->inode_list);
                inode_added = true;
        }
-#ifdef WITH_NTFS_3G
-       if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
+
+       /* Determine whether to include alternate data stream entries or not.
+        *
+        * UNIX:  Include them if extracting using NTFS-3g.
+        *
+        * Windows: Include them undconditionally, although if the filesystem is
+        * not NTFS we won't actually be able to extract them. */
+#if defined(WITH_NTFS_3G)
+       if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS)
+#elif defined(__WIN32__)
+       if (1)
+#else
+       if (0)
+#endif
+       {
                for (unsigned i = 0; i < inode->i_num_ads; i++) {
                        if (inode->i_ads_entries[i].stream_name_nbytes != 0) {
                                lte = inode->i_ads_entries[i].lte;
@@ -640,7 +670,6 @@ inode_find_streams_for_extraction(struct wim_inode *inode,
                        }
                }
        }
-#endif
 }
 
 static void
@@ -711,7 +740,7 @@ apply_stream_list(struct list_head *stream_list,
                                /* Extract the dentry if it was not already
                                 * extracted */
                                ret = maybe_apply_dentry(dentry, args);
-                               if (ret != 0)
+                               if (ret)
                                        return ret;
                                if (progress_func &&
                                    args->progress.extract.completed_bytes >= next_progress)
@@ -863,10 +892,17 @@ extract_single_image(WIMStruct *w, int image,
                              &args.progress);
        }
 
+       if (extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) {
+               args.target_realpath = realpath(target, NULL);
+               if (!args.target_realpath)
+                       return WIMLIB_ERR_NOMEM;
+               args.target_realpath_len = tstrlen(args.target_realpath);
+       }
+
        /* Extract non-empty files */
        ret = apply_stream_list(&stream_list, &args, ops, progress_func);
        if (ret)
-               goto out;
+               goto out_free_target_realpath;
 
        if (progress_func) {
                progress_func(WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS,
@@ -877,12 +913,14 @@ extract_single_image(WIMStruct *w, int image,
        ret = for_dentry_in_tree_depth(wim_root_dentry(w),
                                       ops->apply_dentry_timestamps, &args);
        if (ret)
-               goto out;
+               goto out_free_target_realpath;
 
        if (progress_func) {
                progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END,
                              &args.progress);
        }
+out_free_target_realpath:
+       FREE(args.target_realpath);
 out:
 #ifdef WITH_NTFS_3G
        /* Unmount the NTFS volume */
@@ -1011,6 +1049,19 @@ wimlib_extract_image(WIMStruct *w,
 #endif
        }
 
+       if ((extract_flags & (WIMLIB_EXTRACT_FLAG_RPFIX |
+                             WIMLIB_EXTRACT_FLAG_RPFIX)) ==
+               (WIMLIB_EXTRACT_FLAG_RPFIX | WIMLIB_EXTRACT_FLAG_NORPFIX))
+       {
+               ERROR("Cannot specify RPFIX and NORPFIX flags at the same time!");
+               return WIMLIB_ERR_INVALID_PARAM;
+       }
+
+       if ((extract_flags & (WIMLIB_EXTRACT_FLAG_RPFIX |
+                             WIMLIB_EXTRACT_FLAG_NORPFIX)) == 0)
+               if (w->hdr.flags & WIM_HDR_FLAG_RP_FIX)
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_RPFIX;
+
        ret = verify_swm_set(w, additional_swms, num_additional_swms);
        if (ret)
                return ret;