read_lookup_table(): Change some errors to warnings

[wimlib] / src / lookup_table.c

diff --git a/src/lookup_table.c b/src/lookup_table.c
index 2e45f8f51299fd25e464c4bd20f35d15ea96d639..b79381f00bdd1e4273341b0454d9925e1771248a 100644 (file)
--- a/src/lookup_table.c
+++ b/src/lookup_table.c
@@ -28,7 +28,7 @@
 #  include "config.h"
 #endif
 
 #  include "config.h"
 #endif
 

-#include "wimlib/buffer_io.h"
+#include "wimlib/endianness.h"

 #include "wimlib/error.h"
 #include "wimlib/file_io.h"
 #include "wimlib/lookup_table.h"
 #include "wimlib/error.h"
 #include "wimlib/file_io.h"
 #include "wimlib/lookup_table.h"


@@ -348,8 +348,23 @@ for_lookup_table_entry_pos_sorted(struct wim_lookup_table *table,
        return ret;
 }
 
        return ret;
 }
 

+/* On-disk format of a WIM lookup table entry (stream entry). */
+struct wim_lookup_table_entry_disk {
+       /* Location, offset, compression status, and metadata status of the
+        * stream. */
+       struct resource_entry_disk resource_entry;
+
+       /* Which part of the split WIM this stream is in; indexed from 1. */
+       le16 part_number;
+
+       /* Reference count of this stream over all WIM images. */
+       le32 refcnt;
+
+       /* SHA1 message digest of the uncompressed data of this stream, or
+        * optionally all zeroes if this stream is of zero length. */
+       u8 hash[SHA1_HASH_SIZE];
+} _packed_attribute;

 
 

