#endif
#include "wimlib.h"
+#include "wimlib/assert.h"
#include "wimlib/endianness.h"
#include "wimlib/error.h"
#include "wimlib/file_io.h"
#include "wimlib/lookup_table.h"
#include "wimlib/resource.h"
#include "wimlib/sha1.h"
+#include "wimlib/wim.h"
#ifdef __WIN32__
/* for read_win32_file_prefix(), read_win32_encrypted_file_prefix() */
bool chunk_offsets_malloced = false;
bool ubuf_malloced = false;
bool cbuf_malloced = false;
- struct wimlib_decompressor *decompressor;
+ struct wimlib_decompressor *decompressor = NULL;
/* Sanity checks */
wimlib_assert(rspec != NULL);
/* Get the maximum size of uncompressed chunks in this resource, which
* we require be a power of 2. */
- u32 chunk_size;
u64 cur_read_offset = rspec->offset_in_wim;
- int ctype;
+ int ctype = rspec->compression_type;
+ u32 chunk_size = rspec->chunk_size;
if (alt_chunk_table) {
/* Alternate chunk table format. Its header specifies the chunk
- * size and compression format. */
- struct alt_chunk_table_header_disk hdr;
-
- ret = full_pread(in_fd, &hdr, sizeof(hdr), cur_read_offset);
- if (ret)
- goto read_error;
- cur_read_offset += sizeof(hdr);
-
- chunk_size = le32_to_cpu(hdr.chunk_size);
- ctype = le32_to_cpu(hdr.compression_format);
-
- /* Format numbers must be the same as in WIMGAPI to be
- * compatible. */
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_NONE != 0);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_LZX != 1);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_XPRESS != 2);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_LZMS != 3);
- } else {
- /* "Normal" format: the maximum uncompressed chunk size and the
- * compression format default to those of the WIM itself. */
- chunk_size = rspec->wim->chunk_size;
- ctype = rspec->wim->compression_type;
+ * size and compression format. Note: it could be read here;
+ * however, the relevant data was already loaded into @rspec by
+ * read_wim_lookup_table(). */
+ cur_read_offset += sizeof(struct alt_chunk_table_header_disk);
}
+
if (!is_power_of_2(chunk_size)) {
ERROR("Invalid compressed resource: "
- "expected power-of-2 chunk size (got %u)", chunk_size);
+ "expected power-of-2 chunk size (got %"PRIu32")",
+ chunk_size);
ret = WIMLIB_ERR_INVALID_CHUNK_SIZE;
goto out_free_memory;
}
const u64 num_chunk_entries = (alt_chunk_table ? num_chunks : num_chunks - 1);
/* Set the size of each chunk table entry based on the resource's
- * uncompressed size. XXX: Does the alternate chunk table really
- * always have 4-byte entries? */
- const u64 chunk_entry_size =
- (rspec->uncompressed_size > (1ULL << 32) && !alt_chunk_table)
- ? 8 : 4;
+ * uncompressed size. */
+ const u64 chunk_entry_size = get_chunk_entry_size(rspec->uncompressed_size,
+ alt_chunk_table);
/* Calculate the size of the chunk table in bytes. */
const u64 chunk_table_size = num_chunk_entries * chunk_entry_size;
ERROR("Invalid chunk size in compressed resource!");
errno = EINVAL;
ret = WIMLIB_ERR_DECOMPRESSION;
- goto out_save_decompressor;
+ goto out_free_memory;
}
if (rspec->is_pipable)
cur_read_offset += sizeof(struct pwm_chunk_hdr);
ERROR("Failed to decompress data!");
ret = WIMLIB_ERR_DECOMPRESSION;
errno = EINVAL;
- goto out_save_decompressor;
+ goto out_free_memory;
}
}
cur_read_offset += chunk_csize;
ret = (*cb)(&ubuf[start], size, cb_ctx);
if (ret)
- goto out_save_decompressor;
+ goto out_free_memory;
cur_range_pos += size;
if (cur_range_pos == cur_range_end) {
goto read_error;
}
ret = 0;
-out_save_decompressor:
- wimlib_free_decompressor(rspec->wim->decompressor);
- rspec->wim->decompressor = decompressor;
- rspec->wim->decompressor_ctype = ctype;
- rspec->wim->decompressor_max_block_size = chunk_size;
+
out_free_memory:
errno_save = errno;
+ if (decompressor) {
+ wimlib_free_decompressor(rspec->wim->decompressor);
+ rspec->wim->decompressor = decompressor;
+ rspec->wim->decompressor_ctype = ctype;
+ rspec->wim->decompressor_max_block_size = chunk_size;
+ }
if (chunk_offsets_malloced)
FREE(chunk_offsets);
if (ubuf_malloced)
return wim_resource_spec_to_data(&rspec, buf_ret);
}
+int
+wim_reshdr_to_hash(const struct wim_reshdr *reshdr, WIMStruct *wim,
+ u8 hash[SHA1_HASH_SIZE])
+{
+ struct wim_resource_spec rspec;
+ int ret;
+ struct wim_lookup_table_entry *lte;
+
+ wim_res_hdr_to_spec(reshdr, wim, &rspec);
+
+ lte = new_lookup_table_entry();
+ if (lte == NULL)
+ return WIMLIB_ERR_NOMEM;
+
+ lte_bind_wim_resource_spec(lte, &rspec);
+ lte->flags = rspec.flags;
+ lte->size = rspec.uncompressed_size;
+ lte->offset_in_res = 0;
+ lte->unhashed = 1;
+
+ ret = sha1_stream(lte);
+
+ lte_unbind_wim_resource_spec(lte);
+ copy_hash(hash, lte->hash);
+ free_lookup_table_entry(lte);
+ return ret;
+}
+
struct streamifier_context {
struct read_stream_list_callbacks cbs;
struct wim_lookup_table_entry *cur_stream;
if (ctx->cur_stream_offset == ctx->cur_stream->size) {
/* Finished reading all the data for a stream. */
+ ctx->cur_stream_offset = 0;
+
DEBUG("End stream (size=%"PRIu64").", ctx->cur_stream->size);
ret = (*ctx->cbs.end_stream)(ctx->cur_stream, 0,
ctx->cbs.end_stream_ctx);
else
ctx->next_stream = NULL;
}
- ctx->cur_stream_offset = 0;
}
return 0;
}
return (*ctx->cbs.consume_chunk)(chunk, size, ctx->cbs.consume_chunk_ctx);
}
+static void
+get_sha1_string(const u8 md[SHA1_HASH_SIZE], tchar *str)
+{
+ for (size_t i = 0; i < SHA1_HASH_SIZE; i++)
+ str += tsprintf(str, T("%02x"), md[i]);
+}
+
/* Callback for finishing reading a stream while calculating its SHA1 message
* digest. */
static int
* that it is the same as the calculated value. */
if (!hashes_equal(hash, lte->hash)) {
if (wimlib_print_errors) {
- ERROR("Invalid SHA1 message digest "
- "on the following WIM stream:");
- print_lookup_table_entry(lte, stderr);
+ tchar expected_hashstr[SHA1_HASH_SIZE * 2 + 1];
+ tchar actual_hashstr[SHA1_HASH_SIZE * 2 + 1];
+ get_sha1_string(lte->hash, expected_hashstr);
+ get_sha1_string(hash, actual_hashstr);
+ ERROR("The stream is corrupted!\n"
+ " (Expected SHA1=%"TS",\n"
+ " got SHA1=%"TS")",
+ expected_hashstr, actual_hashstr);
}
ret = WIMLIB_ERR_INVALID_RESOURCE_HASH;
errno = EINVAL;
return read_full_stream_with_cbs(lte, &hasher_cbs);
}
+static int
+read_packed_streams(struct wim_lookup_table_entry *first_stream,
+ struct wim_lookup_table_entry *last_stream,
+ u64 stream_count,
+ size_t list_head_offset,
+ const struct read_stream_list_callbacks *sink_cbs)
+{
+ struct data_range *ranges;
+ bool ranges_malloced;
+ struct wim_lookup_table_entry *cur_stream;
+ size_t i;
+ int ret;
+ u64 ranges_alloc_size;
+
+ DEBUG("Reading %"PRIu64" streams combined in same WIM resource",
+ stream_count);
+
+ /* Setup data ranges array (one range per stream to read); this way
+ * read_compressed_wim_resource() does not need to be aware of streams.
+ */
+
+ ranges_alloc_size = stream_count * sizeof(ranges[0]);
+
+ if (unlikely((size_t)ranges_alloc_size != ranges_alloc_size)) {
+ ERROR("Too many streams in one resource!");
+ return WIMLIB_ERR_NOMEM;
+ }
+ if (likely(ranges_alloc_size <= STACK_MAX)) {
+ ranges = alloca(ranges_alloc_size);
+ ranges_malloced = false;
+ } else {
+ ranges = MALLOC(ranges_alloc_size);
+ if (ranges == NULL) {
+ ERROR("Too many streams in one resource!");
+ return WIMLIB_ERR_NOMEM;
+ }
+ ranges_malloced = true;
+ }
+
+ for (i = 0, cur_stream = first_stream;
+ i < stream_count;
+ i++, cur_stream = next_stream(cur_stream, list_head_offset))
+ {
+ ranges[i].offset = cur_stream->offset_in_res;
+ ranges[i].size = cur_stream->size;
+ }
+
+ struct streamifier_context streamifier_ctx = {
+ .cbs = *sink_cbs,
+ .cur_stream = first_stream,
+ .next_stream = next_stream(first_stream, list_head_offset),
+ .cur_stream_offset = 0,
+ .final_stream = last_stream,
+ .list_head_offset = list_head_offset,
+ };
+
+ ret = read_compressed_wim_resource(first_stream->rspec,
+ ranges,
+ stream_count,
+ streamifier_cb,
+ &streamifier_ctx);
+
+ if (ranges_malloced)
+ FREE(ranges);
+
+ if (ret) {
+ if (streamifier_ctx.cur_stream_offset != 0) {
+ ret = (*streamifier_ctx.cbs.end_stream)
+ (streamifier_ctx.cur_stream,
+ ret,
+ streamifier_ctx.cbs.end_stream_ctx);
+ }
+ }
+ return ret;
+}
+
/*
* Read a list of streams, each of which may be in any supported location (e.g.
* in a WIM or in an external file). Unlike read_stream_prefix() or the
struct wim_lookup_table_entry *lte_next, *lte_last;
struct list_head *next2;
- size_t stream_count;
+ u64 stream_count;
/* The next stream is a proper sub-sequence of a WIM
* resource. See if there are other streams in the same
* first stream in the resource that needs to be
* read and @lte_last specifies the last stream
* in the resource that needs to be read. */
-
- DEBUG("Reading %zu streams combined in same "
- "WIM resource", stream_count);
-
next = next2;
-
- struct data_range ranges[stream_count];
-
- {
- struct list_head *next3;
- size_t i;
- struct wim_lookup_table_entry *lte_cur;
-
- next3 = cur;
- for (i = 0; i < stream_count; i++) {
- lte_cur = (struct wim_lookup_table_entry*)
- ((u8*)next3 - list_head_offset);
- ranges[i].offset = lte_cur->offset_in_res;
- ranges[i].size = lte_cur->size;
- next3 = next3->next;
- }
- }
-
- struct streamifier_context streamifier_ctx = {
- .cbs = *sink_cbs,
- .cur_stream = lte,
- .next_stream = next_stream(lte, list_head_offset),
- .cur_stream_offset = 0,
- .final_stream = lte_last,
- .list_head_offset = list_head_offset,
- };
-
- ret = read_compressed_wim_resource(lte->rspec,
- ranges,
- stream_count,
- streamifier_cb,
- &streamifier_ctx);
-
- if (ret) {
- if (streamifier_ctx.cur_stream_offset != 0) {
- ret = (*streamifier_ctx.cbs.end_stream)
- (streamifier_ctx.cur_stream,
- ret,
- streamifier_ctx.cbs.end_stream_ctx);
- }
+ ret = read_packed_streams(lte, lte_last,
+ stream_count,
+ list_head_offset,
+ sink_cbs);
+ if (ret)
return ret;
- }
continue;
}
}
return extract_stream(lte, size, extract_chunk_to_fd, fd);
}
+/* Extract the full uncompressed contents of the specified stream to the
+ * specified file descriptor. */
+int
+extract_full_stream_to_fd(struct wim_lookup_table_entry *lte,
+ struct filedes *fd)
+{
+ return extract_stream_to_fd(lte, fd, lte->size);
+}
+
/* Calculate the SHA1 message digest of a stream and store it in @lte->hash. */
int
sha1_stream(struct wim_lookup_table_entry *lte)
}
/* Convert a short WIM resource header to a stand-alone WIM resource
- * specification. */
+ * specification.
+ *
+ * Note: for packed resources some fields still need to be overridden.
+ */
void
wim_res_hdr_to_spec(const struct wim_reshdr *reshdr, WIMStruct *wim,
struct wim_resource_spec *rspec)
INIT_LIST_HEAD(&rspec->stream_list);
rspec->flags = reshdr->flags;
rspec->is_pipable = wim_is_pipable(wim);
+ if (rspec->flags & WIM_RESHDR_FLAG_COMPRESSED) {
+ rspec->compression_type = wim->compression_type;
+ rspec->chunk_size = wim->chunk_size;
+ } else {
+ rspec->compression_type = WIMLIB_COMPRESSION_TYPE_NONE;
+ rspec->chunk_size = 0;
+ }
}
/* Convert a stand-alone resource specification to a WIM resource header. */
git://wimlib.net / wimlib / blobdiff