Code to handle some weird siutations and bad WIMs

[wimlib] / src / lookup_table.c

diff --git a/src/lookup_table.c b/src/lookup_table.c
index 2ccb0ef81ed9d2d2c2952f61995f2480111338c4..0546f958a3108f41dc2b3dffc884a576567b8ea3 100644 (file)
--- a/src/lookup_table.c
+++ b/src/lookup_table.c
@@ -52,7 +52,7 @@ err:
        return NULL;
 }
 
        return NULL;
 }
 

-struct lookup_table_entry *new_lookup_table_entry()
+struct lookup_table_entry *new_lookup_table_entry(WIMStruct *wim)

 {
        struct lookup_table_entry *lte;
        
 {
        struct lookup_table_entry *lte;
        


@@ -66,6 +66,7 @@ struct lookup_table_entry *new_lookup_table_entry()
 
        lte->part_number  = 1;
        lte->refcnt       = 1;
 
        lte->part_number  = 1;
        lte->refcnt       = 1;

+       lte->wim          = wim;

        INIT_LIST_HEAD(&lte->lte_group_list);
        return lte;
 }
        INIT_LIST_HEAD(&lte->lte_group_list);
        return lte;
 }


@@ -75,7 +76,9 @@ void free_lookup_table_entry(struct lookup_table_entry *lte)
        if (lte) {
                if (lte->staging_list.next)
                        list_del(&lte->staging_list);
        if (lte) {
                if (lte->staging_list.next)
                        list_del(&lte->staging_list);

-               FREE(lte->file_on_disk);
+               if (lte->resource_location != RESOURCE_IN_WIM &&
+                   lte->resource_location != RESOURCE_NONEXISTENT)
+                       FREE(lte->file_on_disk);

                FREE(lte);
        }
 }
                FREE(lte);
        }
 }


@@ -167,41 +170,37 @@ int for_lookup_table_entry(struct lookup_table *table,
 
 /*
  * Reads the lookup table from a WIM file.
 
 /*
  * Reads the lookup table from a WIM file.

- *
- * @fp:                The FILE* for the WIM file.
- * @offset:            The offset of the lookup table resource.
- * @size:              The size of the lookup table resource.
- * @lookup_table_ret:          A pointer to a struct lookup_table structure into which the
- *                             lookup table will be returned.
- * @return:            True on success, false on failure.

  */
  */

-int read_lookup_table(FILE *fp, u64 offset, u64 size, 
-                     struct lookup_table **table_ret)
+int read_lookup_table(WIMStruct *w)

 {
 {

-       size_t num_entries;
+       u64    num_entries;

        u8     buf[WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE];
        int    ret;
        struct lookup_table *table;
        u8     buf[WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE];
        int    ret;
        struct lookup_table *table;

-       const u8 *p;
-       struct lookup_table_entry *cur_entry;

 
        DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"",
 
        DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"",

-             offset, size);
+             w->hdr.lookup_table_res_entry.offset,
+             w->hdr.lookup_table_res_entry.original_size);

 
 

-       if (fseeko(fp, offset, SEEK_SET) != 0) {
+       if (fseeko(w->fp, w->hdr.lookup_table_res_entry.offset, SEEK_SET) != 0) {

                ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" to read "
                ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" to read "

-                                "lookup table", offset);
+                                "lookup table",
+                                w->hdr.lookup_table_res_entry.offset);

                return WIMLIB_ERR_READ;
        }
 
                return WIMLIB_ERR_READ;
        }
 

