b9ddc076b75d4947b35d7c080535993fb017235b
[wimlib] / src / resource.c
1 /*
2  * resource.c
3  *
4  * Read uncompressed and compressed metadata and file resources from a WIM file.
5  */
6
7 /*
8  * Copyright (C) 2012, 2013 Eric Biggers
9  *
10  * This file is part of wimlib, a library for working with WIM files.
11  *
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
15  * version.
16  *
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.
20  *
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/.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 #  include "config.h"
27 #endif
28
29 #include "wimlib.h"
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"
36
37 #ifdef __WIN32__
38 /* for read_win32_file_prefix(), read_win32_encrypted_file_prefix() */
39 #  include "wimlib/win32.h"
40 #endif
41
42 #ifdef WITH_NTFS_3G
43 /* for read_ntfs_file_prefix() */
44 #  include "wimlib/ntfs_3g.h"
45 #endif
46
47 #ifdef HAVE_ALLOCA_H
48 #  include <alloca.h>
49 #endif
50 #include <errno.h>
51 #include <fcntl.h>
52 #include <stdlib.h>
53 #include <unistd.h>
54
55 /*
56  *                         Compressed WIM resources
57  *
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.
66  *
67  * Additional information:
68  *
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.
73  *
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.
76  *
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.
82  *
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.
90  */
91
92
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.  */
97 static int
98 decompress(const void *cchunk, unsigned clen,
99            void *uchunk, unsigned ulen,
100            int ctype, u32 wim_chunk_size)
101 {
102         switch (ctype) {
103         case WIMLIB_COMPRESSION_TYPE_XPRESS:
104                 return wimlib_xpress_decompress(cchunk,
105                                                 clen,
106                                                 uchunk,
107                                                 ulen);
108         case WIMLIB_COMPRESSION_TYPE_LZX:
109                 return wimlib_lzx_decompress2(cchunk,
110                                               clen,
111                                               uchunk,
112                                               ulen,
113                                               wim_chunk_size);
114         default:
115                 wimlib_assert(0);
116                 return -1;
117         }
118 }
119
120 /* Read data from a compressed WIM resource.  Assumes parameters were already
121  * verified by read_partial_wim_resource().  */
122 static int
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)
127 {
128         int ret;
129         int errno_save;
130
131         const u32 orig_chunk_size = wim_resource_chunk_size(lte);
132         const u32 orig_chunk_order = bsr32(orig_chunk_size);
133
134         wimlib_assert(is_power_of_2(orig_chunk_size));
135
136         /* Handle the trivial case.  */
137         if (size == 0)
138                 return 0;
139
140         u64 *chunk_offsets = NULL;
141         u8 *out_buf = NULL;
142         u8 *tmp_buf = 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;
148
149         /* Get the file descriptor for the WIM.  */
150         struct filedes * const in_fd = &lte->wim->in_fd;
151
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);
154
155         /* Calculate the number of chunks the resource is divided into.  */
156         const u64 num_chunks = wim_resource_chunks(lte);
157
158         /* Calculate the 0-based index of the chunk at which the read starts.
159          */
160         const u64 start_chunk = offset >> orig_chunk_order;
161
162         /* For pipe reads, we always must start from the 0th chunk.  */
163         const u64 actual_start_chunk = (is_pipe_read ? 0 : start_chunk);
164
165         /* Calculate the offset, within the start chunk, of the first byte of
166          * the read.  */
167         const u32 start_offset_in_chunk = offset & (orig_chunk_size - 1);
168
169         /* Calculate the index of the chunk that contains the last byte of the
170          * read.  */
171         const u64 end_chunk = (offset + size - 1) >> orig_chunk_order;
172
173         /* Calculate the offset, within the end chunk, of the last byte of the
174          * read.  */
175         const u32 end_offset_in_chunk = (offset + size - 1) & (orig_chunk_size - 1);
176
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;
180
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;
184
185         /* Calculate the size, in bytes, of the full chunk table.  */
186         const u64 chunk_table_size = num_chunk_entries * chunk_entry_size;
187
188         /* Current offset to read from.  */
189         u64 cur_read_offset = lte->resource_entry.offset;
190         if (!is_pipe_read) {
191                 /* Read the chunk table into memory.  */
192
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);
202
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)))
209                         goto oom;
210
211                 if (num_alloc_chunk_entries <= STACK_MAX / sizeof(u64)) {
212                         chunk_offsets = alloca(num_alloc_chunk_entries * sizeof(u64));
213                 } else {
214                         chunk_offsets = MALLOC(num_alloc_chunk_entries * sizeof(u64));
215                         if (chunk_offsets == NULL)
216                                 goto oom;
217                         chunk_offsets_malloced = true;
218                 }
219
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;
224
225                 /* Calculate the index of the first needed entry in the chunk
226                  * table.  */
227                 const u64 start_table_idx = (start_chunk == 0) ?
228                                 0 : start_chunk - 1;
229
230                 /* Calculate the number of entries that need to be read from the
231                  * chunk table.  */
232                 const u64 num_needed_chunk_entries = (start_chunk == 0) ?
233                                 num_alloc_chunk_entries - 1 : num_alloc_chunk_entries;
234
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;
239
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);
248
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);
255                 if (ret)
256                         goto read_error;
257
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.  */
266                 {
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);
270                         u64 i;
271
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]);
276                         } else {
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]);
280                         }
281                 }
282
283                 /* Set offset to beginning of first chunk to read.  */
284                 cur_read_offset += chunk_offsets[0];
285                 if (lte->is_pipable)
286                         cur_read_offset += start_chunk * sizeof(struct pwm_chunk_hdr);
287                 else
288                         cur_read_offset += chunk_table_size;
289         }
290
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.  */
294         size_t out_buf_size;
295         u8 *out_buf_end, *out_p;
296         if (cb) {
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);
300                 } else {
301                         out_buf = MALLOC(out_buf_size);
302                         if (out_buf == NULL)
303                                 goto oom;
304                         out_buf_malloced = true;
305                 }
306         } else {
307                 out_buf_size = size;
308                 out_buf = ctx_or_buf;
309         }
310         out_buf_end = out_buf + out_buf_size;
311         out_p = out_buf;
312
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
317          * uncompressed.  */
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);
321                 } else {
322                         compressed_buf = MALLOC(orig_chunk_size - 1);
323                         if (compressed_buf == NULL)
324                                 goto oom;
325                         compressed_buf_malloced = true;
326                 }
327         }
328
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)))
334         {
335                 if (orig_chunk_size <= STACK_MAX) {
336                         tmp_buf = alloca(orig_chunk_size);
337                 } else {
338                         tmp_buf = MALLOC(orig_chunk_size);
339                         if (tmp_buf == NULL)
340                                 goto oom;
341                         tmp_buf_malloced = true;
342                 }
343         }
344
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++) {
349
350                 /* Calculate uncompressed size of next chunk.  */
351                 u32 chunk_usize;
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));
354                 else
355                         chunk_usize = orig_chunk_size;
356
357                 /* Calculate compressed size of next chunk.  */
358                 u32 chunk_csize;
359                 if (is_pipe_read) {
360                         struct pwm_chunk_hdr chunk_hdr;
361
362                         ret = full_pread(in_fd, &chunk_hdr,
363                                          sizeof(chunk_hdr), cur_read_offset);
364                         if (ret)
365                                 goto read_error;
366                         chunk_csize = le32_to_cpu(chunk_hdr.compressed_size);
367                 } else {
368                         if (i == num_chunks - 1) {
369                                 chunk_csize = lte->resource_entry.size -
370                                               chunk_table_size -
371                                               chunk_offsets[i - start_chunk];
372                                 if (lte->is_pipable)
373                                         chunk_csize -= num_chunks * sizeof(struct pwm_chunk_hdr);
374                         } else {
375                                 chunk_csize = chunk_offsets[i + 1 - start_chunk] -
376                                               chunk_offsets[i - start_chunk];
377                         }
378                 }
379                 if (chunk_csize == 0 || chunk_csize > chunk_usize) {
380                         ERROR("Invalid chunk size in compressed resource!");
381                         errno = EINVAL;
382                         ret = WIMLIB_ERR_DECOMPRESSION;
383                         goto out_free_memory;
384                 }
385                 if (lte->is_pipable)
386                         cur_read_offset += sizeof(struct pwm_chunk_hdr);
387
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;
393
394                         if (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS) {
395                                 chunk_needed_size = chunk_csize;
396                         } else {
397                                 if (i == start_chunk)
398                                         start_offset = start_offset_in_chunk;
399
400                                 if (i == end_chunk)
401                                         end_offset = end_offset_in_chunk;
402
403                                 chunk_needed_size = end_offset + 1 - start_offset;
404                         }
405
406                         if (chunk_csize == chunk_usize ||
407                             (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS))
408                         {
409                                 /* Read the raw chunk data.  */
410
411                                 ret = full_pread(in_fd,
412                                                  out_p,
413                                                  chunk_needed_size,
414                                                  cur_read_offset + start_offset);
415                                 if (ret)
416                                         goto read_error;
417                         } else {
418                                 /* Read and decompress the chunk.  */
419
420                                 u8 *target;
421
422                                 ret = full_pread(in_fd,
423                                                  compressed_buf,
424                                                  chunk_csize,
425                                                  cur_read_offset);
426                                 if (ret)
427                                         goto read_error;
428
429                                 if (chunk_needed_size == chunk_usize)
430                                         target = out_p;
431                                 else
432                                         target = tmp_buf;
433
434                                 ret = decompress(compressed_buf,
435                                                  chunk_csize,
436                                                  target,
437                                                  chunk_usize,
438                                                  wim_resource_compression_type(lte),
439                                                  orig_chunk_size);
440                                 if (ret) {
441                                         ERROR("Failed to decompress data!");
442                                         ret = WIMLIB_ERR_DECOMPRESSION;
443                                         errno = EINVAL;
444                                         goto out_free_memory;
445                                 }
446                                 if (chunk_needed_size != chunk_usize)
447                                         memcpy(out_p, tmp_buf + start_offset,
448                                                chunk_needed_size);
449                         }
450
451                         out_p += chunk_needed_size;
452
453                         if (cb) {
454                                 /* Feed the data to the callback function.  */
455
456                                 if (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS) {
457                                         ret = cb(out_buf, out_p - out_buf, ctx_or_buf);
458                                         if (ret)
459                                                 goto out_free_memory;
460                                         out_p = out_buf;
461                                 } else if (i == end_chunk || out_p == out_buf_end) {
462                                         size_t bytes_sent;
463                                         const u8 *p;
464
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);
468                                                 if (ret)
469                                                         goto out_free_memory;
470                                         }
471                                         out_p = out_buf;
472                                 }
473                         }
474                         cur_read_offset += chunk_csize;
475                 } else {
476                         u8 dummy;
477
478                         /* Skip data only.  */
479                         cur_read_offset += chunk_csize;
480                         ret = full_pread(in_fd, &dummy, 1, cur_read_offset - 1);
481                         if (ret)
482                                 goto read_error;
483                 }
484         }
485
486         if (is_pipe_read
487             && size == lte->resource_entry.original_size
488             && chunk_table_size)
489         {
490                 u8 dummy;
491                 /* Skip chunk table at end of pipable resource.  */
492
493                 cur_read_offset += chunk_table_size;
494                 ret = full_pread(in_fd, &dummy, 1, cur_read_offset - 1);
495                 if (ret)
496                         goto read_error;
497         }
498         ret = 0;
499 out_free_memory:
500         errno_save = errno;
501         if (chunk_offsets_malloced)
502                 FREE(chunk_offsets);
503         if (out_buf_malloced)
504                 FREE(out_buf);
505         if (compressed_buf_malloced)
506                 FREE(compressed_buf);
507         if (tmp_buf_malloced)
508                 FREE(tmp_buf);
509         errno = errno_save;
510         return ret;
511
512 oom:
513         ERROR("Not enough memory available to read size=%"PRIu64" bytes "
514               "from compressed resource!", size);
515         errno = ENOMEM;
516         ret = WIMLIB_ERR_NOMEM;
517         goto out_free_memory;
518
519 read_error:
520         ERROR_WITH_ERRNO("Error reading compressed file resource!");
521         goto out_free_memory;
522 }
523
524 /* Read raw data from a file descriptor at the specified offset.  */
525 static int
526 read_raw_file_data(struct filedes *in_fd,
527                    u64 size,
528                    consume_data_callback_t cb,
529                    u32 cb_chunk_size,
530                    void *ctx_or_buf,
531                    u64 offset)
532 {
533         int ret;
534         u8 *tmp_buf;
535         bool tmp_buf_malloced = false;
536
537         if (cb) {
538                 /* Send data to callback function in chunks.  */
539                 if (cb_chunk_size <= STACK_MAX) {
540                         tmp_buf = alloca(cb_chunk_size);
541                 } else {
542                         tmp_buf = MALLOC(cb_chunk_size);
543                         if (tmp_buf == NULL) {
544                                 ret = WIMLIB_ERR_NOMEM;
545                                 goto out;
546                         }
547                         tmp_buf_malloced = true;
548                 }
549
550                 while (size) {
551                         size_t bytes_to_read = min(cb_chunk_size, size);
552                         ret = full_pread(in_fd, tmp_buf, bytes_to_read,
553                                          offset);
554                         if (ret)
555                                 goto read_error;
556                         ret = cb(tmp_buf, bytes_to_read, ctx_or_buf);
557                         if (ret)
558                                 goto out;
559                         size -= bytes_to_read;
560                         offset += bytes_to_read;
561                 }
562         } else {
563                 /* Read data directly into buffer.  */
564                 ret = full_pread(in_fd, ctx_or_buf, size, offset);
565                 if (ret)
566                         goto read_error;
567         }
568         ret = 0;
569         goto out;
570
571 read_error:
572         ERROR_WITH_ERRNO("Read error");
573 out:
574         if (tmp_buf_malloced)
575                 FREE(tmp_buf);
576         return ret;
577 }
578
579 /*
580  * read_partial_wim_resource()-
581  *
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().
585  *
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
589  * flags:
590  *
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.
595  *
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.
600  *
601  * Return values:
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)
607  *
608  *      or other error code returned by the @cb function.
609  */
610 int
611 read_partial_wim_resource(const struct wim_lookup_table_entry *lte,
612                           u64 size, consume_data_callback_t cb,
613                           u32 cb_chunk_size,
614                           void *ctx_or_buf, int flags, u64 offset)
615 {
616         struct filedes *in_fd;
617         int ret;
618
619         /* Verify parameters.  */
620         wimlib_assert(lte->resource_location == RESOURCE_IN_WIM);
621         in_fd = &lte->wim->in_fd;
622         if (cb)
623                 wimlib_assert(is_power_of_2(cb_chunk_size));
624         if (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_CHUNKS) {
625                 /* Raw chunks mode is subject to the restrictions noted.  */
626                 wimlib_assert(!(flags & WIMLIB_READ_RESOURCE_FLAG_RAW_FULL));
627                 wimlib_assert(cb_chunk_size == wim_resource_chunk_size(lte));
628                 wimlib_assert(size == lte->resource_entry.original_size);
629                 wimlib_assert(offset == 0);
630         } else if (flags & WIMLIB_READ_RESOURCE_FLAG_RAW_FULL) {
631                 /* Raw full mode:  read must not overrun end of store size.  */
632                 wimlib_assert(offset + size >= size &&
633                               offset + size <= lte->resource_entry.size);
634         } else {
635                 /* Normal mode:  read must not overrun end of original size.  */
636                 wimlib_assert(offset + size >= size &&
637                               offset + size <= lte->resource_entry.original_size);
638         }
639
640         DEBUG("Reading WIM resource: %"PRIu64" @ +%"PRIu64" "
641               "from %"PRIu64"(%"PRIu64") @ +%"PRIu64" "
642               "(readflags 0x%08x, resflags 0x%02x%s)",
643               size, offset,
644               lte->resource_entry.size,
645               lte->resource_entry.original_size,
646               lte->resource_entry.offset,
647               flags, lte->resource_entry.flags,
648               (lte->is_pipable ? ", pipable" : ""));
649
650         if ((flags & WIMLIB_READ_RESOURCE_FLAG_RAW_FULL) ||
651             !resource_is_compressed(&lte->resource_entry)) {
652                 return read_raw_file_data(in_fd,
653                                           size,
654                                           cb,
655                                           cb_chunk_size,
656                                           ctx_or_buf,
657                                           offset + lte->resource_entry.offset);
658         } else {
659                 return read_compressed_wim_resource(lte, size, cb,
660                                                     cb_chunk_size,
661                                                     ctx_or_buf, flags, offset);
662         }
663 }
664
665 int
666 read_partial_wim_resource_into_buf(const struct wim_lookup_table_entry *lte,
667                                    size_t size, u64 offset, void *buf)
668 {
669         return read_partial_wim_resource(lte, size, NULL, 0, buf, 0, offset);
670 }
671
672 static int
673 read_wim_resource_prefix(const struct wim_lookup_table_entry *lte,
674                          u64 size,
675                          consume_data_callback_t cb,
676                          u32 cb_chunk_size,
677                          void *ctx_or_buf,
678                          int flags)
679 {
680         return read_partial_wim_resource(lte, size, cb, cb_chunk_size,
681                                          ctx_or_buf, flags, 0);
682 }
683
684 #ifndef __WIN32__
685 /* This function handles reading resource data that is located in an external
686  * file,  such as a file that has been added to the WIM image through execution
687  * of a wimlib_add_command.
688  *
689  * This assumes the file can be accessed using the standard POSIX open(),
690  * read(), and close().  On Windows this will not necessarily be the case (since
691  * the file may need FILE_FLAG_BACKUP_SEMANTICS to be opened, or the file may be
692  * encrypted), so Windows uses its own code for its equivalent case.
693  */
694 static int
695 read_file_on_disk_prefix(const struct wim_lookup_table_entry *lte,
696                          u64 size,
697                          consume_data_callback_t cb,
698                          u32 cb_chunk_size,
699                          void *ctx_or_buf,
700                          int _ignored_flags)
701 {
702         int ret;
703         int raw_fd;
704         struct filedes fd;
705
706         wimlib_assert(size <= wim_resource_size(lte));
707         DEBUG("Reading %"PRIu64" bytes from \"%"TS"\"", size, lte->file_on_disk);
708
709         raw_fd = open(lte->file_on_disk, O_BINARY | O_RDONLY);
710         if (raw_fd < 0) {
711                 ERROR_WITH_ERRNO("Can't open \"%"TS"\"", lte->file_on_disk);
712                 return WIMLIB_ERR_OPEN;
713         }
714         filedes_init(&fd, raw_fd);
715         ret = read_raw_file_data(&fd, size, cb, cb_chunk_size, ctx_or_buf, 0);
716         filedes_close(&fd);
717         return ret;
718 }
719 #endif /* !__WIN32__ */
720
721 /* This function handles the trivial case of reading resource data that is, in
722  * fact, already located in an in-memory buffer.  */
723 static int
724 read_buffer_prefix(const struct wim_lookup_table_entry *lte,
725                    u64 size, consume_data_callback_t cb,
726                    u32 cb_chunk_size,
727                    void *ctx_or_buf, int _ignored_flags)
728 {
729         wimlib_assert(size <= wim_resource_size(lte));
730
731         if (cb) {
732                 /* Feed the data into the callback function in
733                  * appropriately-sized chunks.  */
734                 int ret;
735                 u32 chunk_size;
736
737                 for (u64 offset = 0; offset < size; offset += chunk_size) {
738                         chunk_size = min(cb_chunk_size, size - offset);
739                         ret = cb((const u8*)lte->attached_buffer + offset,
740                                  chunk_size, ctx_or_buf);
741                         if (ret)
742                                 return ret;
743                 }
744         } else {
745                 /* Copy the data directly into the specified buffer.  */
746                 memcpy(ctx_or_buf, lte->attached_buffer, size);
747         }
748         return 0;
749 }
750
751 typedef int (*read_resource_prefix_handler_t)(const struct wim_lookup_table_entry *lte,
752                                               u64 size,
753                                               consume_data_callback_t cb,
754                                               u32 cb_chunk_size,
755                                               void *ctx_or_buf,
756                                               int flags);
757
758 /*
759  * read_resource_prefix()-
760  *
761  * Reads the first @size bytes from a generic "resource", which may be located
762  * in any one of several locations, such as in a WIM file (compressed or
763  * uncompressed), in an external file, or directly in an in-memory buffer.
764  *
765  * This function feeds the data either to a callback function (@cb != NULL,
766  * passing it @ctx_or_buf), or write it directly into a buffer (@cb == NULL,
767  * @ctx_or_buf specifies the buffer, which must have room for at least @size
768  * bytes).
769  *
770  * When (@cb != NULL), @cb_chunk_size specifies the maximum size of data chunks
771  * to feed the callback function.  @cb_chunk_size must be positive, and if the
772  * resource is in a WIM file, must be a power of 2.  All chunks, except possibly
773  * the last one, will be this size.  If (@cb == NULL), @cb_chunk_size is
774  * ignored.
775  *
776  * If the resource is located in a WIM file, @flags can be set as documented in
777  * read_partial_wim_resource().  Otherwise @flags are ignored.
778  *
779  * Returns 0 on success; nonzero on error.  A nonzero value will be returned if
780  * the resource data cannot be successfully read (for a number of different
781  * reasons, depending on the resource location), or if a callback function was
782  * specified and it returned nonzero.
783  */
784 int
785 read_resource_prefix(const struct wim_lookup_table_entry *lte,
786                      u64 size, consume_data_callback_t cb, u32 cb_chunk_size,
787                      void *ctx_or_buf, int flags)
788 {
789         /* This function merely verifies several preconditions, then passes
790          * control to an appropriate function for understanding each possible
791          * resource location.  */
792         static const read_resource_prefix_handler_t handlers[] = {
793                 [RESOURCE_IN_WIM]             = read_wim_resource_prefix,
794         #ifdef __WIN32__
795                 [RESOURCE_IN_FILE_ON_DISK]    = read_win32_file_prefix,
796         #else
797                 [RESOURCE_IN_FILE_ON_DISK]    = read_file_on_disk_prefix,
798         #endif
799                 [RESOURCE_IN_ATTACHED_BUFFER] = read_buffer_prefix,
800         #ifdef WITH_FUSE
801                 [RESOURCE_IN_STAGING_FILE]    = read_file_on_disk_prefix,
802         #endif
803         #ifdef WITH_NTFS_3G
804                 [RESOURCE_IN_NTFS_VOLUME]     = read_ntfs_file_prefix,
805         #endif
806         #ifdef __WIN32__
807                 [RESOURCE_WIN32_ENCRYPTED]    = read_win32_encrypted_file_prefix,
808         #endif
809         };
810         wimlib_assert(lte->resource_location < ARRAY_LEN(handlers)
811                       && handlers[lte->resource_location] != NULL);
812         wimlib_assert(cb == NULL || cb_chunk_size > 0);
813         return handlers[lte->resource_location](lte, size, cb, cb_chunk_size,
814                                                 ctx_or_buf, flags);
815 }
816
817 /* Read the full uncompressed data of the specified resource into the specified
818  * buffer, which must have space for at least lte->resource_entry.original_size
819  * bytes.  */
820 int
821 read_full_resource_into_buf(const struct wim_lookup_table_entry *lte,
822                             void *buf)
823 {
824         return read_resource_prefix(lte, wim_resource_size(lte),
825                                     NULL, 0, buf, 0);
826 }
827
828 /* Read the full uncompressed data of the specified resource.  A buffer
829  * sufficient to hold the data is allocated and returned in @buf_ret.  */
830 int
831 read_full_resource_into_alloc_buf(const struct wim_lookup_table_entry *lte,
832                                   void **buf_ret)
833 {
834         int ret;
835         void *buf;
836
837         if ((size_t)lte->resource_entry.original_size !=
838             lte->resource_entry.original_size)
839         {
840                 ERROR("Can't read %"PRIu64" byte resource into "
841                       "memory", lte->resource_entry.original_size);
842                 return WIMLIB_ERR_NOMEM;
843         }
844
845         buf = MALLOC(lte->resource_entry.original_size);
846         if (buf == NULL)
847                 return WIMLIB_ERR_NOMEM;
848
849         ret = read_full_resource_into_buf(lte, buf);
850         if (ret) {
851                 FREE(buf);
852                 return ret;
853         }
854
855         *buf_ret = buf;
856         return 0;
857 }
858
859 /* Retrieve the full uncompressed data of the specified WIM resource, provided
860  * as a raw `struct resource_entry'.  */
861 int
862 res_entry_to_data(const struct resource_entry *res_entry,
863                   WIMStruct *wim, void **buf_ret)
864 {
865         int ret;
866         struct wim_lookup_table_entry *lte;
867
868         lte = new_lookup_table_entry();
869         if (lte == NULL)
870                 return WIMLIB_ERR_NOMEM;
871
872         copy_resource_entry(&lte->resource_entry, res_entry);
873         lte->unhashed = 1;
874         lte->part_number = wim->hdr.part_number;
875         lte_init_wim(lte, wim);
876
877         ret = read_full_resource_into_alloc_buf(lte, buf_ret);
878         free_lookup_table_entry(lte);
879         return ret;
880 }
881
882 struct extract_ctx {
883         SHA_CTX sha_ctx;
884         consume_data_callback_t extract_chunk;
885         void *extract_chunk_arg;
886 };
887
888 static int
889 extract_chunk_sha1_wrapper(const void *chunk, size_t chunk_size,
890                            void *_ctx)
891 {
892         struct extract_ctx *ctx = _ctx;
893
894         sha1_update(&ctx->sha_ctx, chunk, chunk_size);
895         return ctx->extract_chunk(chunk, chunk_size, ctx->extract_chunk_arg);
896 }
897
898 /* Extracts the first @size bytes of a resource to somewhere.  In the process,
899  * the SHA1 message digest of the uncompressed resource is checked if the full
900  * resource is being extracted.
901  *
902  * @extract_chunk is a function that will be called to extract each chunk of the
903  * resource.  */
904 int
905 extract_wim_resource(const struct wim_lookup_table_entry *lte,
906                      u64 size,
907                      consume_data_callback_t extract_chunk,
908                      void *extract_chunk_arg)
909 {
910         int ret;
911         if (size == wim_resource_size(lte)) {
912                 /* Do SHA1 */
913                 struct extract_ctx ctx;
914                 ctx.extract_chunk = extract_chunk;
915                 ctx.extract_chunk_arg = extract_chunk_arg;
916                 sha1_init(&ctx.sha_ctx);
917                 ret = read_resource_prefix(lte, size,
918                                            extract_chunk_sha1_wrapper,
919                                            wim_resource_chunk_size(lte),
920                                            &ctx, 0);
921                 if (ret == 0) {
922                         u8 hash[SHA1_HASH_SIZE];
923                         sha1_final(hash, &ctx.sha_ctx);
924                         if (!hashes_equal(hash, lte->hash)) {
925                                 if (wimlib_print_errors) {
926                                         ERROR("Invalid SHA1 message digest "
927                                               "on the following WIM resource:");
928                                         print_lookup_table_entry(lte, stderr);
929                                         if (lte->resource_location == RESOURCE_IN_WIM)
930                                                 ERROR("The WIM file appears to be corrupt!");
931                                 }
932                                 ret = WIMLIB_ERR_INVALID_RESOURCE_HASH;
933                         }
934                 }
935         } else {
936                 /* Don't do SHA1 */
937                 ret = read_resource_prefix(lte, size, extract_chunk,
938                                            wim_resource_chunk_size(lte),
939                                            extract_chunk_arg, 0);
940         }
941         return ret;
942 }
943
944 static int
945 extract_wim_chunk_to_fd(const void *buf, size_t len, void *_fd_p)
946 {
947         struct filedes *fd = _fd_p;
948         int ret = full_write(fd, buf, len);
949         if (ret)
950                 ERROR_WITH_ERRNO("Error writing to file descriptor");
951         return ret;
952 }
953
954 /* Extract the first @size bytes of the specified resource to the specified file
955  * descriptor.  If @size is the full size of the resource, its SHA1 message
956  * digest is also checked.  */
957 int
958 extract_wim_resource_to_fd(const struct wim_lookup_table_entry *lte,
959                            struct filedes *fd, u64 size)
960 {
961         return extract_wim_resource(lte, size, extract_wim_chunk_to_fd, fd);
962 }
963
964
965 static int
966 sha1_chunk(const void *buf, size_t len, void *ctx)
967 {
968         sha1_update(ctx, buf, len);
969         return 0;
970 }
971
972 /* Calculate the SHA1 message digest of a resource, storing it in @lte->hash.  */
973 int
974 sha1_resource(struct wim_lookup_table_entry *lte)
975 {
976         int ret;
977         SHA_CTX sha_ctx;
978
979         sha1_init(&sha_ctx);
980         ret = read_resource_prefix(lte, wim_resource_size(lte),
981                                    sha1_chunk, wim_resource_chunk_size(lte),
982                                    &sha_ctx, 0);
983         if (ret == 0)
984                 sha1_final(lte->hash, &sha_ctx);
985
986         return ret;
987 }
988
989 /* Translates a WIM resource entry from the on-disk format into an in-memory
990  * format.  */
991 void
992 get_resource_entry(const struct resource_entry_disk *disk_entry,
993                    struct resource_entry *entry)
994 {
995         /* Note: disk_entry may not be 8 byte aligned--- in that case, the
996          * offset and original_size members will be unaligned.  (This is okay
997          * since `struct resource_entry_disk' is declared as packed.)  */
998
999         /* Read the size and flags into a bitfield portably... */
1000         entry->size = (((u64)disk_entry->size[0] <<  0) |
1001                        ((u64)disk_entry->size[1] <<  8) |
1002                        ((u64)disk_entry->size[2] << 16) |
1003                        ((u64)disk_entry->size[3] << 24) |
1004                        ((u64)disk_entry->size[4] << 32) |
1005                        ((u64)disk_entry->size[5] << 40) |
1006                        ((u64)disk_entry->size[6] << 48));
1007         entry->flags = disk_entry->flags;
1008         entry->offset = le64_to_cpu(disk_entry->offset);
1009         entry->original_size = le64_to_cpu(disk_entry->original_size);
1010
1011         /* offset and original_size are truncated to 62 bits to avoid possible
1012          * overflows, when converting to a signed 64-bit integer (off_t) or when
1013          * adding size or original_size.  This is okay since no one would ever
1014          * actually have a WIM bigger than 4611686018427387903 bytes... */
1015         if (entry->offset & 0xc000000000000000ULL) {
1016                 WARNING("Truncating offset in resource entry");
1017                 entry->offset &= 0x3fffffffffffffffULL;
1018         }
1019         if (entry->original_size & 0xc000000000000000ULL) {
1020                 WARNING("Truncating original_size in resource entry");
1021                 entry->original_size &= 0x3fffffffffffffffULL;
1022         }
1023 }
1024
1025 /* Translates a WIM resource entry from an in-memory format into the on-disk
1026  * format. */
1027 void
1028 put_resource_entry(const struct resource_entry *entry,
1029                    struct resource_entry_disk *disk_entry)
1030 {
1031         /* Note: disk_entry may not be 8 byte aligned--- in that case, the
1032          * offset and original_size members will be unaligned.  (This is okay
1033          * since `struct resource_entry_disk' is declared as packed.)  */
1034         u64 size = entry->size;
1035
1036         disk_entry->size[0] = size >>  0;
1037         disk_entry->size[1] = size >>  8;
1038         disk_entry->size[2] = size >> 16;
1039         disk_entry->size[3] = size >> 24;
1040         disk_entry->size[4] = size >> 32;
1041         disk_entry->size[5] = size >> 40;
1042         disk_entry->size[6] = size >> 48;
1043         disk_entry->flags = entry->flags;
1044         disk_entry->offset = cpu_to_le64(entry->offset);
1045         disk_entry->original_size = cpu_to_le64(entry->original_size);
1046 }