-/* Size of each lookup table entry in the WIM file. */

 #define WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE 50
 
 /*
 #define WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE 50
 
 /*


@@ -366,11 +381,16 @@ read_lookup_table(WIMStruct *w)
        size_t num_entries;
        struct wim_lookup_table *table;
        struct wim_lookup_table_entry *cur_entry, *duplicate_entry;
        size_t num_entries;
        struct wim_lookup_table *table;
        struct wim_lookup_table_entry *cur_entry, *duplicate_entry;

-       u8 table_buf[(BUFFER_SIZE / WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE) *
-                       WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE];
-       const u8 *p;
+       struct wim_lookup_table_entry_disk
+                       table_buf[BUFFER_SIZE / sizeof(struct wim_lookup_table_entry_disk)]
+                               _aligned_attribute(8);
+
+       BUILD_BUG_ON(sizeof(struct wim_lookup_table_entry_disk) !=
+                    WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE);
+

        off_t offset;
        size_t buf_entries_remaining;
        off_t offset;
        size_t buf_entries_remaining;

+       const struct wim_lookup_table_entry_disk *disk_entry;

 
        DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"",
              w->hdr.lookup_table_res_entry.offset,
 
        DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"",
              w->hdr.lookup_table_res_entry.offset,


@@ -383,23 +403,25 @@ read_lookup_table(WIMStruct *w)
        }
 
        num_entries = w->hdr.lookup_table_res_entry.size /
        }
 
        num_entries = w->hdr.lookup_table_res_entry.size /

-                     WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE;
+                     sizeof(struct wim_lookup_table_entry_disk);

        table = new_lookup_table(num_entries * 2 + 1);
        table = new_lookup_table(num_entries * 2 + 1);

-       if (!table)
+       if (!table) {
+               ERROR("Failed to allocate stream hash table of size %zu",
+                     num_entries * 2 + 1);

                return WIMLIB_ERR_NOMEM;
                return WIMLIB_ERR_NOMEM;

+       }

 
        w->current_image = 0;
        offset = w->hdr.lookup_table_res_entry.offset;
        buf_entries_remaining = 0;
 
        w->current_image = 0;
        offset = w->hdr.lookup_table_res_entry.offset;
        buf_entries_remaining = 0;

-       for (; num_entries != 0; num_entries--, buf_entries_remaining--) {
+       for (; num_entries != 0;
+            num_entries--, buf_entries_remaining--, disk_entry++)
+       {

                if (buf_entries_remaining == 0) {
                        size_t entries_to_read, bytes_to_read;
 
                if (buf_entries_remaining == 0) {
                        size_t entries_to_read, bytes_to_read;
 

-                       entries_to_read = min(sizeof(table_buf) /
-                                               WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE,
-                                             num_entries);
-                       bytes_to_read = entries_to_read *
-                                               WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE;
+                       entries_to_read = min(ARRAY_LEN(table_buf), num_entries);
+                       bytes_to_read = entries_to_read * sizeof(struct wim_lookup_table_entry_disk);

                        if (full_pread(w->in_fd, table_buf,
                                       bytes_to_read, offset) != bytes_to_read)
                        {
                        if (full_pread(w->in_fd, table_buf,
                                       bytes_to_read, offset) != bytes_to_read)
                        {


@@ -409,7 +431,7 @@ read_lookup_table(WIMStruct *w)
                                goto out_free_lookup_table;
                        }
                        offset += bytes_to_read;
                                goto out_free_lookup_table;
                        }
                        offset += bytes_to_read;

-                       p = table_buf;
+                       disk_entry = table_buf;

                        buf_entries_remaining = entries_to_read;
                }
                cur_entry = new_lookup_table_entry();
                        buf_entries_remaining = entries_to_read;
                }
                cur_entry = new_lookup_table_entry();


@@ -420,63 +442,72 @@ read_lookup_table(WIMStruct *w)
 
                cur_entry->wim = w;
                cur_entry->resource_location = RESOURCE_IN_WIM;
 
                cur_entry->wim = w;
                cur_entry->resource_location = RESOURCE_IN_WIM;

-               p = get_resource_entry(p, &cur_entry->resource_entry);
-               p = get_u16(p, &cur_entry->part_number);
-               p = get_u32(p, &cur_entry->refcnt);
-               p = get_bytes(p, SHA1_HASH_SIZE, cur_entry->hash);
+               get_resource_entry(&disk_entry->resource_entry, &cur_entry->resource_entry);
+               cur_entry->part_number = le16_to_cpu(disk_entry->part_number);
+               cur_entry->refcnt = le32_to_cpu(disk_entry->refcnt);
+               copy_hash(cur_entry->hash, disk_entry->hash);

 
                if (cur_entry->part_number != w->hdr.part_number) {
 
                if (cur_entry->part_number != w->hdr.part_number) {

-                       ERROR("A lookup table entry in part %hu of the WIM "
-                             "points to part %hu",
-                             w->hdr.part_number, cur_entry->part_number);
-                       ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
-                       goto out_free_cur_entry;
+                       WARNING("A lookup table entry in part %hu of the WIM "
+                               "points to part %hu (ignoring it)",
+                               w->hdr.part_number, cur_entry->part_number);
+                       free_lookup_table_entry(cur_entry);
+                       continue;

                }
 
                if (is_zero_hash(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;
-                       goto out_free_cur_entry;
+                       WARNING("The WIM lookup table contains an entry with a "
+                               "SHA1 message digest of all 0's (ignoring it)");
+                       free_lookup_table_entry(cur_entry);
+                       continue;

                }
 
                if (!(cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED)
                    && (cur_entry->resource_entry.size !=
                        cur_entry->resource_entry.original_size))
                {
                }
 
                if (!(cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED)
                    && (cur_entry->resource_entry.size !=
                        cur_entry->resource_entry.original_size))
                {

-               #ifdef ENABLE_ERROR_MESSAGES
-                       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, stderr);
-               #endif
-                       ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
-                       goto out_free_cur_entry;
+                       if (wimlib_print_errors) {
+                               WARNING("Found uncompressed resource with "
+                                       "original size (%"PRIu64") not the same "
+                                       "as compressed size (%"PRIu64")",
+                                       cur_entry->resource_entry.original_size,
+                                       cur_entry->resource_entry.size);
+                               if (cur_entry->resource_entry.original_size) {
+                                       WARNING("Overriding compressed size with original size.");
+                                       cur_entry->resource_entry.size =
+                                               cur_entry->resource_entry.original_size;
+                               } else {
+                                       WARNING("Overriding original size with compressed size");
+                                       cur_entry->resource_entry.original_size =
+                                               cur_entry->resource_entry.size;
+                               }
+                       }

                }
 
                if (cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_METADATA) {
                        /* Lookup table entry for a metadata resource */
                        if (cur_entry->refcnt != 1) {
                }
 
                if (cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_METADATA) {
                        /* Lookup table entry for a metadata resource */
                        if (cur_entry->refcnt != 1) {

-                       #ifdef ENABLE_ERROR_MESSAGES
-                               ERROR("Found metadata resource with refcnt != 1:");
-                               print_lookup_table_entry(cur_entry, stderr);
-                       #endif
+                               if (wimlib_print_errors) {
+                                       ERROR("Found metadata resource with refcnt != 1:");
+                                       print_lookup_table_entry(cur_entry, stderr);
+                               }

                                ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
                                goto out_free_cur_entry;
                        }
 
                        if (w->hdr.part_number != 1) {
                                ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
                                goto out_free_cur_entry;
                        }
 
                        if (w->hdr.part_number != 1) {

-                               ERROR("Found a metadata resource in a "
-                                     "non-first part of the split WIM!");
-                               ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
-                               goto out_free_cur_entry;
+                               WARNING("Ignoring metadata resource found in a "
+                                       "non-first part of the split WIM");
+                               free_lookup_table_entry(cur_entry);
+                               continue;

                        }
                        if (w->current_image == w->hdr.image_count) {
                        }
                        if (w->current_image == w->hdr.image_count) {

-                               ERROR("The WIM header says there are %u images "
-                                     "in the WIM, but we found more metadata "
-                                     "resources than this", w->hdr.image_count);
-                               ret = WIMLIB_ERR_IMAGE_COUNT;
-                               goto out_free_cur_entry;
+                               WARNING("The WIM header says there are %u images "
+                                       "in the WIM, but we found more metadata "
+                                       "resources than this (ignoring the extra)",
+                                       w->hdr.image_count);
+                               free_lookup_table_entry(cur_entry);
+                               continue;

                        }
 
                        /* Notice very carefully:  We are assigning the metadata
                        }
 
                        /* Notice very carefully:  We are assigning the metadata


@@ -497,18 +528,19 @@ read_lookup_table(WIMStruct *w)
                         * metadata resource */
                        duplicate_entry = __lookup_resource(table, cur_entry->hash);
                        if (duplicate_entry) {
                         * metadata resource */
                        duplicate_entry = __lookup_resource(table, cur_entry->hash);
                        if (duplicate_entry) {

-                       #ifdef ENABLE_ERROR_MESSAGES
-                               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, stderr);
-                               ERROR("The second entry is:");
-                               print_lookup_table_entry(cur_entry, stderr);
-                       #endif
-                               ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
-                               goto out_free_cur_entry;
+                               if (wimlib_print_errors) {
+                                       WARNING("The WIM lookup table contains two entries with the "
+                                             "same SHA1 message digest!");
+                                       WARNING("The first entry is:");
+                                       print_lookup_table_entry(duplicate_entry, stderr);
+                                       WARNING("The second entry is:");
+                                       print_lookup_table_entry(cur_entry, stderr);
+                               }
+                               free_lookup_table_entry(cur_entry);
+                               continue;
+                       } else {
+                               lookup_table_insert(table, cur_entry);

                        }
                        }

