wimlib.net Git - wimlib/blob - 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 #include "wimlib_internal.h"
  26 #include "dentry.h"
  27 #include "lookup_table.h"
  28 #include "buffer_io.h"
  29 #include "lzx.h"
  30 #include "xpress.h"
  31 #include "sha1.h"
  32
  33 #ifdef __WIN32__
  34 #  include "win32.h"
  35 #endif
  36
  37 #include <errno.h>
  38 #include <stdarg.h>
  39 #include <stdlib.h>
  40 #include <unistd.h>
  41
  42 #ifdef WITH_NTFS_3G
  43 #  include <time.h>
  44 #  include <ntfs-3g/attrib.h>
  45 #  include <ntfs-3g/inode.h>
  46 #  include <ntfs-3g/dir.h>
  47 #endif
  48
  49 /*
  50  * Reads all or part of a compressed resource into an in-memory buffer.
  51  *
  52  * @fp:                 The FILE* for the WIM file.
  53  * @resource_compressed_size:    The compressed size of the resource.
  54  * @resource_uncompressed_size:  The uncompressed size of the resource.
  55  * @resource_offset:             The offset of the start of the resource from
  56  *                                      the start of the stream @fp.
  57  * @resource_ctype:     The compression type of the resource.
  58  * @len:                The number of bytes of uncompressed data to read from
  59  *                              the resource.
  60  * @offset:             The offset of the bytes to read within the uncompressed
  61  *                              resource.
  62  * @contents_len:       An array into which the uncompressed data is written.
  63  *                              It must be at least @len bytes long.
  64  *
  65  * Returns zero on success, nonzero on failure.
  66  */
  67 static int
  68 read_compressed_resource(FILE *fp, u64 resource_compressed_size,
  69                          u64 resource_uncompressed_size,
  70                          u64 resource_offset, int resource_ctype,
  71                          u64 len, u64 offset, void *contents_ret)
  72 {
  73
  74         DEBUG2("comp size = %"PRIu64", uncomp size = %"PRIu64", "
  75                "res offset = %"PRIu64"",
  76                resource_compressed_size,
  77                resource_uncompressed_size,
  78                resource_offset);
  79         DEBUG2("resource_ctype = %s, len = %"PRIu64", offset = %"PRIu64"",
  80                wimlib_get_compression_type_string(resource_ctype), len, offset);
  81         /* Trivial case */
  82         if (len == 0)
  83                 return 0;
  84
  85         int (*decompress)(const void *, unsigned, void *, unsigned);
  86         /* Set the appropriate decompress function. */
  87         if (resource_ctype == WIMLIB_COMPRESSION_TYPE_LZX)
  88                 decompress = lzx_decompress;
  89         else
  90                 decompress = xpress_decompress;
  91
  92         /* The structure of a compressed resource consists of a table of chunk
  93          * offsets followed by the chunks themselves.  Each chunk consists of
  94          * compressed data, and there is one chunk for each WIM_CHUNK_SIZE =
  95          * 32768 bytes of the uncompressed file, with the last chunk having any
  96          * remaining bytes.
  97          *
  98          * The chunk offsets are measured relative to the end of the chunk
  99          * table.  The first chunk is omitted from the table in the WIM file
 100          * because its offset is implicitly given by the fact that it directly
 101          * follows the chunk table and therefore must have an offset of 0.
 102          */
 103
 104         /* Calculate how many chunks the resource conists of in its entirety. */
 105         u64 num_chunks = (resource_uncompressed_size + WIM_CHUNK_SIZE - 1) /
 106                                                                 WIM_CHUNK_SIZE;
 107         /* As mentioned, the first chunk has no entry in the chunk table. */
 108         u64 num_chunk_entries = num_chunks - 1;
 109
 110
 111         /* The index of the chunk that the read starts at. */
 112         u64 start_chunk = offset / WIM_CHUNK_SIZE;
 113         /* The byte offset at which the read starts, within the start chunk. */
 114         u64 start_chunk_offset = offset % WIM_CHUNK_SIZE;
 115
 116         /* The index of the chunk that contains the last byte of the read. */
 117         u64 end_chunk   = (offset + len - 1) / WIM_CHUNK_SIZE;
 118         /* The byte offset of the last byte of the read, within the end chunk */
 119         u64 end_chunk_offset = (offset + len - 1) % WIM_CHUNK_SIZE;
 120
 121         /* Number of chunks that are actually needed to read the requested part
 122          * of the file. */
 123         u64 num_needed_chunks = end_chunk - start_chunk + 1;
 124
 125         /* If the end chunk is not the last chunk, an extra chunk entry is
 126          * needed because we need to know the offset of the chunk after the last
 127          * chunk read to figure out the size of the last read chunk. */
 128         if (end_chunk != num_chunks - 1)
 129                 num_needed_chunks++;
 130
 131         /* Declare the chunk table.  It will only contain offsets for the chunks
 132          * that are actually needed for this read. */
 133         u64 chunk_offsets[num_needed_chunks];
 134
 135         /* Set the implicit offset of the first chunk if it is included in the
 136          * needed chunks.
 137          *
 138          * Note: M$'s documentation includes a picture that shows the first
 139          * chunk starting right after the chunk entry table, labeled as offset
 140          * 0x10.  However, in the actual file format, the offset is measured
 141          * from the end of the chunk entry table, so the first chunk has an
 142          * offset of 0. */
 143         if (start_chunk == 0)
 144                 chunk_offsets[0] = 0;
 145
 146         /* According to M$'s documentation, if the uncompressed size of
 147          * the file is greater than 4 GB, the chunk entries are 8-byte
 148          * integers.  Otherwise, they are 4-byte integers. */
 149         u64 chunk_entry_size = (resource_uncompressed_size >= (u64)1 << 32) ?
 150                                                                         8 : 4;
 151
 152         /* Size of the full chunk table in the WIM file. */
 153         u64 chunk_table_size = chunk_entry_size * num_chunk_entries;
 154
 155         /* Read the needed chunk offsets from the table in the WIM file. */
 156
 157         /* Index, in the WIM file, of the first needed entry in the
 158          * chunk table. */
 159         u64 start_table_idx = (start_chunk == 0) ? 0 : start_chunk - 1;
 160
 161         /* Number of entries we need to actually read from the chunk
 162          * table (excludes the implicit first chunk). */
 163         u64 num_needed_chunk_entries = (start_chunk == 0) ?
 164                                 num_needed_chunks - 1 : num_needed_chunks;
 165
 166         /* Skip over unneeded chunk table entries. */
 167         u64 file_offset_of_needed_chunk_entries = resource_offset +
 168                                 start_table_idx * chunk_entry_size;
 169         if (fseeko(fp, file_offset_of_needed_chunk_entries, SEEK_SET) != 0) {
 170                 ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" to read "
 171                                  "chunk table of compressed resource",
 172                                  file_offset_of_needed_chunk_entries);
 173                 return WIMLIB_ERR_READ;
 174         }
 175
 176         /* Number of bytes we need to read from the chunk table. */
 177         size_t size = num_needed_chunk_entries * chunk_entry_size;
 178
 179         u8 chunk_tab_buf[size];
 180
 181         if (fread(chunk_tab_buf, 1, size, fp) != size)
 182                 goto err;
 183
 184         /* Now fill in chunk_offsets from the entries we have read in
 185          * chunk_tab_buf. */
 186
 187         u64 *chunk_tab_p = chunk_offsets;
 188         if (start_chunk == 0)
 189                 chunk_tab_p++;
 190
 191         if (chunk_entry_size == 4) {
 192                 u32 *entries = (u32*)chunk_tab_buf;
 193                 while (num_needed_chunk_entries--)
 194                         *chunk_tab_p++ = le32_to_cpu(*entries++);
 195         } else {
 196                 u64 *entries = (u64*)chunk_tab_buf;
 197                 while (num_needed_chunk_entries--)
 198                         *chunk_tab_p++ = le64_to_cpu(*entries++);
 199         }
 200
 201         /* Done with the chunk table now.  We must now seek to the first chunk
 202          * that is needed for the read. */
 203
 204         u64 file_offset_of_first_needed_chunk = resource_offset +
 205                                 chunk_table_size + chunk_offsets[0];
 206         if (fseeko(fp, file_offset_of_first_needed_chunk, SEEK_SET) != 0) {
 207                 ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" to read "
 208                                  "first chunk of compressed resource",
 209                                  file_offset_of_first_needed_chunk);
 210                 return WIMLIB_ERR_READ;
 211         }
 212
 213         /* Pointer to current position in the output buffer for uncompressed
 214          * data. */
 215         u8 *out_p = contents_ret;
 216
 217         /* Buffer for compressed data.  While most compressed chunks will have a
 218          * size much less than WIM_CHUNK_SIZE, WIM_CHUNK_SIZE - 1 is the maximum
 219          * size in the worst-case.  This assumption is valid only if chunks that
 220          * happen to compress to more than the uncompressed size (i.e. a
 221          * sequence of random bytes) are always stored uncompressed. But this seems
 222          * to be the case in M$'s WIM files, even though it is undocumented. */
 223         u8 compressed_buf[WIM_CHUNK_SIZE - 1];
 224
 225
 226         /* Decompress all the chunks. */
 227         for (u64 i = start_chunk; i <= end_chunk; i++) {
 228
 229                 DEBUG2("Chunk %"PRIu64" (start %"PRIu64", end %"PRIu64").",
 230                        i, start_chunk, end_chunk);
 231
 232                 /* Calculate the sizes of the compressed chunk and of the
 233                  * uncompressed chunk. */
 234                 unsigned compressed_chunk_size;
 235                 unsigned uncompressed_chunk_size;
 236                 if (i != num_chunks - 1) {
 237                         /* All the chunks except the last one in the resource
 238                          * expand to WIM_CHUNK_SIZE uncompressed, and the amount
 239                          * of compressed data for the chunk is given by the
 240                          * difference of offsets in the chunk offset table. */
 241                         compressed_chunk_size = chunk_offsets[i + 1 - start_chunk] -
 242                                                 chunk_offsets[i - start_chunk];
 243                         uncompressed_chunk_size = WIM_CHUNK_SIZE;
 244                 } else {
 245                         /* The last compressed chunk consists of the remaining
 246                          * bytes in the file resource, and the last uncompressed
 247                          * chunk has size equal to however many bytes are left-
 248                          * that is, the remainder of the uncompressed size when
 249                          * divided by WIM_CHUNK_SIZE.
 250                          *
 251                          * Note that the resource_compressed_size includes the
 252                          * chunk table, so the size of it must be subtracted. */
 253                         compressed_chunk_size = resource_compressed_size -
 254                                                 chunk_table_size -
 255                                                 chunk_offsets[i - start_chunk];
 256
 257                         uncompressed_chunk_size = resource_uncompressed_size %
 258                                                                 WIM_CHUNK_SIZE;
 259
 260                         /* If the remainder is 0, the last chunk actually
 261                          * uncompresses to a full WIM_CHUNK_SIZE bytes. */
 262                         if (uncompressed_chunk_size == 0)
 263                                 uncompressed_chunk_size = WIM_CHUNK_SIZE;
 264                 }
 265
 266                 DEBUG2("compressed_chunk_size = %u, "
 267                        "uncompressed_chunk_size = %u",
 268                        compressed_chunk_size, uncompressed_chunk_size);
 269
 270
 271                 /* Figure out how much of this chunk we actually need to read */
 272                 u64 start_offset;
 273                 if (i == start_chunk)
 274                         start_offset = start_chunk_offset;
 275                 else
 276                         start_offset = 0;
 277                 u64 end_offset;
 278                 if (i == end_chunk)
 279                         end_offset = end_chunk_offset;
 280                 else
 281                         end_offset = WIM_CHUNK_SIZE - 1;
 282
 283                 u64 partial_chunk_size = end_offset + 1 - start_offset;
 284                 bool is_partial_chunk = (partial_chunk_size !=
 285                                                 uncompressed_chunk_size);
 286
 287                 DEBUG2("start_offset = %"PRIu64", end_offset = %"PRIu64"",
 288                        start_offset, end_offset);
 289                 DEBUG2("partial_chunk_size = %"PRIu64"", partial_chunk_size);
 290
 291                 /* This is undocumented, but chunks can be uncompressed.  This
 292                  * appears to always be the case when the compressed chunk size
 293                  * is equal to the uncompressed chunk size. */
 294                 if (compressed_chunk_size == uncompressed_chunk_size) {
 295                         /* Probably an uncompressed chunk */
 296
 297                         if (start_offset != 0) {
 298                                 if (fseeko(fp, start_offset, SEEK_CUR) != 0) {
 299                                         ERROR_WITH_ERRNO("Uncompressed partial "
 300                                                          "chunk fseek() error");
 301                                         return WIMLIB_ERR_READ;
 302                                 }
 303                         }
 304                         if (fread(out_p, 1, partial_chunk_size, fp) !=
 305                                         partial_chunk_size)
 306                                 goto err;
 307                 } else {
 308                         /* Compressed chunk */
 309                         int ret;
 310
 311                         /* Read the compressed data into compressed_buf. */
 312                         if (fread(compressed_buf, 1, compressed_chunk_size,
 313                                                 fp) != compressed_chunk_size)
 314                                 goto err;
 315
 316                         /* For partial chunks we must buffer the uncompressed
 317                          * data because we don't need all of it. */
 318                         if (is_partial_chunk) {
 319                                 u8 uncompressed_buf[uncompressed_chunk_size];
 320
 321                                 ret = decompress(compressed_buf,
 322                                                 compressed_chunk_size,
 323                                                 uncompressed_buf,
 324                                                 uncompressed_chunk_size);
 325                                 if (ret != 0)
 326                                         return WIMLIB_ERR_DECOMPRESSION;
 327                                 memcpy(out_p, uncompressed_buf + start_offset,
 328                                                 partial_chunk_size);
 329                         } else {
 330                                 ret = decompress(compressed_buf,
 331                                                 compressed_chunk_size,
 332                                                 out_p,
 333                                                 uncompressed_chunk_size);
 334                                 if (ret != 0)
 335                                         return WIMLIB_ERR_DECOMPRESSION;
 336                         }
 337                 }
 338
 339                 /* Advance the pointer into the uncompressed output data by the
 340                  * number of uncompressed bytes that were written.  */
 341                 out_p += partial_chunk_size;
 342         }
 343
 344         return 0;
 345
 346 err:
 347         if (feof(fp))
 348                 ERROR("Unexpected EOF in compressed file resource");
 349         else
 350                 ERROR_WITH_ERRNO("Error reading compressed file resource");
 351         return WIMLIB_ERR_READ;
 352 }
 353
 354 /*
 355  * Reads uncompressed data from an open file stream.
 356  */
 357 int
 358 read_uncompressed_resource(FILE *fp, u64 offset, u64 len, void *contents_ret)
 359 {
 360         if (fseeko(fp, offset, SEEK_SET) != 0) {
 361                 ERROR("Failed to seek to byte %"PRIu64" of input file "
 362                       "to read uncompressed resource (len = %"PRIu64")",
 363                       offset, len);
 364                 return WIMLIB_ERR_READ;
 365         }
 366         if (fread(contents_ret, 1, len, fp) != len) {
 367                 if (feof(fp)) {
 368                         ERROR("Unexpected EOF in uncompressed file resource");
 369                 } else {
 370                         ERROR("Failed to read %"PRIu64" bytes from "
 371                               "uncompressed resource at offset %"PRIu64,
 372                               len, offset);
 373                 }
 374                 return WIMLIB_ERR_READ;
 375         }
 376         return 0;
 377 }
 378
 379 /* Reads the contents of a struct resource_entry, as represented in the on-disk
 380  * format, from the memory pointed to by @p, and fills in the fields of @entry.
 381  * A pointer to the byte after the memory read at @p is returned. */
 382 const u8 *
 383 get_resource_entry(const u8 *p, struct resource_entry *entry)
 384 {
 385         u64 size;
 386         u8 flags;
 387
 388         p = get_u56(p, &size);
 389         p = get_u8(p, &flags);
 390         entry->size = size;
 391         entry->flags = flags;
 392
 393         /* offset and original_size are truncated to 62 bits to avoid possible
 394          * overflows, when converting to a signed 64-bit integer (off_t) or when
 395          * adding size or original_size.  This is okay since no one would ever
 396          * actually have a WIM bigger than 4611686018427387903 bytes... */
 397         p = get_u64(p, &entry->offset);
 398         if (entry->offset & 0xc000000000000000ULL) {
 399                 WARNING("Truncating offset in resource entry");
 400                 entry->offset &= 0x3fffffffffffffffULL;
 401         }
 402         p = get_u64(p, &entry->original_size);
 403         if (entry->original_size & 0xc000000000000000ULL) {
 404                 WARNING("Truncating original_size in resource entry");
 405                 entry->original_size &= 0x3fffffffffffffffULL;
 406         }
 407         return p;
 408 }
 409
 410 /* Copies the struct resource_entry @entry to the memory pointed to by @p in the
 411  * on-disk format.  A pointer to the byte after the memory written at @p is
 412  * returned. */
 413 u8 *
 414 put_resource_entry(u8 *p, const struct resource_entry *entry)
 415 {
 416         p = put_u56(p, entry->size);
 417         p = put_u8(p, entry->flags);
 418         p = put_u64(p, entry->offset);
 419         p = put_u64(p, entry->original_size);
 420         return p;
 421 }
 422
 423 #ifdef WITH_FUSE
 424 static FILE *
 425 wim_get_fp(WIMStruct *w)
 426 {
 427         pthread_mutex_lock(&w->fp_tab_mutex);
 428         FILE *fp;
 429
 430         wimlib_assert(w->filename != NULL);
 431
 432         for (size_t i = 0; i < w->num_allocated_fps; i++) {
 433                 if (w->fp_tab[i]) {
 434                         fp = w->fp_tab[i];
 435                         w->fp_tab[i] = NULL;
 436                         goto out;
 437                 }
 438         }
 439         DEBUG("Opening extra file descriptor to `%s'", w->filename);
 440         fp = fopen(w->filename, "rb");
 441         if (!fp)
 442                 ERROR_WITH_ERRNO("Failed to open `%s'", w->filename);
 443 out:
 444         pthread_mutex_unlock(&w->fp_tab_mutex);
 445         return fp;
 446 }
 447
 448 static int
 449 wim_release_fp(WIMStruct *w, FILE *fp)
 450 {
 451         int ret = 0;
 452         FILE **fp_tab;
 453
 454         pthread_mutex_lock(&w->fp_tab_mutex);
 455
 456         for (size_t i = 0; i < w->num_allocated_fps; i++) {
 457                 if (w->fp_tab[i] == NULL) {
 458                         w->fp_tab[i] = fp;
 459                         goto out;
 460                 }
 461         }
 462
 463         fp_tab = REALLOC(w->fp_tab, sizeof(FILE*) * (w->num_allocated_fps + 4));
 464         if (!fp_tab) {
 465                 ret = WIMLIB_ERR_NOMEM;
 466                 goto out;
 467         }
 468         w->fp_tab = fp_tab;
 469         memset(&w->fp_tab[w->num_allocated_fps], 0, 4 * sizeof(FILE*));
 470         w->fp_tab[w->num_allocated_fps] = fp;
 471         w->num_allocated_fps += 4;
 472 out:
 473         pthread_mutex_unlock(&w->fp_tab_mutex);
 474         return ret;
 475 }
 476 #endif /* !WITH_FUSE */
 477
 478 /*
 479  * Reads some data from the resource corresponding to a WIM lookup table entry.
 480  *
 481  * @lte:        The WIM lookup table entry for the resource.
 482  * @buf:        Buffer into which to write the data.
 483  * @size:       Number of bytes to read.
 484  * @offset:     Offset at which to start reading the resource.
 485  *
 486  * Returns zero on success, nonzero on failure.
 487  */
 488 int
 489 read_wim_resource(const struct wim_lookup_table_entry *lte, void *buf,
 490                   size_t size, u64 offset, int flags)
 491 {
 492         int ctype;
 493         int ret = 0;
 494         FILE *fp;
 495
 496         /* We shouldn't be allowing read over-runs in any part of the library.
 497          * */
 498         if (flags & WIMLIB_RESOURCE_FLAG_RAW)
 499                 wimlib_assert(offset + size <= lte->resource_entry.size);
 500         else
 501                 wimlib_assert(offset + size <= lte->resource_entry.original_size);
 502
 503         switch (lte->resource_location) {
 504         case RESOURCE_IN_WIM:
 505                 /* The resource is in a WIM file, and its WIMStruct is given by
 506                  * the lte->wim member.  The resource may be either compressed
 507                  * or uncompressed. */
 508                 wimlib_assert(lte->wim != NULL);
 509
 510                 #ifdef WITH_FUSE
 511                 if (flags & WIMLIB_RESOURCE_FLAG_MULTITHREADED) {
 512                         fp = wim_get_fp(lte->wim);
 513                         if (!fp)
 514                                 return WIMLIB_ERR_OPEN;
 515                 } else
 516                 #endif
 517                 {
 518                         wimlib_assert(!(flags & WIMLIB_RESOURCE_FLAG_MULTITHREADED));
 519                         wimlib_assert(lte->wim->fp != NULL);
 520                         fp = lte->wim->fp;
 521                 }
 522
 523                 ctype = wim_resource_compression_type(lte);
 524
 525                 wimlib_assert(ctype != WIMLIB_COMPRESSION_TYPE_NONE ||
 526                               (lte->resource_entry.original_size ==
 527                                lte->resource_entry.size));
 528
 529                 if ((flags & WIMLIB_RESOURCE_FLAG_RAW)
 530                     || ctype == WIMLIB_COMPRESSION_TYPE_NONE)
 531                         ret = read_uncompressed_resource(fp,
 532                                                          lte->resource_entry.offset + offset,
 533                                                          size, buf);
 534                 else
 535                         ret = read_compressed_resource(fp,
 536                                                        lte->resource_entry.size,
 537                                                        lte->resource_entry.original_size,
 538                                                        lte->resource_entry.offset,
 539                                                        ctype, size, offset, buf);
 540         #ifdef WITH_FUSE
 541                 if (flags & WIMLIB_RESOURCE_FLAG_MULTITHREADED) {
 542                         int ret2 = wim_release_fp(lte->wim, fp);
 543                         if (ret == 0)
 544                                 ret = ret2;
 545                 }
 546         #endif
 547                 break;
 548         case RESOURCE_IN_STAGING_FILE:
 549         case RESOURCE_IN_FILE_ON_DISK:
 550                 /* The resource is in some file on the external filesystem and
 551                  * needs to be read uncompressed */
 552                 wimlib_assert(lte->file_on_disk != NULL);
 553                 BUILD_BUG_ON(&lte->file_on_disk != &lte->staging_file_name);
 554                 /* Use existing file pointer if available; otherwise open one
 555                  * temporarily */
 556                 if (lte->file_on_disk_fp) {
 557                         fp = lte->file_on_disk_fp;
 558                 } else {
 559                         fp = fopen(lte->file_on_disk, "rb");
 560                         if (!fp) {
 561                                 ERROR_WITH_ERRNO("Failed to open the file "
 562                                                  "`%s'", lte->file_on_disk);
 563                                 ret = WIMLIB_ERR_OPEN;
 564                                 break;
 565                         }
 566                 }
 567                 ret = read_uncompressed_resource(fp, offset, size, buf);
 568                 if (fp != lte->file_on_disk_fp)
 569                         fclose(fp);
 570                 break;
 571 #ifdef __WIN32__
 572         case RESOURCE_WIN32:
 573                 wimlib_assert(lte->file_on_disk_fp != NULL);
 574                 ret = win32_read_file(lte->file_on_disk, lte->file_on_disk_fp,
 575                                       offset, size, buf);
 576                 break;
 577 #endif
 578         case RESOURCE_IN_ATTACHED_BUFFER:
 579                 /* The resource is directly attached uncompressed in an
 580                  * in-memory buffer. */
 581                 wimlib_assert(lte->attached_buffer != NULL);
 582                 memcpy(buf, lte->attached_buffer + offset, size);
 583                 break;
 584 #ifdef WITH_NTFS_3G
 585         case RESOURCE_IN_NTFS_VOLUME:
 586                 wimlib_assert(lte->ntfs_loc != NULL);
 587                 wimlib_assert(lte->attr != NULL);
 588                 if (lte->ntfs_loc->is_reparse_point)
 589                         offset += 8;
 590                 if (ntfs_attr_pread(lte->attr, offset, size, buf) != size) {
 591                         ERROR_WITH_ERRNO("Error reading NTFS attribute "
 592                                          "at `%s'",
 593                                          lte->ntfs_loc->path);
 594                         ret = WIMLIB_ERR_NTFS_3G;
 595                 }
 596                 break;
 597 #endif
 598         default:
 599                 wimlib_assert(0);
 600                 ret = -1;
 601                 break;
 602         }
 603         return ret;
 604 }
 605
 606 /*
 607  * Reads all the data from the resource corresponding to a WIM lookup table
 608  * entry.
 609  *
 610  * @lte:        The WIM lookup table entry for the resource.
 611  * @buf:        Buffer into which to write the data.  It must be at least
 612  *              wim_resource_size(lte) bytes long.
 613  *
 614  * Returns 0 on success; nonzero on failure.
 615  */
 616 int
 617 read_full_wim_resource(const struct wim_lookup_table_entry *lte,
 618                        void *buf, int flags)
 619 {
 620         return read_wim_resource(lte, buf, wim_resource_size(lte), 0, flags);
 621 }
 622
 623 /* Extracts the first @size bytes of a WIM resource to somewhere.  In the
 624  * process, the SHA1 message digest of the resource is checked if the full
 625  * resource is being extracted.
 626  *
 627  * @extract_chunk is a function that is called to extract each chunk of the
 628  * resource. */
 629 int
 630 extract_wim_resource(const struct wim_lookup_table_entry *lte,
 631                      u64 size,
 632                      extract_chunk_func_t extract_chunk,
 633                      void *extract_chunk_arg)
 634 {
 635         u64 bytes_remaining = size;
 636         u8 buf[min(WIM_CHUNK_SIZE, bytes_remaining)];
 637         u64 offset = 0;
 638         int ret = 0;
 639         u8 hash[SHA1_HASH_SIZE];
 640         bool check_hash = (size == wim_resource_size(lte));
 641         SHA_CTX ctx;
 642
 643         if (check_hash)
 644                 sha1_init(&ctx);
 645
 646         while (bytes_remaining) {
 647                 u64 to_read = min(bytes_remaining, sizeof(buf));
 648                 ret = read_wim_resource(lte, buf, to_read, offset, 0);
 649                 if (ret != 0)
 650                         return ret;
 651                 if (check_hash)
 652                         sha1_update(&ctx, buf, to_read);
 653                 ret = extract_chunk(buf, to_read, offset, extract_chunk_arg);
 654                 if (ret != 0) {
 655                         ERROR_WITH_ERRNO("Error extracting WIM resource");
 656                         return ret;
 657                 }
 658                 bytes_remaining -= to_read;
 659                 offset += to_read;
 660         }
 661         if (check_hash) {
 662                 sha1_final(hash, &ctx);
 663                 if (!hashes_equal(hash, lte->hash)) {
 664                 #ifdef ENABLE_ERROR_MESSAGES
 665                         ERROR("Invalid checksum on the following WIM resource:");
 666                         print_lookup_table_entry(lte, stderr);
 667                 #endif
 668                         return WIMLIB_ERR_INVALID_RESOURCE_HASH;
 669                 }
 670         }
 671         return 0;
 672 }
 673
 674 /* Write @n bytes from @buf to the file descriptor @fd, retrying on internupt
 675  * and on short writes.
 676  *
 677  * Returns short count and set errno on failure. */
 678 static ssize_t
 679 full_write(int fd, const void *buf, size_t n)
 680 {
 681         const void *p = buf;
 682         ssize_t ret;
 683         ssize_t total = 0;
 684
 685         while (total != n) {
 686                 ret = write(fd, p, n);
 687                 if (ret < 0) {
 688                         if (errno == EINTR)
 689                                 continue;
 690                         else
 691                                 break;
 692                 }
 693                 total += ret;
 694                 p += ret;
 695         }
 696         return total;
 697 }
 698
 699 int
 700 extract_wim_chunk_to_fd(const void *buf, size_t len, u64 offset, void *arg)
 701 {
 702         int fd = *(int*)arg;
 703         ssize_t ret = full_write(fd, buf, len);
 704         if (ret < len) {
 705                 ERROR_WITH_ERRNO("Error writing to file descriptor");
 706                 return WIMLIB_ERR_WRITE;
 707         } else {
 708                 return 0;
 709         }
 710 }
 711
 712 /*
 713  * Copies the file resource specified by the lookup table entry @lte from the
 714  * input WIM to the output WIM that has its FILE * given by
 715  * ((WIMStruct*)wim)->out_fp.
 716  *
 717  * The output_resource_entry, out_refcnt, and part_number fields of @lte are
 718  * updated.
 719  *
 720  * (This function is confusing and should be refactored somehow.)
 721  */
 722 int
 723 copy_resource(struct wim_lookup_table_entry *lte, void *wim)
 724 {
 725         WIMStruct *w = wim;
 726         int ret;
 727
 728         if ((lte->resource_entry.flags & WIM_RESHDR_FLAG_METADATA) &&
 729             !w->write_metadata)
 730                 return 0;
 731
 732         ret = write_wim_resource(lte, w->out_fp,
 733                                  wim_resource_compression_type(lte),
 734                                  &lte->output_resource_entry, 0);
 735         if (ret != 0)
 736                 return ret;
 737         lte->out_refcnt = lte->refcnt;
 738         lte->part_number = w->hdr.part_number;
 739         return 0;
 740 }