-       num_entries = size / WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE;
+       num_entries = w->hdr.lookup_table_res_entry.original_size /
+                     WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE;

        table = new_lookup_table(num_entries * 2 + 1);
        if (!table)
                return WIMLIB_ERR_NOMEM;
 
        while (num_entries--) {
        table = new_lookup_table(num_entries * 2 + 1);
        if (!table)
                return WIMLIB_ERR_NOMEM;
 
        while (num_entries--) {

-               if (fread(buf, 1, sizeof(buf), fp) != sizeof(buf)) {
-                       if (feof(fp)) {
+               const u8 *p;
+               struct lookup_table_entry *cur_entry, *duplicate_entry;
+
+               if (fread(buf, 1, sizeof(buf), w->fp) != sizeof(buf)) {
+                       if (feof(w->fp)) {

                                ERROR("Unexpected EOF in WIM lookup table!");
                        } else {
                                ERROR_WITH_ERRNO("Error reading WIM lookup "
                                ERROR("Unexpected EOF in WIM lookup table!");
                        } else {
                                ERROR_WITH_ERRNO("Error reading WIM lookup "


@@ -210,20 +209,46 @@ int read_lookup_table(FILE *fp, u64 offset, u64 size,
                        ret = WIMLIB_ERR_READ;
                        goto out;
                }
                        ret = WIMLIB_ERR_READ;
                        goto out;
                }

-               cur_entry = new_lookup_table_entry();
+               cur_entry = new_lookup_table_entry(w);

                if (!cur_entry) {
                        ret = WIMLIB_ERR_NOMEM;
                        goto out;
                }
                if (!cur_entry) {
                        ret = WIMLIB_ERR_NOMEM;
                        goto out;
                }

+               cur_entry->wim = w;
+               cur_entry->resource_location = RESOURCE_IN_WIM;

                         
                p = get_resource_entry(buf, &cur_entry->resource_entry);
                p = get_u16(p, &cur_entry->part_number);
                p = get_u32(p, &cur_entry->refcnt);
                         
                p = get_resource_entry(buf, &cur_entry->resource_entry);
                p = get_u16(p, &cur_entry->part_number);
                p = get_u32(p, &cur_entry->refcnt);

-               p = get_bytes(p, WIM_HASH_SIZE, cur_entry->hash);
+               p = get_bytes(p, SHA1_HASH_SIZE, cur_entry->hash);
+
+               duplicate_entry = __lookup_resource(table, cur_entry->hash);
+               if (duplicate_entry) {
+                       ERROR("The WIM lookup table contains two entries with the "
+                             "same SHA1 message digest!");
+                       ERROR("The first entry is:");
+                       print_lookup_table_entry(duplicate_entry);
+                       ERROR("The second entry is:");
+                       print_lookup_table_entry(cur_entry);
+                       ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
+                       goto out;
+               }

                lookup_table_insert(table, cur_entry);
                lookup_table_insert(table, cur_entry);

+
+               if (!(cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED)
+                   && (cur_entry->resource_entry.size !=
+                     cur_entry->resource_entry.original_size))
+               {
+                       ERROR("Found uncompressed resource with original size "
+                             "not the same as compressed size");
+                       ERROR("The lookup table entry for the resource is as follows:");
+                       print_lookup_table_entry(cur_entry);
+                       ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
+                       goto out;
+               }

        }
        DEBUG("Done reading lookup table.");
        }
        DEBUG("Done reading lookup table.");

-       *table_ret = table;
+       w->lookup_table = table;

        return 0;
 out:
        free_lookup_table(table);
        return 0;
 out:
        free_lookup_table(table);


@@ -258,7 +283,7 @@ int write_lookup_table_entry(struct lookup_table_entry *lte, void *__out)
        p = put_resource_entry(buf, &lte->output_resource_entry);
        p = put_u16(p, lte->part_number);
        p = put_u32(p, lte->out_refcnt);
        p = put_resource_entry(buf, &lte->output_resource_entry);
        p = put_u16(p, lte->part_number);
        p = put_u32(p, lte->out_refcnt);

-       p = put_bytes(p, WIM_HASH_SIZE, lte->hash);
+       p = put_bytes(p, SHA1_HASH_SIZE, lte->hash);

        if (fwrite(buf, 1, sizeof(buf), out) != sizeof(buf)) {
                ERROR_WITH_ERRNO("Failed to write lookup table entry");
                return WIMLIB_ERR_WRITE;
        if (fwrite(buf, 1, sizeof(buf), out) != sizeof(buf)) {
                ERROR_WITH_ERRNO("Failed to write lookup table entry");
                return WIMLIB_ERR_WRITE;


@@ -274,8 +299,12 @@ int zero_out_refcnts(struct lookup_table_entry *entry, void *ignore)
        return 0;
 }
 
        return 0;
 }
 

-int print_lookup_table_entry(struct lookup_table_entry *lte, void *ignore)
+void print_lookup_table_entry(const struct lookup_table_entry *lte)

 {
 {

+       if (!lte) {
+               putchar('\n');
+               return;
+       }

        printf("Offset            = %"PRIu64" bytes\n", 
               lte->resource_entry.offset);
        printf("Size              = %"PRIu64" bytes\n", 
        printf("Offset            = %"PRIu64" bytes\n", 
               lte->resource_entry.offset);
        printf("Size              = %"PRIu64" bytes\n", 


@@ -284,7 +313,7 @@ int print_lookup_table_entry(struct lookup_table_entry *lte, void *ignore)
               lte->resource_entry.original_size);
        printf("Part Number       = %hu\n", lte->part_number);
        printf("Reference Count   = %u\n", lte->refcnt);
               lte->resource_entry.original_size);
        printf("Part Number       = %hu\n", lte->part_number);
        printf("Reference Count   = %u\n", lte->refcnt);

-       printf("Hash              = ");
+       printf("Hash              = 0x");

        print_hash(lte->hash);
        putchar('\n');
        printf("Flags             = ");
        print_hash(lte->hash);
        putchar('\n');
        printf("Flags             = ");


@@ -298,9 +327,27 @@ int print_lookup_table_entry(struct lookup_table_entry *lte, void *ignore)
        if (flags & WIM_RESHDR_FLAG_SPANNED)
                fputs("WIM_RESHDR_FLAG_SPANNED, ", stdout);
        putchar('\n');
        if (flags & WIM_RESHDR_FLAG_SPANNED)
                fputs("WIM_RESHDR_FLAG_SPANNED, ", stdout);
        putchar('\n');

-       if (lte->file_on_disk && !lte->is_symlink)
+       switch (lte->resource_location) {
+       case RESOURCE_IN_WIM:
+               if (lte->wim->filename) {
+                       printf("WIM file          = `%s'\n",
+                              lte->wim->filename);
+               }
+               break;
+       case RESOURCE_IN_FILE_ON_DISK:

                printf("File on Disk      = `%s'\n", lte->file_on_disk);
                printf("File on Disk      = `%s'\n", lte->file_on_disk);

+               break;
+       case RESOURCE_IN_STAGING_FILE:
+               printf("Staging File      = `%s'\n", lte->staging_file_name);
+               break;
+       }

        putchar('\n');
        putchar('\n');

+}
+
+static int do_print_lookup_table_entry(struct lookup_table_entry *lte,
+                                      void *ignore)
+{
+       print_lookup_table_entry(lte);

        return 0;
 }
 
        return 0;
 }
 


@@ -310,7 +357,7 @@ int print_lookup_table_entry(struct lookup_table_entry *lte, void *ignore)
 WIMLIBAPI void wimlib_print_lookup_table(WIMStruct *w)
 {
        for_lookup_table_entry(w->lookup_table, 
 WIMLIBAPI void wimlib_print_lookup_table(WIMStruct *w)
 {
        for_lookup_table_entry(w->lookup_table, 

-                              print_lookup_table_entry,
+                              do_print_lookup_table_entry,

                               NULL);
 }
 
                               NULL);
 }
 


@@ -326,7 +373,7 @@ __lookup_resource(const struct lookup_table *table, const u8 hash[])
 
        i = *(size_t*)hash % table->capacity;
        hlist_for_each_entry(lte, pos, &table->array[i], hash_list)
 
        i = *(size_t*)hash % table->capacity;
        hlist_for_each_entry(lte, pos, &table->array[i], hash_list)

-               if (memcmp(hash, lte->hash, WIM_HASH_SIZE) == 0)
+               if (hashes_equal(hash, lte->hash))

                        return lte;
        return NULL;
 }
                        return lte;
        return NULL;
 }


@@ -398,7 +445,8 @@ int dentry_resolve_ltes(struct dentry *dentry, void *__table)
        struct lookup_table *table = __table;
        struct lookup_table_entry *lte;
 
        struct lookup_table *table = __table;
        struct lookup_table_entry *lte;
 

-       wimlib_assert(!dentry->resolved);
+       if (dentry->resolved)
+               return 0;

 
        /* Resolve the default file stream */
        lte = __lookup_resource(table, dentry->hash);
 
        /* Resolve the default file stream */
        lte = __lookup_resource(table, dentry->hash);


@@ -427,3 +475,13 @@ int dentry_resolve_ltes(struct dentry *dentry, void *__table)
        }
        return 0;
 }
        }
        return 0;
 }

+
+struct lookup_table_entry *
+dentry_first_lte(const struct dentry *dentry, const struct lookup_table *table)
+{
+       if (dentry->resolved)
+               return dentry_first_lte_resolved(dentry);
+       else
+               return dentry_first_lte_unresolved(dentry, table);
+}
+