-                       lookup_table_insert(table, cur_entry);

                }
        }
 
                }
        }
 


@@ -534,14 +566,14 @@ out:
 }
 
 
 }
 
 

-static u8 *
-write_lookup_table_entry(const struct wim_lookup_table_entry *lte, u8 *buf_p)
+static void
+write_lookup_table_entry(const struct wim_lookup_table_entry *lte,
+                        struct wim_lookup_table_entry_disk *disk_entry)

 {
 {

-       buf_p = put_resource_entry(buf_p, &lte->output_resource_entry);
-       buf_p = put_u16(buf_p, lte->part_number);
-       buf_p = put_u32(buf_p, lte->out_refcnt);
-       buf_p = put_bytes(buf_p, SHA1_HASH_SIZE, lte->hash);
-       return buf_p;
+       put_resource_entry(&lte->output_resource_entry, &disk_entry->resource_entry);
+       disk_entry->part_number = cpu_to_le16(lte->part_number);
+       disk_entry->refcnt = cpu_to_le32(lte->out_refcnt);
+       copy_hash(disk_entry->hash, lte->hash);

 }
 
 int
 }
 
 int


@@ -551,32 +583,34 @@ write_lookup_table_from_stream_list(struct list_head *stream_list,
 {
        int ret;
        off_t start_offset;
 {
        int ret;
        off_t start_offset;

-       u8 table_buf[(BUFFER_SIZE / WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE) *
-                       WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE];
-       u8 *buf_p;
+       struct wim_lookup_table_entry_disk
+                       table_buf[BUFFER_SIZE / sizeof(struct wim_lookup_table_entry_disk)]
+                               _aligned_attribute(8);

        size_t table_size;
        size_t bytes_to_write;
        struct wim_lookup_table_entry *lte;
        size_t table_size;
        size_t bytes_to_write;
        struct wim_lookup_table_entry *lte;

+       size_t cur_idx;

 
        start_offset = filedes_offset(out_fd);
        if (start_offset == -1)
                goto write_error;
 
 
        start_offset = filedes_offset(out_fd);
        if (start_offset == -1)
                goto write_error;
 

-       buf_p = table_buf;

        table_size = 0;
        table_size = 0;

+       cur_idx = 0;

        list_for_each_entry(lte, stream_list, lookup_table_list) {
        list_for_each_entry(lte, stream_list, lookup_table_list) {

-               if (buf_p == table_buf + sizeof(table_buf)) {
+               if (cur_idx == ARRAY_LEN(table_buf)) {

                        bytes_to_write = sizeof(table_buf);
                        if (full_write(out_fd, table_buf,
                                       bytes_to_write) != bytes_to_write)
                                goto write_error;
                        table_size += bytes_to_write;
                        bytes_to_write = sizeof(table_buf);
                        if (full_write(out_fd, table_buf,
                                       bytes_to_write) != bytes_to_write)
                                goto write_error;
                        table_size += bytes_to_write;

-                       buf_p = table_buf;
+                       cur_idx = 0;

                }
                }

-               buf_p = write_lookup_table_entry(lte, buf_p);
+               write_lookup_table_entry(lte, &table_buf[cur_idx]);
+               cur_idx++;

        }
        }

-       bytes_to_write = buf_p - table_buf;
-       if (bytes_to_write != 0) {
+       if (cur_idx != 0) {
+               bytes_to_write = cur_idx * sizeof(struct wim_lookup_table_entry_disk);

                if (full_write(out_fd, table_buf,
                               bytes_to_write) != bytes_to_write)
                        goto write_error;
                if (full_write(out_fd, table_buf,
                               bytes_to_write) != bytes_to_write)
                        goto write_error;


@@ -737,9 +771,11 @@ do_print_lookup_table_entry(struct wim_lookup_table_entry *lte, void *fp)
  * Prints the lookup table of a WIM file.
  */
 WIMLIBAPI void
  * Prints the lookup table of a WIM file.
  */
 WIMLIBAPI void

-wimlib_print_lookup_table(WIMStruct *w)
+wimlib_print_lookup_table(WIMStruct *wim)

 {
 {

-       for_lookup_table_entry(w->lookup_table,
+       for (int i = 0; i < wim->hdr.image_count; i++)
+               print_lookup_table_entry(wim->image_metadata[i]->metadata_lte, stdout);
+       for_lookup_table_entry(wim->lookup_table,

                               do_print_lookup_table_entry,
                               stdout);
 }
                               do_print_lookup_table_entry,
                               stdout);
 }