Various cleanups

[wimlib] / src / resource.c

diff --git a/src/resource.c b/src/resource.c
index f7a7916e5f0cc0ed94bcae2b30673b500f80db4b..be9bd7ce5a56ccb5c5d1affabde744b9d8c99420 100644 (file)
--- a/src/resource.c
+++ b/src/resource.c
@@ -191,11 +191,11 @@ static int read_compressed_resource(FILE *fp, u64 resource_compressed_size,
        if (chunk_entry_size == 4) {
                u32 *entries = (u32*)chunk_tab_buf;
                while (num_needed_chunk_entries--)
-                       *chunk_tab_p++ = to_le32(*entries++);
+                       *chunk_tab_p++ = le32_to_cpu(*entries++);
        } else {
                u64 *entries = (u64*)chunk_tab_buf;
                while (num_needed_chunk_entries--)
-                       *chunk_tab_p++ = to_le64(*entries++);
+                       *chunk_tab_p++ = le64_to_cpu(*entries++);
        }
 
        /* Done with the chunk table now.  We must now seek to the first chunk
@@ -390,8 +390,21 @@ const u8 *get_resource_entry(const u8 *p, struct resource_entry *entry)
        p = get_u8(p, &flags);
        entry->size = size;
        entry->flags = flags;
+
+       /* offset and original_size are truncated to 62 bits to avoid possible
+        * overflows, when converting to a signed 64-bit integer (off_t) or when
+        * adding size or original_size.  This is okay since no one would ever
+        * actually have a WIM bigger than 4611686018427387903 bytes... */
        p = get_u64(p, &entry->offset);
+       if (entry->offset & 0xc000000000000000ULL) {
+               WARNING("Truncating offset in resource entry");
+               entry->offset &= 0x3fffffffffffffffULL;
+       }
        p = get_u64(p, &entry->original_size);
+       if (entry->original_size & 0xc000000000000000ULL) {
+               WARNING("Truncating original_size in resource entry");
+               entry->original_size &= 0x3fffffffffffffffULL;
+       }
        return p;
 }
 
@@ -554,11 +567,10 @@ begin_wim_resource_chunk_tab(const struct lookup_table_entry *lte,
 {
        u64 size = wim_resource_size(lte);
        u64 num_chunks = (size + WIM_CHUNK_SIZE - 1) / WIM_CHUNK_SIZE;
-       struct chunk_table *chunk_tab = MALLOC(sizeof(struct chunk_table) +
-                                              num_chunks * sizeof(u64));
-       int ret = 0;
+       size_t alloc_size = sizeof(struct chunk_table) + num_chunks * sizeof(u64);
+       struct chunk_table *chunk_tab = CALLOC(1, alloc_size);
+       int ret;
 
-       wimlib_assert(size != 0);
 
        if (!chunk_tab) {
                ERROR("Failed to allocate chunk table for %"PRIu64" byte "
@@ -583,8 +595,9 @@ begin_wim_resource_chunk_tab(const struct lookup_table_entry *lte,
                goto out;
        }
 
-       *chunk_tab_ret = chunk_tab;
+       ret = 0;
 out:
+       *chunk_tab_ret = chunk_tab;
        return ret;
 }
 
@@ -693,11 +706,11 @@ finish_wim_resource_chunk_tab(struct chunk_table *chunk_tab,
        }
 
        if (chunk_tab->bytes_per_chunk_entry == 8) {
-               array_to_le64(chunk_tab->offsets, chunk_tab->num_chunks);
+               array_cpu_to_le64(chunk_tab->offsets, chunk_tab->num_chunks);
        } else {
                for (u64 i = 0; i < chunk_tab->num_chunks; i++)
                        ((u32*)chunk_tab->offsets)[i] =
-                               to_le32(chunk_tab->offsets[i]);
+                               cpu_to_le32(chunk_tab->offsets[i]);
        }
        bytes_written = fwrite((u8*)chunk_tab->offsets +
                                        chunk_tab->bytes_per_chunk_entry,