extract.c: add missing will_extract_dentry() check

[wimlib] / src / extract.c

diff --git a/src/extract.c b/src/extract.c
index 04d0b7972997b46f45f2325ef52b5159c77dcf5c..625224b34924d4eae6068f15b891402261cdf323 100644 (file)
--- a/src/extract.c
+++ b/src/extract.c
@@ -328,10 +328,7 @@ extract_chunk_wrapper(const void *chunk, size_t size, void *_ctx)
                        const struct wim_inode *inode = targets[i].inode;
                        const struct wim_dentry *dentry;
 
-                       list_for_each_entry(dentry,
-                                           &inode->i_extraction_aliases,
-                                           d_extraction_alias_node)
-                       {
+                       inode_for_each_extraction_alias(dentry, inode) {
                                progress->extract.completed_bytes += size;
                                if (ctx->cur_blob_offset == ctx->cur_blob->size)
                                        progress->extract.completed_streams++;
@@ -525,14 +522,14 @@ remove_duplicate_trees(struct wim_dentry **trees, size_t num_trees)
 {
        size_t i, j = 0;
        for (i = 0; i < num_trees; i++) {
-               if (!trees[i]->tmp_flag) {
+               if (!trees[i]->d_tmp_flag) {
                        /* Found distinct dentry.  */
-                       trees[i]->tmp_flag = 1;
+                       trees[i]->d_tmp_flag = 1;
                        trees[j++] = trees[i];
                }
        }
        for (i = 0; i < j; i++)
-               trees[i]->tmp_flag = 0;
+               trees[i]->d_tmp_flag = 0;
        return j;
 }
 
@@ -546,23 +543,23 @@ remove_contained_trees(struct wim_dentry **trees, size_t num_trees)
 {
        size_t i, j = 0;
        for (i = 0; i < num_trees; i++)
-               trees[i]->tmp_flag = 1;
+               trees[i]->d_tmp_flag = 1;
        for (i = 0; i < num_trees; i++) {
                struct wim_dentry *d = trees[i];
                while (!dentry_is_root(d)) {
                        d = d->d_parent;
-                       if (d->tmp_flag)
+                       if (d->d_tmp_flag)
                                goto tree_contained;
                }
                trees[j++] = trees[i];
                continue;
 
        tree_contained:
-               trees[i]->tmp_flag = 0;
+               trees[i]->d_tmp_flag = 0;
        }
 
        for (i = 0; i < j; i++)
-               trees[i]->tmp_flag = 0;
+               trees[i]->d_tmp_flag = 0;
        return j;
 }
 
@@ -583,8 +580,10 @@ dentry_reset_extraction_list_node(struct wim_dentry *dentry)
 static int
 dentry_delete_from_list(struct wim_dentry *dentry, void *_ignore)
 {
-       list_del(&dentry->d_extraction_list_node);
-       dentry_reset_extraction_list_node(dentry);
+       if (will_extract_dentry(dentry)) {
+               list_del(&dentry->d_extraction_list_node);
+               dentry_reset_extraction_list_node(dentry);
+       }
        return 0;
 }
 
@@ -646,7 +645,7 @@ destroy_dentry_list(struct list_head *dentry_list)
                dentry_reset_extraction_list_node(dentry);
                inode->i_visited = 0;
                inode->i_can_externally_back = 0;
-               if ((void *)dentry->d_extraction_name != (void *)dentry->file_name)
+               if ((void *)dentry->d_extraction_name != (void *)dentry->d_name)
                        FREE(dentry->d_extraction_name);
                dentry->d_extraction_name = NULL;
                dentry->d_extraction_name_nchars = 0;
@@ -721,8 +720,8 @@ dentry_calculate_extraction_name(struct wim_dentry *dentry,
 
 #ifdef WITH_NTFS_3G
        if (ctx->extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
-               dentry->d_extraction_name = dentry->file_name;
-               dentry->d_extraction_name_nchars = dentry->file_name_nbytes /
+               dentry->d_extraction_name = dentry->d_name;
+               dentry->d_extraction_name_nchars = dentry->d_name_nbytes /
                                                   sizeof(utf16lechar);
                return 0;
        }
@@ -755,12 +754,13 @@ dentry_calculate_extraction_name(struct wim_dentry *dentry,
                }
        }
 
-       if (file_name_valid(dentry->file_name, dentry->file_name_nbytes / 2, false)) {
-               ret = utf16le_get_tstr(dentry->file_name,
-                                      dentry->file_name_nbytes,
+       if (file_name_valid(dentry->d_name, dentry->d_name_nbytes / 2, false)) {
+               size_t nbytes = 0;
+               ret = utf16le_get_tstr(dentry->d_name,
+                                      dentry->d_name_nbytes,
                                       (const tchar **)&dentry->d_extraction_name,
-                                      &dentry->d_extraction_name_nchars);
-               dentry->d_extraction_name_nchars /= sizeof(tchar);
+                                      &nbytes);
+               dentry->d_extraction_name_nchars = nbytes / sizeof(tchar);
                return ret;
        } else {
                if (ctx->extract_flags & WIMLIB_EXTRACT_FLAG_REPLACE_INVALID_FILENAMES)
@@ -780,16 +780,16 @@ dentry_calculate_extraction_name(struct wim_dentry *dentry,
 
 out_replace:
        {
-               utf16lechar utf16_name_copy[dentry->file_name_nbytes / 2];
+               utf16lechar utf16_name_copy[dentry->d_name_nbytes / 2];
 
-               memcpy(utf16_name_copy, dentry->file_name, dentry->file_name_nbytes);
-               file_name_valid(utf16_name_copy, dentry->file_name_nbytes / 2, true);
+               memcpy(utf16_name_copy, dentry->d_name, dentry->d_name_nbytes);
+               file_name_valid(utf16_name_copy, dentry->d_name_nbytes / 2, true);
 
                const tchar *tchar_name;
                size_t tchar_nchars;
 
                ret = utf16le_get_tstr(utf16_name_copy,
-                                      dentry->file_name_nbytes,
+                                      dentry->d_name_nbytes,
                                       &tchar_name, &tchar_nchars);
                if (ret)
                        return ret;
@@ -1083,18 +1083,14 @@ static void
 dentry_list_build_inode_alias_lists(struct list_head *dentry_list)
 {
        struct wim_dentry *dentry;
-       struct wim_inode *inode;
+
+       list_for_each_entry(dentry, dentry_list, d_extraction_list_node)
+               dentry->d_inode->i_first_extraction_alias = NULL;
 
        list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
-               inode = dentry->d_inode;
-               if (!inode->i_visited)
-                       INIT_LIST_HEAD(&inode->i_extraction_aliases);
-               list_add_tail(&dentry->d_extraction_alias_node,
-                             &inode->i_extraction_aliases);
-               inode->i_visited = 1;
+               dentry->d_next_extraction_alias = dentry->d_inode->i_first_extraction_alias;
+               dentry->d_inode->i_first_extraction_alias = dentry;
        }
-       list_for_each_entry(dentry, dentry_list, d_extraction_list_node)
-               dentry->d_inode->i_visited = 0;
 }
 
 static void