4 * Read uncompressed and compressed metadata and file resources from a WIM file.
8 * Copyright (C) 2012, 2013 Eric Biggers
10 * This file is part of wimlib, a library for working with WIM files.
12 * wimlib is free software; you can redistribute it and/or modify it under the
13 * terms of the GNU General Public License as published by the Free Software
14 * Foundation; either version 3 of the License, or (at your option) any later
17 * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
18 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
19 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License along with
22 * wimlib; if not, see http://www.gnu.org/licenses/.
30 #include "wimlib/endianness.h"
31 #include "wimlib/error.h"
32 #include "wimlib/file_io.h"
33 #include "wimlib/lookup_table.h"
34 #include "wimlib/resource.h"
35 #include "wimlib/sha1.h"
38 /* for read_win32_file_prefix(), read_win32_encrypted_file_prefix() */
39 # include "wimlib/win32.h"
43 /* for read_ntfs_file_prefix() */
44 # include "wimlib/ntfs_3g.h"
56 * Compressed WIM resources
58 * A compressed resource in a WIM consists of a number of compressed chunks,
59 * each of which decompresses to a fixed chunk size (given in the WIM header;
60 * usually 32768) except possibly the last, which always decompresses to any
61 * remaining bytes. In addition, immediately before the chunks, a table (the
62 * "chunk table") provides the offset, in bytes relative to the end of the chunk
63 * table, of the start of each compressed chunk, except for the first chunk
64 * which is omitted as it always has an offset of 0. Therefore, a compressed
65 * resource with N chunks will have a chunk table with N - 1 entries.
67 * Additional information:
69 * - Entries in the chunk table are 4 bytes each, except if the uncompressed
70 * size of the resource is greater than 4 GiB, in which case the entries in
71 * the chunk table are 8 bytes each. In either case, the entries are unsigned
72 * little-endian integers.
74 * - The chunk table is included in the compressed size of the resource provided
75 * in the corresponding entry in the WIM's stream lookup table.
77 * - The compressed size of a chunk is never greater than the uncompressed size.
78 * From the compressor's point of view, chunks that would have compressed to a
79 * size greater than or equal to their original size are in fact stored
80 * uncompressed. From the decompresser's point of view, chunks with
81 * compressed size equal to their uncompressed size are in fact uncompressed.
83 * Furthermore, wimlib supports its own "pipable" WIM format, and for this the
84 * structure of compressed resources was modified to allow piped reading and
85 * writing. To make sequential writing possible, the chunk table is placed
86 * after the chunks rather than before the chunks, and to make sequential
87 * reading possible, each chunk is prefixed with a 4-byte header giving its
88 * compressed size as a 32-bit, unsigned, little-endian integer. Otherwise the
89 * details are the same.
93 /* Decompress the specified chunk that uses the specified compression type
94 * @ctype, part of a WIM with default chunk size @wim_chunk_size. For LZX the
95 * separate @wim_chunk_size is needed because it determines the window size used
96 * for LZX compression. */
98 decompress(const void *cchunk, unsigned clen,
99 void *uchunk, unsigned ulen,
100 int ctype, u32 wim_chunk_size)
103 case WIMLIB_COMPRESSION_TYPE_XPRESS:
104 return wimlib_xpress_decompress(cchunk,
108 case WIMLIB_COMPRESSION_TYPE_LZX:
109 return wimlib_lzx_decompress2(cchunk,
120 /* Read data from a compressed WIM resource. Assumes parameters were already
121 * verified by read_partial_wim_resource(). */
123 read_compressed_wim_resource(const struct wim_lookup_table_entry * const lte,
124 const u64 size, const consume_data_callback_t cb,
125 const u32 cb_chunk_size, void * const ctx_or_buf,
126 const int flags, const u64 offset)
131 const u32 orig_chunk_size = wim_resource_chunk_size(lte);
132 const u32 orig_chunk_order = bsr32(orig_chunk_size);
134 wimlib_assert(is_power_of_2(orig_chunk_size));
136 /* Handle the trivial case. */
140 u64 *chunk_offsets = NULL;
143 void *compressed_buf = NULL;
144 bool chunk_offsets_malloced = false;
145 bool out_buf_malloced = false;
146 bool tmp_buf_malloced = false;
147 bool compressed_buf_malloced = false;
149 /* Get the file descriptor for the WIM. */
150 struct filedes * const in_fd = <e->wim->in_fd;
152 /* Determine if we're reading a pipable resource from a pipe or not. */
153 const bool is_pipe_read = !filedes_is_seekable(in_fd);
155 /* Calculate the number of chunks the resource is divided into. */
156 const u64 num_chunks = wim_resource_chunks(lte);
158 /* Calculate the 0-based index of the chunk at which the read starts.
160 const u64 start_chunk = offset >> orig_chunk_order;
162 /* For pipe reads, we always must start from the 0th chunk. */
163 const u64 actual_start_chunk = (is_pipe_read ? 0 : start_chunk);
165 /* Calculate the offset, within the start chunk, of the first byte of
167 const u32 start_offset_in_chunk = offset & (orig_chunk_size - 1);
169 /* Calculate the index of the chunk that contains the last byte of the
171 const u64 end_chunk = (offset + size - 1) >> orig_chunk_order;
173 /* Calculate the offset, within the end chunk, of the last byte of the
175 const u32 end_offset_in_chunk = (offset + size - 1) & (orig_chunk_size - 1);
177 /* Calculate the number of entries in the chunk table; it's one less
178 * than the number of chunks, since the first chunk has no entry. */
179 const u64 num_chunk_entries = num_chunks - 1;
181 /* Set the size of each chunk table entry based on the resource's
182 * uncompressed size. */
183 const u64 chunk_entry_size = (wim_resource_size(lte) > (1ULL << 32)) ? 8 : 4;
185 /* Calculate the size, in bytes, of the full chunk table. */
186 const u64 chunk_table_size = num_chunk_entries * chunk_entry_size;
188 /* Current offset to read from. */
189 u64 cur_read_offset = lte->resource_entry.offset;
191 /* Read the chunk table into memory. */
193 /* Calculate the number of chunk entries are actually needed to
194 * read the requested part of the resource. Include an entry
195 * for the first chunk even though that doesn't exist in the
196 * on-disk table, but take into account that if the last chunk
197 * required for the read is not the last chunk of the resource,
198 * an extra chunk entry is needed so that the compressed size of
199 * the last chunk of the read can be determined. */
200 const u64 num_alloc_chunk_entries = end_chunk - start_chunk +
201 1 + (end_chunk != num_chunks - 1);
203 /* Allocate a buffer to hold a subset of the chunk table. It
204 * will only contain offsets for the chunks that are actually
205 * needed for this read. For speed, allocate the buffer on the
206 * stack unless it's too large. */
207 if ((size_t)(num_alloc_chunk_entries * sizeof(u64)) !=
208 (num_alloc_chunk_entries * sizeof(u64)))
211 if (num_alloc_chunk_entries <= STACK_MAX / sizeof(u64)) {
212 chunk_offsets = alloca(num_alloc_chunk_entries * sizeof(u64));
214 chunk_offsets = MALLOC(num_alloc_chunk_entries * sizeof(u64));
215 if (chunk_offsets == NULL)
217 chunk_offsets_malloced = true;
220 /* Set the implicit offset of the first chunk if it's included
221 * in the needed chunks. */
222 if (start_chunk == 0)
223 chunk_offsets[0] = 0;
225 /* Calculate the index of the first needed entry in the chunk
227 const u64 start_table_idx = (start_chunk == 0) ?
230 /* Calculate the number of entries that need to be read from the
232 const u64 num_needed_chunk_entries = (start_chunk == 0) ?
233 num_alloc_chunk_entries - 1 : num_alloc_chunk_entries;
235 /* Calculate the number of bytes of data that need to be read
236 * from the chunk table. */
237 const size_t chunk_table_needed_size =
238 num_needed_chunk_entries * chunk_entry_size;
240 /* Calculate the byte offset, in the WIM file, of the first
241 * chunk table entry to read. Take into account that if the WIM
242 * file is in the special "pipable" format, then the chunk table
243 * is at the end of the resource, not the beginning. */
244 const u64 file_offset_of_needed_chunk_entries =
245 lte->resource_entry.offset
246 + (start_table_idx * chunk_entry_size)
247 + (lte->is_pipable ? (lte->resource_entry.size - chunk_table_size) : 0);
249 /* Read the needed chunk table entries into the end of the
250 * chunk_offsets buffer. */
251 void * const chunk_tab_data = (u8*)&chunk_offsets[num_alloc_chunk_entries] -
252 chunk_table_needed_size;
253 ret = full_pread(in_fd, chunk_tab_data, chunk_table_needed_size,
254 file_offset_of_needed_chunk_entries);
258 /* Now fill in chunk_offsets from the entries we have read in
259 * chunk_tab_data. Careful: chunk_offsets aliases
260 * chunk_tab_data, which breaks C's aliasing rules when we read
261 * 32-bit integers and store 64-bit integers. But since the
262 * operations are safe as long as the compiler doesn't mess with
263 * their order, we use the gcc may_alias extension to tell the
264 * compiler that loads from the 32-bit integers may alias stores
265 * to the 64-bit integers. */
267 typedef le64 __attribute__((may_alias)) aliased_le64_t;
268 typedef le32 __attribute__((may_alias)) aliased_le32_t;
269 u64 * const chunk_offsets_p = chunk_offsets + (start_chunk == 0);
272 if (chunk_entry_size == 4) {
273 aliased_le32_t *raw_entries = (aliased_le32_t*)chunk_tab_data;
274 for (i = 0; i < num_needed_chunk_entries; i++)
275 chunk_offsets_p[i] = le32_to_cpu(raw_entries[i]);
277 aliased_le64_t *raw_entries = (aliased_le64_t*)chunk_tab_data;
278 for (i = 0; i < num_needed_chunk_entries; i++)
279 chunk_offsets_p[i] = le64_to_cpu(raw_entries[i]);
283 /* Set offset to beginning of first chunk to read. */
284 cur_read_offset += chunk_offsets[0];
286 cur_read_offset += start_chunk * sizeof(struct pwm_chunk_hdr);
288 cur_read_offset += chunk_table_size;
291 /* If using a callback function, allocate a temporary buffer that will
292 * hold data being passed to it. If writing directly to a buffer
293 * instead, arrange to write data directly into it. */
295 u8 *out_buf_end, *out_p;
297 out_buf_size = max(cb_chunk_size, orig_chunk_size);
298 if (out_buf_size <= STACK_MAX) {
299 out_buf = alloca(out_buf_size);
301 out_buf = MALLOC(out_buf_size);
304 out_buf_malloced = true;
308 out_buf = ctx_or_buf;
310 out_buf_end = out_buf + out_buf_size;
313 /* Unless the raw compressed data was requested, allocate a temporary
314 * buffer for reading compressed chunks, each of which can be at most
315 * @orig_chunk_size - 1 bytes. This excludes compressed chunks that are
316 * a full @orig_chunk_size bytes, which are actually stored
318 if (!(flags & WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS)) {
319 if (orig_chunk_size - 1 <= STACK_MAX) {
320 compressed_buf = alloca(orig_chunk_size - 1);
322 compressed_buf = MALLOC(orig_chunk_size - 1);
323 if (compressed_buf == NULL)
325 compressed_buf_malloced = true;
329 /* Allocate yet another temporary buffer, this one for decompressing
330 * chunks for which only part of the data is needed. */
331 if (start_offset_in_chunk != 0 ||
332 (end_offset_in_chunk != orig_chunk_size - 1 &&
333 offset + size != wim_resource_size(lte)))
335 if (orig_chunk_size <= STACK_MAX) {
336 tmp_buf = alloca(orig_chunk_size);
338 tmp_buf = MALLOC(orig_chunk_size);
341 tmp_buf_malloced = true;
345 /* Read, and possibly decompress, each needed chunk, either writing the
346 * data directly into the @ctx_or_buf buffer or passing it to the @cb
347 * callback function. */
348 for (u64 i = actual_start_chunk; i <= end_chunk; i++) {
350 /* Calculate uncompressed size of next chunk. */
352 if ((i == num_chunks - 1) && (wim_resource_size(lte) & (orig_chunk_size - 1)))
353 chunk_usize = (wim_resource_size(lte) & (orig_chunk_size - 1));
355 chunk_usize = orig_chunk_size;
357 /* Calculate compressed size of next chunk. */
360 struct pwm_chunk_hdr chunk_hdr;
362 ret = full_pread(in_fd, &chunk_hdr,
363 sizeof(chunk_hdr), cur_read_offset);
366 chunk_csize = le32_to_cpu(chunk_hdr.compressed_size);
368 if (i == num_chunks - 1) {
369 chunk_csize = lte->resource_entry.size -
371 chunk_offsets[i - start_chunk];
373 chunk_csize -= num_chunks * sizeof(struct pwm_chunk_hdr);
375 chunk_csize = chunk_offsets[i + 1 - start_chunk] -
376 chunk_offsets[i - start_chunk];
379 if (chunk_csize == 0 || chunk_csize > chunk_usize) {
380 ERROR("Invalid chunk size in compressed resource!");
382 ret = WIMLIB_ERR_DECOMPRESSION;
383 goto out_free_memory;
386 cur_read_offset += sizeof(struct pwm_chunk_hdr);
388 if (i >= start_chunk) {
389 /* Calculate how much of this chunk needs to be read. */
390 u32 chunk_needed_size;
391 u32 start_offset = 0;
392 u32 end_offset = orig_chunk_size - 1;
394 if (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS) {
395 chunk_needed_size = chunk_csize;
397 if (i == start_chunk)
398 start_offset = start_offset_in_chunk;
401 end_offset = end_offset_in_chunk;
403 chunk_needed_size = end_offset + 1 - start_offset;
406 if (chunk_csize == chunk_usize ||
407 (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS))
409 /* Read the raw chunk data. */
411 ret = full_pread(in_fd,
414 cur_read_offset + start_offset);
418 /* Read and decompress the chunk. */
422 ret = full_pread(in_fd,
429 if (chunk_needed_size == chunk_usize)
434 ret = decompress(compressed_buf,
438 wim_resource_compression_type(lte),
441 ERROR("Failed to decompress data!");
442 ret = WIMLIB_ERR_DECOMPRESSION;
444 goto out_free_memory;
446 if (chunk_needed_size != chunk_usize)
447 memcpy(out_p, tmp_buf + start_offset,
451 out_p += chunk_needed_size;
454 /* Feed the data to the callback function. */
456 if (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS) {
457 ret = cb(out_buf, out_p - out_buf, ctx_or_buf);
459 goto out_free_memory;
461 } else if (i == end_chunk || out_p == out_buf_end) {
465 for (p = out_buf; p != out_p; p += bytes_sent) {
466 bytes_sent = min(cb_chunk_size, out_p - p);
467 ret = cb(p, bytes_sent, ctx_or_buf);
469 goto out_free_memory;
474 cur_read_offset += chunk_csize;
478 /* Skip data only. */
479 cur_read_offset += chunk_csize;
480 ret = full_pread(in_fd, &dummy, 1, cur_read_offset - 1);
487 && size == lte->resource_entry.original_size
491 /* Skip chunk table at end of pipable resource. */
493 cur_read_offset += chunk_table_size;
494 ret = full_pread(in_fd, &dummy, 1, cur_read_offset - 1);
501 if (chunk_offsets_malloced)
503 if (out_buf_malloced)
505 if (compressed_buf_malloced)
506 FREE(compressed_buf);
507 if (tmp_buf_malloced)
513 ERROR("Not enough memory available to read size=%"PRIu64" bytes "
514 "from compressed resource!", size);
516 ret = WIMLIB_ERR_NOMEM;
517 goto out_free_memory;
520 ERROR_WITH_ERRNO("Error reading compressed file resource!");
521 goto out_free_memory;
524 /* Read raw data from a file descriptor at the specified offset. */
526 read_raw_file_data(struct filedes *in_fd,
528 consume_data_callback_t cb,
535 bool tmp_buf_malloced = false;
538 /* Send data to callback function in chunks. */
539 if (cb_chunk_size <= STACK_MAX) {
540 tmp_buf = alloca(cb_chunk_size);
542 tmp_buf = MALLOC(cb_chunk_size);
543 if (tmp_buf == NULL) {
544 ret = WIMLIB_ERR_NOMEM;
547 tmp_buf_malloced = true;
551 size_t bytes_to_read = min(cb_chunk_size, size);
552 ret = full_pread(in_fd, tmp_buf, bytes_to_read,
556 ret = cb(tmp_buf, bytes_to_read, ctx_or_buf);
559 size -= bytes_to_read;
560 offset += bytes_to_read;
563 /* Read data directly into buffer. */
564 ret = full_pread(in_fd, ctx_or_buf, size, offset);
572 ERROR_WITH_ERRNO("Read error");
574 if (tmp_buf_malloced)
580 * read_partial_wim_resource()-
582 * Read a range of data from an uncompressed or compressed resource in a WIM
583 * file. Data is written into a buffer or fed into a callback function, as
584 * documented in read_resource_prefix().
586 * By default, this function provides the uncompressed data of the resource, and
587 * @size and @offset and interpreted relative to the uncompressed contents of
588 * the resource. This behavior can be modified by either of the following
591 * WIMLIB_READ_RESOURCE_FLAG_RAW_FULL:
592 * Read @size bytes at @offset of the raw contents of the compressed
593 * resource. In the case of pipable resources, this excludes the stream
594 * header. Exclusive with WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS.
596 * WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS:
597 * Read the raw compressed chunks of the compressed resource. @size must
598 * be the full uncompressed size, @offset must be 0, and @cb_chunk_size
599 * must be the resource chunk size.
602 * WIMLIB_ERR_SUCCESS (0)
603 * WIMLIB_ERR_READ (errno set)
604 * WIMLIB_ERR_UNEXPECTED_END_OF_FILE (errno set to 0)
605 * WIMLIB_ERR_NOMEM (errno set to ENOMEM)
606 * WIMLIB_ERR_DECOMPRESSION (errno set to EINVAL)
608 * or other error code returned by the @cb function.
611 read_partial_wim_resource(const struct wim_lookup_table_entry *lte,
612 u64 size, consume_data_callback_t cb,
614 void *ctx_or_buf, int flags, u64 offset)
616 struct filedes *in_fd;
618 /* Verify parameters. */
619 wimlib_assert(lte->resource_location == RESOURCE_IN_WIM);
620 in_fd = <e->wim->in_fd;
622 wimlib_assert(is_power_of_2(cb_chunk_size));
623 if (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS) {
624 /* Raw chunks mode is subject to the restrictions noted. */
625 wimlib_assert(!(flags & WIMLIB_READ_RESOURCE_FLAG_RAW_FULL));
626 wimlib_assert(cb_chunk_size == wim_resource_chunk_size(lte));
627 wimlib_assert(size == lte->resource_entry.original_size);
628 wimlib_assert(offset == 0);
629 } else if (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_FULL) {
630 /* Raw full mode: read must not overrun end of store size. */
631 wimlib_assert(offset + size >= size &&
632 offset + size <= lte->resource_entry.size);
634 /* Normal mode: read must not overrun end of original size. */
635 wimlib_assert(offset + size >= size &&
636 offset + size <= lte->resource_entry.original_size);
639 DEBUG("Reading WIM resource: %"PRIu64" @ +%"PRIu64" "
640 "from %"PRIu64"(%"PRIu64") @ +%"PRIu64" "
641 "(readflags 0x%08x, resflags 0x%02x%s)",
643 lte->resource_entry.size,
644 lte->resource_entry.original_size,
645 lte->resource_entry.offset,
646 flags, lte->resource_entry.flags,
647 (lte->is_pipable ? ", pipable" : ""));
649 if ((flags & WIMLIB_READ_RESOURCE_FLAG_RAW_FULL) ||
650 !resource_is_compressed(<e->resource_entry)) {
651 return read_raw_file_data(in_fd,
656 offset + lte->resource_entry.offset);
658 return read_compressed_wim_resource(lte, size, cb,
660 ctx_or_buf, flags, offset);
665 read_partial_wim_resource_into_buf(const struct wim_lookup_table_entry *lte,
666 size_t size, u64 offset, void *buf)
668 return read_partial_wim_resource(lte, size, NULL, 0, buf, 0, offset);
672 read_wim_resource_prefix(const struct wim_lookup_table_entry *lte,
674 consume_data_callback_t cb,
679 return read_partial_wim_resource(lte, size, cb, cb_chunk_size,
680 ctx_or_buf, flags, 0);
684 /* This function handles reading resource data that is located in an external
685 * file, such as a file that has been added to the WIM image through execution
686 * of a wimlib_add_command.
688 * This assumes the file can be accessed using the standard POSIX open(),
689 * read(), and close(). On Windows this will not necessarily be the case (since
690 * the file may need FILE_FLAG_BACKUP_SEMANTICS to be opened, or the file may be
691 * encrypted), so Windows uses its own code for its equivalent case.
694 read_file_on_disk_prefix(const struct wim_lookup_table_entry *lte,
696 consume_data_callback_t cb,
705 wimlib_assert(size <= wim_resource_size(lte));
706 DEBUG("Reading %"PRIu64" bytes from \"%"TS"\"", size, lte->file_on_disk);
708 raw_fd = open(lte->file_on_disk, O_BINARY | O_RDONLY);
710 ERROR_WITH_ERRNO("Can't open \"%"TS"\"", lte->file_on_disk);
711 return WIMLIB_ERR_OPEN;
713 filedes_init(&fd, raw_fd);
714 ret = read_raw_file_data(&fd, size, cb, cb_chunk_size, ctx_or_buf, 0);
718 #endif /* !__WIN32__ */
720 /* This function handles the trivial case of reading resource data that is, in
721 * fact, already located in an in-memory buffer. */
723 read_buffer_prefix(const struct wim_lookup_table_entry *lte,
724 u64 size, consume_data_callback_t cb,
726 void *ctx_or_buf, int _ignored_flags)
728 wimlib_assert(size <= wim_resource_size(lte));
731 /* Feed the data into the callback function in
732 * appropriately-sized chunks. */
736 for (u64 offset = 0; offset < size; offset += chunk_size) {
737 chunk_size = min(cb_chunk_size, size - offset);
738 ret = cb((const u8*)lte->attached_buffer + offset,
739 chunk_size, ctx_or_buf);
744 /* Copy the data directly into the specified buffer. */
745 memcpy(ctx_or_buf, lte->attached_buffer, size);
750 typedef int (*read_resource_prefix_handler_t)(const struct wim_lookup_table_entry *lte,
752 consume_data_callback_t cb,
758 * read_resource_prefix()-
760 * Reads the first @size bytes from a generic "resource", which may be located
761 * in any one of several locations, such as in a WIM file (compressed or
762 * uncompressed), in an external file, or directly in an in-memory buffer.
764 * This function feeds the data either to a callback function (@cb != NULL,
765 * passing it @ctx_or_buf), or write it directly into a buffer (@cb == NULL,
766 * @ctx_or_buf specifies the buffer, which must have room for at least @size
769 * When (@cb != NULL), @cb_chunk_size specifies the maximum size of data chunks
770 * to feed the callback function. @cb_chunk_size must be positive, and if the
771 * resource is in a WIM file, must be a power of 2. All chunks, except possibly
772 * the last one, will be this size. If (@cb == NULL), @cb_chunk_size is
775 * If the resource is located in a WIM file, @flags can be set as documented in
776 * read_partial_wim_resource(). Otherwise @flags are ignored.
778 * Returns 0 on success; nonzero on error. A nonzero value will be returned if
779 * the resource data cannot be successfully read (for a number of different
780 * reasons, depending on the resource location), or if a callback function was
781 * specified and it returned nonzero.
784 read_resource_prefix(const struct wim_lookup_table_entry *lte,
785 u64 size, consume_data_callback_t cb, u32 cb_chunk_size,
786 void *ctx_or_buf, int flags)
788 /* This function merely verifies several preconditions, then passes
789 * control to an appropriate function for understanding each possible
790 * resource location. */
791 static const read_resource_prefix_handler_t handlers[] = {
792 [RESOURCE_IN_WIM] = read_wim_resource_prefix,
794 [RESOURCE_IN_FILE_ON_DISK] = read_win32_file_prefix,
796 [RESOURCE_IN_FILE_ON_DISK] = read_file_on_disk_prefix,
798 [RESOURCE_IN_ATTACHED_BUFFER] = read_buffer_prefix,
800 [RESOURCE_IN_STAGING_FILE] = read_file_on_disk_prefix,
803 [RESOURCE_IN_NTFS_VOLUME] = read_ntfs_file_prefix,
806 [RESOURCE_WIN32_ENCRYPTED] = read_win32_encrypted_file_prefix,
809 wimlib_assert(lte->resource_location < ARRAY_LEN(handlers)
810 && handlers[lte->resource_location] != NULL);
811 wimlib_assert(cb == NULL || cb_chunk_size > 0);
812 return handlers[lte->resource_location](lte, size, cb, cb_chunk_size,
816 /* Read the full uncompressed data of the specified resource into the specified
817 * buffer, which must have space for at least lte->resource_entry.original_size
820 read_full_resource_into_buf(const struct wim_lookup_table_entry *lte,
823 return read_resource_prefix(lte, wim_resource_size(lte),
827 /* Read the full uncompressed data of the specified resource. A buffer
828 * sufficient to hold the data is allocated and returned in @buf_ret. */
830 read_full_resource_into_alloc_buf(const struct wim_lookup_table_entry *lte,
836 if ((size_t)lte->resource_entry.original_size !=
837 lte->resource_entry.original_size)
839 ERROR("Can't read %"PRIu64" byte resource into "
840 "memory", lte->resource_entry.original_size);
841 return WIMLIB_ERR_NOMEM;
844 buf = MALLOC(lte->resource_entry.original_size);
846 return WIMLIB_ERR_NOMEM;
848 ret = read_full_resource_into_buf(lte, buf);
858 /* Retrieve the full uncompressed data of the specified WIM resource, provided
859 * as a raw `struct resource_entry'. */
861 res_entry_to_data(const struct resource_entry *res_entry,
862 WIMStruct *wim, void **buf_ret)
865 struct wim_lookup_table_entry *lte;
867 lte = new_lookup_table_entry();
869 return WIMLIB_ERR_NOMEM;
871 copy_resource_entry(<e->resource_entry, res_entry);
873 lte->part_number = wim->hdr.part_number;
874 lte_init_wim(lte, wim);
876 ret = read_full_resource_into_alloc_buf(lte, buf_ret);
877 free_lookup_table_entry(lte);
883 consume_data_callback_t extract_chunk;
884 void *extract_chunk_arg;
888 extract_chunk_sha1_wrapper(const void *chunk, size_t chunk_size,
891 struct extract_ctx *ctx = _ctx;
893 sha1_update(&ctx->sha_ctx, chunk, chunk_size);
894 return ctx->extract_chunk(chunk, chunk_size, ctx->extract_chunk_arg);
897 /* Extracts the first @size bytes of a resource to somewhere. In the process,
898 * the SHA1 message digest of the uncompressed resource is checked if the full
899 * resource is being extracted.
901 * @extract_chunk is a function that will be called to extract each chunk of the
904 extract_wim_resource(const struct wim_lookup_table_entry *lte,
906 consume_data_callback_t extract_chunk,
907 void *extract_chunk_arg)
910 if (size == wim_resource_size(lte)) {
912 struct extract_ctx ctx;
913 ctx.extract_chunk = extract_chunk;
914 ctx.extract_chunk_arg = extract_chunk_arg;
915 sha1_init(&ctx.sha_ctx);
916 ret = read_resource_prefix(lte, size,
917 extract_chunk_sha1_wrapper,
918 wim_resource_chunk_size(lte),
921 u8 hash[SHA1_HASH_SIZE];
922 sha1_final(hash, &ctx.sha_ctx);
923 if (!hashes_equal(hash, lte->hash)) {
924 if (wimlib_print_errors) {
925 ERROR("Invalid SHA1 message digest "
926 "on the following WIM resource:");
927 print_lookup_table_entry(lte, stderr);
928 if (lte->resource_location == RESOURCE_IN_WIM)
929 ERROR("The WIM file appears to be corrupt!");
931 ret = WIMLIB_ERR_INVALID_RESOURCE_HASH;
936 ret = read_resource_prefix(lte, size, extract_chunk,
937 wim_resource_chunk_size(lte),
938 extract_chunk_arg, 0);
944 extract_wim_chunk_to_fd(const void *buf, size_t len, void *_fd_p)
946 struct filedes *fd = _fd_p;
947 int ret = full_write(fd, buf, len);
949 ERROR_WITH_ERRNO("Error writing to file descriptor");
953 /* Extract the first @size bytes of the specified resource to the specified file
954 * descriptor. If @size is the full size of the resource, its SHA1 message
955 * digest is also checked. */
957 extract_wim_resource_to_fd(const struct wim_lookup_table_entry *lte,
958 struct filedes *fd, u64 size)
960 return extract_wim_resource(lte, size, extract_wim_chunk_to_fd, fd);
965 sha1_chunk(const void *buf, size_t len, void *ctx)
967 sha1_update(ctx, buf, len);
971 /* Calculate the SHA1 message digest of a resource, storing it in @lte->hash. */
973 sha1_resource(struct wim_lookup_table_entry *lte)
979 ret = read_resource_prefix(lte, wim_resource_size(lte),
980 sha1_chunk, wim_resource_chunk_size(lte),
983 sha1_final(lte->hash, &sha_ctx);
988 /* Translates a WIM resource entry from the on-disk format into an in-memory
991 get_resource_entry(const struct resource_entry_disk *disk_entry,
992 struct resource_entry *entry)
994 /* Note: disk_entry may not be 8 byte aligned--- in that case, the
995 * offset and original_size members will be unaligned. (This is okay
996 * since `struct resource_entry_disk' is declared as packed.) */
998 /* Read the size and flags into a bitfield portably... */
999 entry->size = (((u64)disk_entry->size[0] << 0) |
1000 ((u64)disk_entry->size[1] << 8) |
1001 ((u64)disk_entry->size[2] << 16) |
1002 ((u64)disk_entry->size[3] << 24) |
1003 ((u64)disk_entry->size[4] << 32) |
1004 ((u64)disk_entry->size[5] << 40) |
1005 ((u64)disk_entry->size[6] << 48));
1006 entry->flags = disk_entry->flags;
1007 entry->offset = le64_to_cpu(disk_entry->offset);
1008 entry->original_size = le64_to_cpu(disk_entry->original_size);
1010 /* offset and original_size are truncated to 62 bits to avoid possible
1011 * overflows, when converting to a signed 64-bit integer (off_t) or when
1012 * adding size or original_size. This is okay since no one would ever
1013 * actually have a WIM bigger than 4611686018427387903 bytes... */
1014 if (entry->offset & 0xc000000000000000ULL) {
1015 WARNING("Truncating offset in resource entry");
1016 entry->offset &= 0x3fffffffffffffffULL;
1018 if (entry->original_size & 0xc000000000000000ULL) {
1019 WARNING("Truncating original_size in resource entry");
1020 entry->original_size &= 0x3fffffffffffffffULL;
1024 /* Translates a WIM resource entry from an in-memory format into the on-disk
1027 put_resource_entry(const struct resource_entry *entry,
1028 struct resource_entry_disk *disk_entry)
1030 /* Note: disk_entry may not be 8 byte aligned--- in that case, the
1031 * offset and original_size members will be unaligned. (This is okay
1032 * since `struct resource_entry_disk' is declared as packed.) */
1033 u64 size = entry->size;
1035 disk_entry->size[0] = size >> 0;
1036 disk_entry->size[1] = size >> 8;
1037 disk_entry->size[2] = size >> 16;
1038 disk_entry->size[3] = size >> 24;
1039 disk_entry->size[4] = size >> 32;
1040 disk_entry->size[5] = size >> 40;
1041 disk_entry->size[6] = size >> 48;
1042 disk_entry->flags = entry->flags;
1043 disk_entry->offset = cpu_to_le64(entry->offset);
1044 disk_entry->original_size = cpu_to_le64(entry->original_size);