dentry_first_lte() -> dentry_unnamed_lte()

This probably doesn't make a difference, but when we were looking for the
"first" lookup table entry what we really wanted was to find the lookup table
for the un-named data stream, even if it's in an alternate data stream rather
	than the expected location in the dentry.

diff --git a/src/extract.c b/src/extract.c
index ec6842dcf826ab96a4ea3146e416ab20000130ee..b27c44325fabd8d7078b79d4ababa447b73b8e54 100644 (file)
--- a/src/extract.c
+++ b/src/extract.c
@@ -200,7 +200,7 @@ static int extract_regular_file(WIMStruct *w,
 {
        struct lookup_table_entry *lte;
 
 {
        struct lookup_table_entry *lte;
 

-       lte = dentry_first_lte(dentry, w->lookup_table);
+       lte = dentry_unnamed_lte(dentry, w->lookup_table);

 
        if ((extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK |
                              WIMLIB_EXTRACT_FLAG_HARDLINK)) && lte) {
 
        if ((extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK |
                              WIMLIB_EXTRACT_FLAG_HARDLINK)) && lte) {

diff --git a/src/lookup_table.c b/src/lookup_table.c
index d15a3088d3675578227cfc82438f012242e7c5fe..92fb8a9f178b0713bea0b6000e2fbc18b781edd6 100644 (file)
--- a/src/lookup_table.c
+++ b/src/lookup_table.c
@@ -221,6 +221,14 @@ int read_lookup_table(WIMStruct *w)
                p = get_u32(p, &cur_entry->refcnt);
                p = get_bytes(p, SHA1_HASH_SIZE, cur_entry->hash);
 
                p = get_u32(p, &cur_entry->refcnt);
                p = get_bytes(p, SHA1_HASH_SIZE, cur_entry->hash);
 

+               if (is_zero_hash(cur_entry->hash)) {
+                       ERROR("The WIM lookup table contains an entry with a "
+                             "SHA1 message digest of all 0's");
+                       ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
+                       FREE(cur_entry);
+                       goto out;
+               }
+

                duplicate_entry = __lookup_resource(table, cur_entry->hash);
                if (duplicate_entry) {
                        ERROR("The WIM lookup table contains two entries with the "
                duplicate_entry = __lookup_resource(table, cur_entry->hash);
                if (duplicate_entry) {
                        ERROR("The WIM lookup table contains two entries with the "


@@ -230,6 +238,7 @@ int read_lookup_table(WIMStruct *w)
                        ERROR("The second entry is:");
                        print_lookup_table_entry(cur_entry);
                        ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
                        ERROR("The second entry is:");
                        print_lookup_table_entry(cur_entry);
                        ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;

+                       FREE(cur_entry);

                        goto out;
                }
                lookup_table_insert(table, cur_entry);
                        goto out;
                }
                lookup_table_insert(table, cur_entry);


@@ -481,12 +490,29 @@ int dentry_resolve_ltes(struct dentry *dentry, void *__table)
        return 0;
 }
 
        return 0;
 }
 

+/* Return the lookup table entry for the unnamed data stream of a dentry, or
+ * NULL if there is none.
+ *
+ * You'd think this would be easier than it actually is, since the unnamed data
+ * stream should be the one referenced from the dentry itself.  Alas, if there
+ * are named data streams, Microsoft's "imagex.exe" program will put the unnamed
+ * data stream in one of the alternate data streams instead of inside the
+ * dentry.  So we need to check the alternate data streams too.
+ *
+ * Also, note that a dentry may appear to have than one unnamed stream, but if
+ * the SHA1 message digest is all 0's then the corresponding stream does not
+ * really "count" (this is the case for the dentry's own file stream when the
+ * file stream that should be there is actually in one of the alternate stream
+ * entries.).  This is despite the fact that we may need to extract such a
+ * missing entry as an empty file or empty named data stream.
+ */

 struct lookup_table_entry *
 struct lookup_table_entry *

-dentry_first_lte(const struct dentry *dentry, const struct lookup_table *table)
+dentry_unnamed_lte(const struct dentry *dentry,
+                  const struct lookup_table *table)

 {
        if (dentry->resolved)
 {
        if (dentry->resolved)

-               return dentry_first_lte_resolved(dentry);
+               return dentry_unnamed_lte_resolved(dentry);

        else
        else

-               return dentry_first_lte_unresolved(dentry, table);
+               return dentry_unnamed_lte_unresolved(dentry, table);

 }
 
 }
 

diff --git a/src/lookup_table.h b/src/lookup_table.h
index 43494efeb8c3e24bd43e9537776a234b20b13024..3a653bfb531b15c13a437ac2a647c378c0e71a75 100644 (file)
--- a/src/lookup_table.h
+++ b/src/lookup_table.h
@@ -299,7 +299,7 @@ static inline u16 dentry_stream_name_len(const struct dentry *dentry,
 {
        wimlib_assert(stream_idx <= dentry->num_ads);
        if (stream_idx == 0)
 {
        wimlib_assert(stream_idx <= dentry->num_ads);
        if (stream_idx == 0)

-               return dentry->file_name_len;
+               return 0;

        else
                return dentry->ads_entries[stream_idx - 1].stream_name_len;
 }
        else
                return dentry->ads_entries[stream_idx - 1].stream_name_len;
 }


@@ -332,35 +332,34 @@ static inline const u8 *dentry_stream_hash(const struct dentry *dentry,
 }
 
 static inline struct lookup_table_entry *
 }
 
 static inline struct lookup_table_entry *

-dentry_first_lte_resolved(const struct dentry *dentry)
+dentry_unnamed_lte_resolved(const struct dentry *dentry)

 {
        struct lookup_table_entry *lte;
        wimlib_assert(dentry->resolved);
 
 {
        struct lookup_table_entry *lte;
        wimlib_assert(dentry->resolved);
 

-       for (unsigned i = 0; i <= dentry->num_ads; i++) {
-               lte = dentry_stream_lte_resolved(dentry, i);
-               if (lte)
-                       return lte;
-       }
+       for (unsigned i = 0; i <= dentry->num_ads; i++)
+               if (dentry_stream_name_len(dentry, i) == 0 &&
+                    !is_zero_hash(dentry_stream_hash_resolved(dentry, i)))
+                       return dentry_stream_lte_resolved(dentry, i);

        return NULL;
 }
 
 static inline struct lookup_table_entry *
        return NULL;
 }
 
 static inline struct lookup_table_entry *

-dentry_first_lte_unresolved(const struct dentry *dentry,
-                           const struct lookup_table *table)
+dentry_unnamed_lte_unresolved(const struct dentry *dentry,
+                             const struct lookup_table *table)

 {
        struct lookup_table_entry *lte;
        wimlib_assert(!dentry->resolved);
 
 {
        struct lookup_table_entry *lte;
        wimlib_assert(!dentry->resolved);
 

-       for (unsigned i = 0; i <= dentry->num_ads; i++) {
-               lte = dentry_stream_lte_unresolved(dentry, i, table);
-               if (lte)
-                       return lte;
-       }
+       for (unsigned i = 0; i <= dentry->num_ads; i++)
+               if (dentry_stream_name_len(dentry, i) == 0 &&
+                    !is_zero_hash(dentry_stream_hash_unresolved(dentry, i)))
+                       return dentry_stream_lte_unresolved(dentry, i, table);

        return NULL;
 }
 
 extern struct lookup_table_entry *
        return NULL;
 }
 
 extern struct lookup_table_entry *

-dentry_first_lte(const struct dentry *dentry, const struct lookup_table *table);
+dentry_unnamed_lte(const struct dentry *dentry,
+                  const struct lookup_table *table);

 
 #endif
 
 #endif

diff --git a/src/mount.c b/src/mount.c
index 1510fbfb0c1b3f2429afb8e735ba44134623daad..f6c178b494bb64fe57133a8ef805be31a6715ab7 100644 (file)
--- a/src/mount.c
+++ b/src/mount.c
@@ -221,7 +221,7 @@ int dentry_to_stbuf(const struct dentry *dentry, struct stat *stbuf)
        stbuf->st_gid   = getgid();
 
        /* Use the size of the unnamed (default) file stream. */
        stbuf->st_gid   = getgid();
 
        /* Use the size of the unnamed (default) file stream. */

-       lte = dentry_first_lte_resolved(dentry);
+       lte = dentry_unnamed_lte_resolved(dentry);

        if (lte) {
                if (lte->resource_location == RESOURCE_IN_STAGING_FILE) {
                        wimlib_assert(lte->staging_file_name);
        if (lte) {
                if (lte->resource_location == RESOURCE_IN_STAGING_FILE) {
                        wimlib_assert(lte->staging_file_name);

diff --git a/src/ntfs-apply.c b/src/ntfs-apply.c
index 4118a30af74dac5fc5e3f626c39d03aa86ae5a69..3ec0ae75526e89b153495a224d60d0be48302893 100644 (file)
--- a/src/ntfs-apply.c
+++ b/src/ntfs-apply.c
@@ -268,7 +268,7 @@ static int apply_reparse_data(ntfs_inode *ni, const struct dentry *dentry,
 
        wimlib_assert(dentry->attributes & FILE_ATTRIBUTE_REPARSE_POINT);
 
 
        wimlib_assert(dentry->attributes & FILE_ATTRIBUTE_REPARSE_POINT);
 

-       lte = dentry_first_lte(dentry, w->lookup_table);
+       lte = dentry_unnamed_lte(dentry, w->lookup_table);

 
        DEBUG("Applying reparse data to `%s'", dentry->full_path_utf8);
 
 
        DEBUG("Applying reparse data to `%s'", dentry->full_path_utf8);
 

diff --git a/src/resource.c b/src/resource.c
index 3c573f1c9131d4cfb0af8f1ff8e68b87964366b0..0c7a4cf9b40f3a929ec459188e7239fc96051604 100644 (file)
--- a/src/resource.c
+++ b/src/resource.c
@@ -882,7 +882,9 @@ static int write_wim_resource(struct lookup_table_entry *lte,
                }
        }
 
                }
        }
 

-       if (new_compressed_size > original_size) {
+       if (new_compressed_size >= original_size &&
+           out_ctype != WIM_COMPRESSION_TYPE_NONE && !raw)
+       {

                /* Oops!  We compressed the resource to larger than the original
                 * size.  Write the resource uncompressed instead. */
                if (fseeko(out_fp, file_offset, SEEK_SET) != 0) {
                /* Oops!  We compressed the resource to larger than the original
                 * size.  Write the resource uncompressed instead. */
                if (fseeko(out_fp, file_offset, SEEK_SET) != 0) {

diff --git a/src/sha1.h b/src/sha1.h
index a5d695d65a633d5e01428d56659b3067ea1e0f89..e153f5338335b92e31ae181b11180bd9e14379d1 100644 (file)
--- a/src/sha1.h
+++ b/src/sha1.h
@@ -39,9 +39,10 @@ static inline void print_hash(const u8 hash[SHA1_HASH_SIZE])
 
 static inline bool is_zero_hash(const u8 hash[SHA1_HASH_SIZE])
 {
 
 static inline bool is_zero_hash(const u8 hash[SHA1_HASH_SIZE])
 {

-       for (u8 i = 0; i < SHA1_HASH_SIZE / 4; i++)
-               if (((u32*)hash)[i])
-                       return false;
+       if (hash)
+               for (u8 i = 0; i < SHA1_HASH_SIZE / 4; i++)
+                       if (((u32*)hash)[i])
+                               return false;

        return true;
 }
 
        return true;
 }
 

diff --git a/src/symlink.c b/src/symlink.c
index ca2e422fca2176e49f6f6b1054bc0667736bcce0..3773fb053012f63db8dee41ed0460fcfb9098895 100644 (file)
--- a/src/symlink.c
+++ b/src/symlink.c
@@ -168,7 +168,7 @@ ssize_t dentry_readlink(const struct dentry *dentry, char *buf, size_t buf_len,
 
        wimlib_assert(dentry_is_symlink(dentry));
 
 
        wimlib_assert(dentry_is_symlink(dentry));
 

-       lte = dentry_first_lte(dentry, w->lookup_table);
+       lte = dentry_unnamed_lte(dentry, w->lookup_table);

        if (!lte)
                return -EIO;
 
        if (!lte)
                return -EIO;