*/
/*
- * Copyright (C) 2010 Carl Thijssen
* Copyright (C) 2012 Eric Biggers
*
* This file is part of wimlib, a library for working with WIM files.
*
* wimlib is free software; you can redistribute it and/or modify it under the
- * terms of the GNU Lesser General Public License as published by the Free
- * Software Foundation; either version 2.1 of the License, or (at your option)
- * any later version.
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3 of the License, or (at your option) any later
+ * version.
*
* wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
- * details.
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
- * You should have received a copy of the GNU Lesser General Public License
- * along with wimlib; if not, see http://www.gnu.org/licenses/.
+ * You should have received a copy of the GNU General Public License along with
+ * wimlib; if not, see http://www.gnu.org/licenses/.
*/
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdarg.h>
+
+#ifdef WITH_NTFS_3G
+#include <ntfs-3g/attrib.h>
+#include <ntfs-3g/inode.h>
+#include <ntfs-3g/dir.h>
+#endif
+
#include "wimlib_internal.h"
#include "lookup_table.h"
#include "io.h"
#include "xpress.h"
#include "sha1.h"
#include "dentry.h"
-#include "config.h"
#include <unistd.h>
#include <errno.h>
+#ifdef HAVE_ALLOCA_H
#include <alloca.h>
+#endif
/*
return p;
}
-static int __read_wim_resource(const struct lookup_table_entry *lte,
- u8 buf[], size_t size, u64 offset, bool raw)
+/*
+ * Reads some data from the resource corresponding to a WIM lookup table entry.
+ *
+ * @lte: The WIM lookup table entry for the resource.
+ * @buf: Buffer into which to write the data.
+ * @size: Number of bytes to read.
+ * @offset: Offset at which to start reading the resource.
+ * @raw: If %true, compressed data is read literally rather than being
+ * decompressed first.
+ *
+ * Returns zero on success, nonzero on failure.
+ */
+int read_wim_resource(const struct lookup_table_entry *lte, u8 buf[],
+ size_t size, u64 offset, bool raw)
{
- wimlib_assert(offset + size <= wim_resource_size(lte));
+ /* We shouldn't be allowing read over-runs in any part of the library.
+ * */
+ if (raw)
+ wimlib_assert(offset + size <= lte->resource_entry.size);
+ else
+ wimlib_assert(offset + size <= lte->resource_entry.original_size);
+
int ctype;
int ret;
FILE *fp;
switch (lte->resource_location) {
case RESOURCE_IN_WIM:
+ /* The resource is in a WIM file, and its WIMStruct is given by
+ * the lte->wim member. The resource may be either compressed
+ * or uncompressed. */
wimlib_assert(lte->wim);
wimlib_assert(lte->wim->fp);
ctype = wim_resource_compression_type(lte);
- if (ctype == WIM_COMPRESSION_TYPE_NONE &&
- lte->resource_entry.original_size !=
- lte->resource_entry.size) {
- ERROR("WIM resource at offset %"PRIu64", size %"PRIu64
- "has an original size of %"PRIu64", but is "
- "uncompressed",
- lte->resource_entry.offset,
- lte->resource_entry.size,
- lte->resource_entry.original_size);
- return WIMLIB_ERR_INVALID_RESOURCE_SIZE;
- }
+
+ wimlib_assert(ctype != WIM_COMPRESSION_TYPE_NONE ||
+ (lte->resource_entry.original_size ==
+ lte->resource_entry.size));
+
if (raw || ctype == WIM_COMPRESSION_TYPE_NONE)
return read_uncompressed_resource(lte->wim->fp,
- offset, size, buf);
+ lte->resource_entry.offset + offset,
+ size, buf);
else
return read_compressed_resource(lte->wim->fp,
lte->resource_entry.size,
ctype, size, offset, buf);
break;
case RESOURCE_IN_STAGING_FILE:
- wimlib_assert(lte->staging_file_name);
- wimlib_assert(0);
- break;
case RESOURCE_IN_FILE_ON_DISK:
+ /* The resource is in some file on the external filesystem and
+ * needs to be read uncompressed */
wimlib_assert(lte->file_on_disk);
+ wimlib_assert(<e->file_on_disk == <e->staging_file_name);
+ /* Use existing file pointer if available; otherwise open one
+ * temporarily */
if (lte->file_on_disk_fp) {
fp = lte->file_on_disk_fp;
} else {
if (!fp) {
ERROR_WITH_ERRNO("Failed to open the file "
"`%s'", lte->file_on_disk);
+ return WIMLIB_ERR_OPEN;
}
}
- ret = read_uncompressed_resource(lte->file_on_disk_fp,
- offset, size, buf);
+ ret = read_uncompressed_resource(fp, offset, size, buf);
if (fp != lte->file_on_disk_fp)
fclose(fp);
return ret;
break;
case RESOURCE_IN_ATTACHED_BUFFER:
+ /* The resource is directly attached uncompressed in an
+ * in-memory buffer. */
wimlib_assert(lte->attached_buffer);
memcpy(buf, lte->attached_buffer + offset, size);
return 0;
break;
+#ifdef WITH_NTFS_3G
+ case RESOURCE_IN_NTFS_VOLUME:
+ wimlib_assert(lte->ntfs_loc);
+ if (lte->attr) {
+ u64 adjusted_offset;
+ if (lte->ntfs_loc->is_reparse_point)
+ adjusted_offset = offset + 8;
+ else
+ adjusted_offset = offset;
+ if (ntfs_attr_pread(lte->attr, offset, size, buf) == size) {
+ return 0;
+ } else {
+ ERROR_WITH_ERRNO("Error reading NTFS attribute "
+ "at `%s'",
+ lte->ntfs_loc->path_utf8);
+ return WIMLIB_ERR_NTFS_3G;
+ }
+ } else {
+ wimlib_assert(0);
+ }
+ break;
+#endif
default:
assert(0);
}
}
-int read_wim_resource(const struct lookup_table_entry *lte, u8 buf[],
- size_t size, u64 offset)
-{
- return __read_wim_resource(lte, buf, size, offset, false);
-}
-
+/*
+ * Reads all the data from the resource corresponding to a WIM lookup table
+ * entry.
+ *
+ * @lte: The WIM lookup table entry for the resource.
+ * @buf: Buffer into which to write the data. It must be at least
+ * wim_resource_size(lte) bytes long.
+ *
+ * Returns 0 on success; nonzero on failure.
+ */
int read_full_wim_resource(const struct lookup_table_entry *lte, u8 buf[])
{
- return __read_wim_resource(lte, buf, lte->resource_entry.original_size,
- 0, false);
+ return read_wim_resource(lte, buf, wim_resource_size(lte), 0, false);
}
+/* Chunk table that's located at the beginning of each compressed resource in
+ * the WIM. (This is not the on-disk format; the on-disk format just has an
+ * array of offsets.) */
struct chunk_table {
off_t file_offset;
u64 num_chunks;
u64 offsets[0];
};
+/*
+ * Allocates and initializes a chunk table, and reserves space for it in the
+ * output file.
+ */
static int
begin_wim_resource_chunk_tab(const struct lookup_table_entry *lte,
FILE *out_fp,
+ off_t file_offset,
struct chunk_table **chunk_tab_ret)
{
u64 size = wim_resource_size(lte);
num_chunks * sizeof(u64));
int ret = 0;
+ wimlib_assert(size != 0);
+
if (!chunk_tab) {
ERROR("Failed to allocate chunk table for %"PRIu64" byte "
"resource", size);
ret = WIMLIB_ERR_NOMEM;
goto out;
}
- chunk_tab->file_offset = ftello(out_fp);
- if (chunk_tab->file_offset == -1) {
- ERROR_WITH_ERRNO("Failed to get file offset in output WIM");
- ret = WIMLIB_ERR_WRITE;
- goto out;
- }
+ chunk_tab->file_offset = file_offset;
chunk_tab->num_chunks = num_chunks;
- chunk_tab->cur_offset_p = chunk_tab->offsets;
- chunk_tab->original_resource_size = lte->resource_entry.original_size;
- chunk_tab->bytes_per_chunk_entry =
- (lte->resource_entry.original_size >= (1ULL << 32))
- ? 8 : 4;
+ chunk_tab->original_resource_size = size;
+ chunk_tab->bytes_per_chunk_entry = (size >= (1ULL << 32)) ? 8 : 4;
chunk_tab->table_disk_size = chunk_tab->bytes_per_chunk_entry *
(num_chunks - 1);
+ chunk_tab->cur_offset = 0;
+ chunk_tab->cur_offset_p = chunk_tab->offsets;
if (fwrite(chunk_tab, 1, chunk_tab->table_disk_size, out_fp) !=
- chunk_tab->table_disk_size)
- {
+ chunk_tab->table_disk_size) {
ERROR_WITH_ERRNO("Failed to write chunk table in compressed "
"file resource");
ret = WIMLIB_ERR_WRITE;
return ret;
}
-static int compress_chunk(const u8 chunk[], unsigned chunk_sz,
+/*
+ * Compresses a chunk of a WIM resource.
+ *
+ * @chunk: Uncompressed data of the chunk.
+ * @chunk_size: Size of the uncompressed chunk in bytes.
+ * @compressed_chunk: Pointer to output buffer of size at least
+ * (@chunk_size - 1) bytes.
+ * @compressed_chunk_len_ret: Pointer to an unsigned int into which the size
+ * of the compressed chunk will be
+ * returned.
+ * @ctype: Type of compression to use. Must be WIM_COMPRESSION_TYPE_LZX
+ * or WIM_COMPRESSION_TYPE_XPRESS.
+ *
+ * Returns zero if compressed succeeded, and nonzero if the chunk could not be
+ * compressed to any smaller than @chunk_size. This function cannot fail for
+ * any other reasons.
+ */
+static int compress_chunk(const u8 chunk[], unsigned chunk_size,
u8 compressed_chunk[],
unsigned *compressed_chunk_len_ret,
int ctype)
{
- unsigned compressed_chunk_sz;
int (*compress)(const void *, unsigned, void *, unsigned *);
- if (ctype == WIM_COMPRESSION_TYPE_LZX)
+ switch (ctype) {
+ case WIM_COMPRESSION_TYPE_LZX:
compress = lzx_compress;
- else
+ break;
+ case WIM_COMPRESSION_TYPE_XPRESS:
compress = xpress_compress;
- return (*compress)(chunk, chunk_sz, compressed_chunk,
+ break;
+ default:
+ wimlib_assert(0);
+ break;
+ }
+ return (*compress)(chunk, chunk_size, compressed_chunk,
compressed_chunk_len_ret);
}
+/*
+ * Writes a chunk of a WIM resource to an output file.
+ *
+ * @chunk: Uncompressed data of the chunk.
+ * @chunk_size: Size of the chunk (<= WIM_CHUNK_SIZE)
+ * @out_fp: FILE * to write tho chunk to.
+ * @out_ctype: Compression type to use when writing the chunk (ignored if no
+ * chunk table provided)
+ * @chunk_tab: Pointer to chunk table being created. It is updated with the
+ * offset of the chunk we write.
+ *
+ * Returns 0 on success; nonzero on failure.
+ */
static int write_wim_resource_chunk(const u8 chunk[], unsigned chunk_size,
FILE *out_fp, int out_ctype,
struct chunk_table *chunk_tab)
const u8 *out_chunk;
unsigned out_chunk_size;
- if (out_ctype == WIM_COMPRESSION_TYPE_NONE) {
+ wimlib_assert(chunk_size <= WIM_CHUNK_SIZE);
+
+ if (!chunk_tab) {
out_chunk = chunk;
out_chunk_size = chunk_size;
} else {
u8 *compressed_chunk = alloca(chunk_size);
int ret;
- unsigned compressed_chunk_len;
-
- wimlib_assert(chunk_tab != NULL);
ret = compress_chunk(chunk, chunk_size, compressed_chunk,
&out_chunk_size, out_ctype);
- if (ret > 0)
- return ret;
- else if (ret < 0) {
+ if (ret == 0) {
+ out_chunk = compressed_chunk;
+ } else {
out_chunk = chunk;
out_chunk_size = chunk_size;
- } else {
- out_chunk = compressed_chunk;
}
*chunk_tab->cur_offset_p++ = chunk_tab->cur_offset;
chunk_tab->cur_offset += out_chunk_size;
return 0;
}
+/*
+ * Finishes a WIM chunk tale and writes it to the output file at the correct
+ * offset.
+ *
+ * The final size of the full compressed resource is returned in the
+ * @compressed_size_p.
+ */
static int
-finish_wim_resource_chunk_tab(const struct chunk_table *chunk_tab,
- FILE *out_fp)
+finish_wim_resource_chunk_tab(struct chunk_table *chunk_tab,
+ FILE *out_fp, u64 *compressed_size_p)
{
+ size_t bytes_written;
if (fseeko(out_fp, chunk_tab->file_offset, SEEK_SET) != 0) {
- ERROR_WITH_ERRNO("Failed to seet to byte "PRIu64" of output "
+ ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" of output "
"WIM file", chunk_tab->file_offset);
return WIMLIB_ERR_WRITE;
}
if (chunk_tab->bytes_per_chunk_entry == 8) {
- array_to_le64(chunk_tab->offsets, chunk_tab->num_chunks - 1);
+ array_to_le64(chunk_tab->offsets, chunk_tab->num_chunks);
} else {
- for (u64 i = 0; i < chunk_tab->num_chunks - 1; i++)
+ for (u64 i = 0; i < chunk_tab->num_chunks; i++)
((u32*)chunk_tab->offsets)[i] =
to_le32(chunk_tab->offsets[i]);
}
- if (fwrite(chunk_tab->offsets, 1, chunk_tab->table_disk_size, out_fp) !=
- chunk_tab->table_disk_size)
- {
+ bytes_written = fwrite((u8*)chunk_tab->offsets +
+ chunk_tab->bytes_per_chunk_entry,
+ 1, chunk_tab->table_disk_size, out_fp);
+ if (bytes_written != chunk_tab->table_disk_size) {
ERROR_WITH_ERRNO("Failed to write chunk table in compressed "
"file resource");
return WIMLIB_ERR_WRITE;
}
- if (fseeko(out_fp, chunk_tab->file_offset, SEEK_SET) != 0) {
- ERROR_WITH_ERRNO("Failed to seet to byte "PRIu64" of output "
- "WIM file", chunk_tab->file_offset);
+ if (fseeko(out_fp, 0, SEEK_END) != 0) {
+ ERROR_WITH_ERRNO("Failed to seek to end of output WIM file");
return WIMLIB_ERR_WRITE;
}
+ *compressed_size_p = chunk_tab->cur_offset + chunk_tab->table_disk_size;
return 0;
}
-static int write_wim_resource(const struct lookup_table_entry *lte,
- FILE *out_fp, int out_ctype)
+/*
+ * Writes a WIM resource to a FILE * opened for writing. The resource may be
+ * written uncompressed or compressed depending on the @out_ctype parameter.
+ *
+ * If by chance the resource compresses to more than the original size (this may
+ * happen with random data or files than are pre-compressed), the resource is
+ * instead written uncompressed (and this is reflected in the @out_res_entry by
+ * removing the WIM_RESHDR_FLAG_COMPRESSED flag).
+ *
+ * @lte: The lookup table entry for the WIM resource.
+ * @out_fp: The FILE * to write the resource to.
+ * @out_ctype: The compression type of the resource to write. Note: if this is
+ * the same as the compression type of the WIM resource we
+ * need to read, we simply copy the data (i.e. we do not
+ * uncompress it, then compress it again).
+ * @out_res_entry: If non-NULL, a resource entry that is filled in with the
+ * offset, original size, compressed size, and compression flag
+ * of the output resource.
+ *
+ * Returns 0 on success; nonzero on failure.
+ */
+static int write_wim_resource(struct lookup_table_entry *lte,
+ FILE *out_fp, int out_ctype,
+ struct resource_entry *out_res_entry)
{
- u64 bytes_remaining = wim_resource_size(lte);
- char buf[min(WIM_CHUNK_SIZE, bytes_remaining)];
+ u64 bytes_remaining;
+ u64 original_size;
+ u64 old_compressed_size;
+ u64 new_compressed_size;
u64 offset = 0;
int ret = 0;
- bool raw = wim_resource_compression_type(lte) == out_ctype;
struct chunk_table *chunk_tab = NULL;
+ bool raw;
+ off_t file_offset;
+#ifdef WITH_NTFS_3G
+ ntfs_inode *ni = NULL;
+#endif
+
+ wimlib_assert(lte);
+
+ /* Original size of the resource */
+ original_size = wim_resource_size(lte);
+ /* Compressed size of the resource (as it exists now) */
+ old_compressed_size = wim_resource_compressed_size(lte);
+
+ /* Current offset in output file */
+ file_offset = ftello(out_fp);
+ if (file_offset == -1) {
+ ERROR_WITH_ERRNO("Failed to get offset in output "
+ "stream");
+ return WIMLIB_ERR_WRITE;
+ }
+
+ /* Are the compression types the same? If so, do a raw copy (copy
+ * without decompressing and recompressing the data). */
+ raw = (wim_resource_compression_type(lte) == out_ctype
+ && out_ctype != WIM_COMPRESSION_TYPE_NONE);
if (raw)
- out_ctype = WIM_COMPRESSION_TYPE_NONE;
+ bytes_remaining = old_compressed_size;
+ else
+ bytes_remaining = original_size;
+
+ /* Empty resource; nothing needs to be done, so just return success. */
+ if (bytes_remaining == 0)
+ return 0;
+
+ /* Buffer for reading chunks for the resource */
+ u8 buf[min(WIM_CHUNK_SIZE, bytes_remaining)];
- if (out_ctype != WIM_COMPRESSION_TYPE_NONE) {
- ret = begin_wim_resource_chunk_tab(lte, out_fp,
+ /* If we are writing a compressed resource and not doing a raw copy, we
+ * need to initialize the chunk table */
+ if (out_ctype != WIM_COMPRESSION_TYPE_NONE && !raw) {
+ ret = begin_wim_resource_chunk_tab(lte, out_fp, file_offset,
&chunk_tab);
if (ret != 0)
- return 0;
+ goto out;
}
- while (bytes_remaining) {
+ /* If the WIM resource is in an external file, open a FILE * to it so we
+ * don't have to open a temporary one in read_wim_resource() for each
+ * chunk. */
+ if (lte->resource_location == RESOURCE_IN_FILE_ON_DISK
+ && !lte->file_on_disk_fp)
+ {
+ wimlib_assert(lte->file_on_disk);
+ lte->file_on_disk_fp = fopen(lte->file_on_disk, "rb");
+ if (!lte->file_on_disk_fp) {
+ ERROR_WITH_ERRNO("Failed to open the file `%s' for "
+ "reading", lte->file_on_disk);
+ ret = WIMLIB_ERR_OPEN;
+ goto out;
+ }
+ }
+#ifdef WITH_NTFS_3G
+ else if (lte->resource_location == RESOURCE_IN_NTFS_VOLUME
+ && !lte->attr)
+ {
+ struct ntfs_location *loc = lte->ntfs_loc;
+ wimlib_assert(loc);
+ ni = ntfs_pathname_to_inode(*loc->ntfs_vol_p, NULL, loc->path_utf8);
+ if (!ni) {
+ ERROR_WITH_ERRNO("Failed to open inode `%s' in NTFS "
+ "volume", loc->path_utf8);
+ ret = WIMLIB_ERR_NTFS_3G;
+ goto out;
+ }
+ lte->attr = ntfs_attr_open(ni,
+ loc->is_reparse_point ? AT_REPARSE_POINT : AT_DATA,
+ (ntfschar*)loc->stream_name_utf16,
+ loc->stream_name_utf16_num_chars);
+ if (!lte->attr) {
+ ERROR_WITH_ERRNO("Failed to open attribute of `%s' in "
+ "NTFS volume", loc->path_utf8);
+ ret = WIMLIB_ERR_NTFS_3G;
+ goto out_fclose;
+ }
+ }
+#endif
+
+ /* If we aren't doing a raw copy, we will compute the SHA1 message
+ * digest of the resource as we read it, and verify it's the same as the
+ * hash given in the lookup table entry once we've finished reading the
+ * resource. */
+ SHA_CTX ctx;
+ if (!raw)
+ sha1_init(&ctx);
+
+ /* While there are still bytes remaining in the WIM resource, read a
+ * chunk of the resource, update SHA1, then write that chunk using the
+ * desired compression type. */
+ do {
u64 to_read = min(bytes_remaining, WIM_CHUNK_SIZE);
- ret = __read_wim_resource(lte, buf, to_read, offset, raw);
+ ret = read_wim_resource(lte, buf, to_read, offset, raw);
if (ret != 0)
- break;
+ goto out_fclose;
+ if (!raw)
+ sha1_update(&ctx, buf, to_read);
ret = write_wim_resource_chunk(buf, to_read, out_fp,
out_ctype, chunk_tab);
if (ret != 0)
- break;
+ goto out_fclose;
bytes_remaining -= to_read;
offset += to_read;
+ } while (bytes_remaining);
+
+ /* Raw copy: The new compressed size is the same as the old compressed
+ * size
+ *
+ * Using WIM_COMPRESSION_TYPE_NONE: The new compressed size is the
+ * original size
+ *
+ * Using a different compression type: Call
+ * finish_wim_resource_chunk_tab() and it will provide the new
+ * compressed size.
+ */
+ if (raw) {
+ new_compressed_size = old_compressed_size;
+ } else {
+ if (out_ctype == WIM_COMPRESSION_TYPE_NONE)
+ new_compressed_size = original_size;
+ else {
+ ret = finish_wim_resource_chunk_tab(chunk_tab, out_fp,
+ &new_compressed_size);
+ if (ret != 0)
+ goto out_fclose;
+ }
+ }
+
+ /* Verify SHA1 message digest of the resource, unless we are doing a raw
+ * write (in which case we never even saw the uncompressed data). Or,
+ * if the hash we had before is all 0's, just re-set it to be the new
+ * hash. */
+ if (!raw) {
+ u8 md[SHA1_HASH_SIZE];
+ sha1_final(md, &ctx);
+ if (is_zero_hash(lte->hash)) {
+ copy_hash(lte->hash, md);
+ } else if (!hashes_equal(md, lte->hash)) {
+ ERROR("WIM resource has incorrect hash!");
+ if (lte->resource_location == RESOURCE_IN_FILE_ON_DISK) {
+ ERROR("We were reading it from `%s'; maybe it changed "
+ "while we were reading it.",
+ lte->file_on_disk);
+ }
+ ret = WIMLIB_ERR_INVALID_RESOURCE_HASH;
+ goto out_fclose;
+ }
+ }
+
+ if (!raw && new_compressed_size >= original_size &&
+ out_ctype != WIM_COMPRESSION_TYPE_NONE)
+ {
+ /* Oops! We compressed the resource to larger than the original
+ * size. Write the resource uncompressed instead. */
+ if (fseeko(out_fp, file_offset, SEEK_SET) != 0) {
+ ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" "
+ "of output WIM file", file_offset);
+ ret = WIMLIB_ERR_WRITE;
+ goto out_fclose;
+ }
+ ret = write_wim_resource(lte, out_fp, WIM_COMPRESSION_TYPE_NONE,
+ out_res_entry);
+ if (ret != 0)
+ goto out_fclose;
+ if (fflush(out_fp) != 0) {
+ ERROR_WITH_ERRNO("Failed to flush output WIM file");
+ ret = WIMLIB_ERR_WRITE;
+ goto out_fclose;
+ }
+ if (ftruncate(fileno(out_fp), file_offset + out_res_entry->size) != 0) {
+ ERROR_WITH_ERRNO("Failed to truncate output WIM file");
+ ret = WIMLIB_ERR_WRITE;
+ }
+ goto out_fclose;
}
- if (out_ctype != WIM_COMPRESSION_TYPE_NONE)
- ret = finish_wim_resource_chunk_tab(chunk_tab, out_fp);
+ wimlib_assert(new_compressed_size <= original_size || raw);
+ if (out_res_entry) {
+ out_res_entry->size = new_compressed_size;
+ out_res_entry->original_size = original_size;
+ out_res_entry->offset = file_offset;
+ out_res_entry->flags = lte->resource_entry.flags
+ & ~WIM_RESHDR_FLAG_COMPRESSED;
+ if (out_ctype != WIM_COMPRESSION_TYPE_NONE)
+ out_res_entry->flags |= WIM_RESHDR_FLAG_COMPRESSED;
+ }
+out_fclose:
+ if (lte->resource_location == RESOURCE_IN_FILE_ON_DISK
+ && lte->file_on_disk_fp) {
+ fclose(lte->file_on_disk_fp);
+ lte->file_on_disk_fp = NULL;
+ }
+#ifdef WITH_NTFS_3G
+ else if (lte->resource_location == RESOURCE_IN_NTFS_VOLUME) {
+ if (lte->attr) {
+ ntfs_attr_close(lte->attr);
+ lte->attr = NULL;
+ } if (ni) {
+ ntfs_inode_close(ni);
+ }
+ }
+#endif
+out:
+ FREE(chunk_tab);
return ret;
}
+/* Like write_wim_resource(), but the resource is specified by a buffer of
+ * uncompressed data rather a lookup table entry; also writes the SHA1 hash of
+ * the buffer to @hash. */
static int write_wim_resource_from_buffer(const u8 *buf, u64 buf_size,
- FILE *out_fp, int out_ctype)
+ FILE *out_fp, int out_ctype,
+ struct resource_entry *out_res_entry,
+ u8 hash[SHA1_HASH_SIZE])
{
+ /* Set up a temporary lookup table entry that we provide to
+ * write_wim_resource(). */
struct lookup_table_entry lte;
- lte.resource_entry.flags = 0;
+ int ret;
+ lte.resource_entry.flags = 0;
lte.resource_entry.original_size = buf_size;
- lte.resource_entry.size = buf_size;
- lte.resource_entry.offset = 0;
- lte.resource_location = RESOURCE_IN_ATTACHED_BUFFER;
- lte.attached_buffer = (u8*)buf;
- return write_wim_resource(<e, out_fp, out_ctype);
+ lte.resource_entry.size = buf_size;
+ lte.resource_entry.offset = 0;
+ lte.resource_location = RESOURCE_IN_ATTACHED_BUFFER;
+ lte.attached_buffer = (u8*)buf;
+
+ zero_out_hash(lte.hash);
+ ret = write_wim_resource(<e, out_fp, out_ctype, out_res_entry);
+ if (ret != 0)
+ return ret;
+ copy_hash(hash, lte.hash);
+ return 0;
}
/*
- * Extracts the first @size bytes of the resource specified by @lte to the open
- * file @fd. Returns nonzero on error.
+ * Extracts the first @size bytes of the WIM resource specified by @lte to the
+ * open file descriptor @fd.
+ *
+ * Returns 0 on success; nonzero on failure.
*/
int extract_wim_resource_to_fd(const struct lookup_table_entry *lte, int fd,
u64 size)
{
u64 bytes_remaining = size;
- char buf[min(WIM_CHUNK_SIZE, bytes_remaining)];
+ u8 buf[min(WIM_CHUNK_SIZE, bytes_remaining)];
u64 offset = 0;
int ret = 0;
+ u8 hash[SHA1_HASH_SIZE];
+
+ SHA_CTX ctx;
+ sha1_init(&ctx);
while (bytes_remaining) {
u64 to_read = min(bytes_remaining, WIM_CHUNK_SIZE);
- ret = read_wim_resource(lte, buf, to_read, offset);
+ ret = read_wim_resource(lte, buf, to_read, offset, false);
if (ret != 0)
break;
+ sha1_update(&ctx, buf, to_read);
if (full_write(fd, buf, to_read) < 0) {
ERROR_WITH_ERRNO("Error extracting WIM resource");
return WIMLIB_ERR_WRITE;
bytes_remaining -= to_read;
offset += to_read;
}
+ sha1_final(hash, &ctx);
+ if (!hashes_equal(hash, lte->hash)) {
+ ERROR("Invalid checksum on a WIM resource "
+ "(detected when extracting to external file)");
+ ERROR("The following WIM resource is invalid:");
+ print_lookup_table_entry(lte);
+ return WIMLIB_ERR_INVALID_RESOURCE_HASH;
+ }
return 0;
}
+/*
+ * Extracts the WIM resource specified by @lte to the open file descriptor @fd.
+ *
+ * Returns 0 on success; nonzero on failure.
+ */
int extract_full_wim_resource_to_fd(const struct lookup_table_entry *lte, int fd)
{
- return extract_wim_resource_to_fd(lte, fd,
- lte->resource_entry.original_size);
+ return extract_wim_resource_to_fd(lte, fd, wim_resource_size(lte));
}
/*
* Copies the file resource specified by the lookup table entry @lte from the
- * input WIM, pointed to by the fp field of the WIMStruct, to the output WIM,
- * pointed to by the out_fp field of the WIMStruct.
+ * input WIM to the output WIM that has its FILE * given by
+ * ((WIMStruct*)wim)->out_fp.
*
* The output_resource_entry, out_refcnt, and part_number fields of @lte are
* updated.
{
WIMStruct *w = wim;
int ret;
- off_t new_offset;
if ((lte->resource_entry.flags & WIM_RESHDR_FLAG_METADATA) &&
!w->write_metadata)
return 0;
- new_offset = ftello(w->out_fp);
- if (new_offset == -1) {
- ERROR_WITH_ERRNO("Could not get offset in output WIM");
- return WIMLIB_ERR_WRITE;
- }
-
-
ret = write_wim_resource(lte, w->out_fp,
- wimlib_get_compression_type((WIMStruct*)w));
+ wim_resource_compression_type(lte),
+ <e->output_resource_entry);
if (ret != 0)
return ret;
-
- memcpy(<e->output_resource_entry, <e->resource_entry,
- sizeof(struct resource_entry));
-
- lte->output_resource_entry.offset = new_offset;
lte->out_refcnt = lte->refcnt;
lte->part_number = w->hdr.part_number;
return 0;
* alternate data streams, to the output file.
*
* @dentry: The dentry for the file.
- * @wim_p: A pointer to the WIMStruct. The fields of interest to this
- * function are the input and output file streams and the lookup
- * table.
+ * @wim_p: A pointer to the WIMStruct containing @dentry.
*
* @return zero on success, nonzero on failure.
*/
struct lookup_table_entry *lte;
int ctype = wimlib_get_compression_type(w);
- for (unsigned i = 0; i <= dentry->num_ads; i++) {
- lte = dentry_stream_lte(dentry, i, w->lookup_table);
+ if (w->write_flags & WIMLIB_WRITE_FLAG_VERBOSE) {
+ wimlib_assert(dentry->full_path_utf8);
+ printf("Writing streams for `%s'\n", dentry->full_path_utf8);
+ }
+
+ for (unsigned i = 0; i <= dentry->inode->num_ads; i++) {
+ lte = inode_stream_lte(dentry->inode, i, w->lookup_table);
if (lte && ++lte->out_refcnt == 1) {
- ret = write_wim_resource(lte, w->out_fp, ctype);
+ ret = write_wim_resource(lte, w->out_fp, ctype,
+ <e->output_resource_entry);
if (ret != 0)
break;
}
*
* @fp: The FILE* for the input WIM file.
* @wim_ctype: The compression type of the WIM file.
- * @imd: Pointer to the image metadata structure. Its
- * `lookup_table_entry' member specifies the lookup table entry for
- * the metadata resource. The rest of the image metadata entry
- * will be filled in by this function.
+ * @imd: Pointer to the image metadata structure. Its `metadata_lte'
+ * member specifies the lookup table entry for the metadata
+ * resource. The rest of the image metadata entry will be filled
+ * in by this function.
*
* @return: Zero on success, nonzero on failure.
*/
-int read_metadata_resource(FILE *fp, int wim_ctype, struct image_metadata *imd)
+int read_metadata_resource(WIMStruct *w, struct image_metadata *imd)
{
u8 *buf;
- int ctype;
u32 dentry_offset;
int ret;
struct dentry *dentry;
- struct wim_security_data *sd;
- struct link_group_table *lgt;
+ struct inode_table inode_tab;
const struct lookup_table_entry *metadata_lte;
- const struct resource_entry *res_entry;
+ u64 metadata_len;
+ u64 metadata_offset;
+ struct hlist_head inode_list;
metadata_lte = imd->metadata_lte;
- res_entry = &metadata_lte->resource_entry;
+ metadata_len = wim_resource_size(metadata_lte);
+ metadata_offset = metadata_lte->resource_entry.offset;
DEBUG("Reading metadata resource: length = %"PRIu64", "
- "offset = %"PRIu64"",
- res_entry->original_size, res_entry->offset);
-
- if (res_entry->original_size < 8) {
- ERROR("Expected at least 8 bytes for the metadata resource");
+ "offset = %"PRIu64"", metadata_len, metadata_offset);
+
+ /* There is no way the metadata resource could possibly be less than (8
+ * + WIM_DENTRY_DISK_SIZE) bytes, where the 8 is for security data (with
+ * no security descriptors) and WIM_DENTRY_DISK_SIZE is for the root
+ * dentry. */
+ if (metadata_len < 8 + WIM_DENTRY_DISK_SIZE) {
+ ERROR("Expected at least %u bytes for the metadata resource",
+ 8 + WIM_DENTRY_DISK_SIZE);
return WIMLIB_ERR_INVALID_RESOURCE_SIZE;
}
/* Allocate memory for the uncompressed metadata resource. */
- buf = MALLOC(res_entry->original_size);
+ buf = MALLOC(metadata_len);
if (!buf) {
ERROR("Failed to allocate %"PRIu64" bytes for uncompressed "
- "metadata resource", res_entry->original_size);
+ "metadata resource", metadata_len);
return WIMLIB_ERR_NOMEM;
}
- /* Determine the compression type of the metadata resource. */
-
/* Read the metadata resource into memory. (It may be compressed.) */
ret = read_full_wim_resource(metadata_lte, buf);
if (ret != 0)
DEBUG("Finished reading metadata resource into memory.");
- /* The root directory entry starts after security data, on an 8-byte
- * aligned address.
+ /* The root directory entry starts after security data, aligned on an
+ * 8-byte boundary within the metadata resource.
*
* The security data starts with a 4-byte integer giving its total
- * length. */
+ * length, so if we round that up to an 8-byte boundary that gives us
+ * the offset of the root dentry.
+ *
+ * Here we read the security data into a wim_security_data structure,
+ * and if successful, go ahead and calculate the offset in the metadata
+ * resource of the root dentry. */
- /* Read the security data into a wim_security_data structure. */
- ret = read_security_data(buf, res_entry->original_size, &sd);
+ ret = read_security_data(buf, metadata_len, &imd->security_data);
if (ret != 0)
goto out_free_buf;
+ get_u32(buf, &dentry_offset);
+ if (dentry_offset == 0)
+ dentry_offset = 8;
+ dentry_offset = (dentry_offset + 7) & ~7;
+
+ /* Allocate memory for the root dentry and read it into memory */
dentry = MALLOC(sizeof(struct dentry));
if (!dentry) {
ERROR("Failed to allocate %zu bytes for root dentry",
ret = WIMLIB_ERR_NOMEM;
goto out_free_security_data;
}
-
- get_u32(buf, &dentry_offset);
- if (dentry_offset == 0)
- dentry_offset = 8;
- dentry_offset = (dentry_offset + 7) & ~7;
- ret = read_dentry(buf, res_entry->original_size, dentry_offset, dentry);
+ ret = read_dentry(buf, metadata_len, dentry_offset, dentry);
+
/* This is the root dentry, so set its pointers correctly. */
dentry->parent = dentry;
dentry->next = dentry;
dentry->prev = dentry;
if (ret != 0)
goto out_free_dentry_tree;
+ inode_add_dentry(dentry, dentry->inode);
+ /* Now read the entire directory entry tree into memory. */
DEBUG("Reading dentry tree");
- /* Now read the entire directory entry tree. */
- ret = read_dentry_tree(buf, res_entry->original_size, dentry);
+ ret = read_dentry_tree(buf, metadata_len, dentry);
if (ret != 0)
goto out_free_dentry_tree;
- DEBUG("Calculating dentry full paths");
/* Calculate the full paths in the dentry tree. */
+ DEBUG("Calculating dentry full paths");
ret = for_dentry_in_tree(dentry, calculate_dentry_full_path, NULL);
if (ret != 0)
goto out_free_dentry_tree;
- DEBUG("Building link group table");
/* Build hash table that maps hard link group IDs to dentry sets */
- lgt = new_link_group_table(9001);
- if (!lgt)
+ DEBUG("Building link group table");
+ ret = init_inode_table(&inode_tab, 9001);
+ if (ret != 0)
goto out_free_dentry_tree;
- ret = for_dentry_in_tree(dentry, link_group_table_insert, lgt);
+
+ for_dentry_in_tree(dentry, inode_table_insert, &inode_tab);
+
+ DEBUG("Fixing inconsistencies in the hard link groups");
+ ret = fix_inodes(&inode_tab, &inode_list);
+ destroy_inode_table(&inode_tab);
if (ret != 0)
- goto out_free_lgt;
+ goto out_free_dentry_tree;
- DEBUG("Freeing duplicate ADS entries in link group table");
- ret = link_groups_free_duplicate_data(lgt);
+ DEBUG("Running miscellaneous verifications on the dentry tree");
+ for_lookup_table_entry(w->lookup_table, lte_zero_real_refcnt, NULL);
+ ret = for_dentry_in_tree(dentry, verify_dentry, w);
if (ret != 0)
- goto out_free_lgt;
+ goto out_free_dentry_tree;
+
DEBUG("Done reading image metadata");
- imd->lgt = lgt;
- imd->security_data = sd;
imd->root_dentry = dentry;
+ imd->inode_list = inode_list;
goto out_free_buf;
-out_free_lgt:
- free_link_group_table(lgt);
out_free_dentry_tree:
free_dentry_tree(dentry, NULL);
out_free_security_data:
- free_security_data(sd);
+ free_security_data(imd->security_data);
+ imd->security_data = NULL;
out_free_buf:
FREE(buf);
return ret;
}
-/* Write the metadata resource for the current image. */
+/* Write the metadata resource for the current WIM image. */
int write_metadata_resource(WIMStruct *w)
{
- FILE *out;
u8 *buf;
u8 *p;
int ret;
u64 subdir_offset;
struct dentry *root;
struct lookup_table_entry *lte;
- off_t metadata_offset;
u64 metadata_original_size;
- u64 metadata_compressed_size;
- int metadata_ctype;
- u8 hash[SHA1_HASH_SIZE];
+ const struct wim_security_data *sd;
+ const unsigned random_tail_len = 20;
DEBUG("Writing metadata resource for image %d", w->current_image);
- out = w->out_fp;
root = wim_root_dentry(w);
- metadata_ctype = wimlib_get_compression_type(w);
- metadata_offset = ftello(out);
- if (metadata_offset == -1)
- return WIMLIB_ERR_WRITE;
+ sd = wim_security_data(w);
+
+ /* We do not allow the security data pointer to be NULL, although it may
+ * point to an empty security data with no entries. */
+ wimlib_assert(sd);
+
+ /* Offset of first child of the root dentry. It's equal to:
+ * - The total length of the security data, rounded to the next 8-byte
+ * boundary,
+ * - plus the total length of the root dentry,
+ * - plus 8 bytes for an end-of-directory entry following the root
+ * dentry (shouldn't really be needed, but just in case...)
+ */
+ subdir_offset = ((sd->total_length + 7) & ~7) +
+ dentry_correct_total_length(root) + 8;
- struct wim_security_data *sd = wim_security_data(w);
- if (sd)
- subdir_offset = sd->total_length + root->length + 8;
- else
- subdir_offset = 8 + root->length + 8;
+ /* Calculate the subdirectory offsets for the entire dentry tree. */
calculate_subdir_offsets(root, &subdir_offset);
- metadata_original_size = subdir_offset;
+
+ /* Total length of the metadata resource (uncompressed) */
+ metadata_original_size = subdir_offset + random_tail_len;
+
+ /* Allocate a buffer to contain the uncompressed metadata resource */
buf = MALLOC(metadata_original_size);
if (!buf) {
ERROR("Failed to allocate %"PRIu64" bytes for "
return WIMLIB_ERR_NOMEM;
}
+ /* Write the security data into the resource buffer */
p = write_security_data(sd, buf);
+ /* Write the dentry tree into the resource buffer */
DEBUG("Writing dentry tree.");
p = write_dentry_tree(root, p);
- /* Like file resources, the lookup table entry for a metadata resource
- * uses for the hash code a SHA1 message digest of its uncompressed
- * contents. */
- sha1_buffer(buf, metadata_original_size, hash);
+ /*
+ * Append 20 random bytes to the metadata resource so that we don't have
+ * identical metadata resources if we happen to append exactly the same
+ * image twice without any changes in timestamps. If this were to
+ * happen, it would cause confusion about the number and order of images
+ * in the WIM.
+ */
+ randomize_byte_array(p, random_tail_len);
+
+ /* We MUST have exactly filled the buffer; otherwise we calculated its
+ * size incorrectly or wrote the data incorrectly. */
+ wimlib_assert(p - buf + random_tail_len == metadata_original_size);
+ /* Get the lookup table entry for the metadata resource so we can update
+ * it. */
+ lte = wim_metadata_lookup_table_entry(w);
+ /* Write the metadata resource to the output WIM using the proper
+ * compression type. The lookup table entry for the metadata resource
+ * is updated. */
ret = write_wim_resource_from_buffer(buf, metadata_original_size,
- out, metadata_ctype);
- FREE(buf);
+ w->out_fp,
+ wimlib_get_compression_type(w),
+ <e->output_resource_entry,
+ lte->hash);
if (ret != 0)
- return ret;
-
- DEBUG("Updating metadata lookup table entry (size %zu)",
- metadata_original_size);
+ goto out;
- /* Update the lookup table entry, including the hash and output resource
- * entry fields, for this image's metadata resource. */
- lte = wim_metadata_lookup_table_entry(w);
- lte->out_refcnt++;
- if (!hashes_equal(hash, lte->hash)) {
- lookup_table_unlink(w->lookup_table, lte);
- copy_hash(lte->hash, hash);
- lookup_table_insert(w->lookup_table, lte);
- }
- lte->output_resource_entry.original_size = metadata_original_size;
- lte->output_resource_entry.offset = metadata_offset;
- lte->output_resource_entry.size = metadata_compressed_size;
- lte->output_resource_entry.flags = WIM_RESHDR_FLAG_METADATA;
- if (metadata_ctype != WIM_COMPRESSION_TYPE_NONE)
- lte->output_resource_entry.flags |= WIM_RESHDR_FLAG_COMPRESSED;
- return 0;
+ /* It's very likely the SHA1 message digest of the metadata resource, so
+ * re-insert the lookup table entry into the lookup table. */
+ lookup_table_unlink(w->lookup_table, lte);
+ lookup_table_insert(w->lookup_table, lte);
+
+ /* We do not allow a metadata resource to be referenced multiple times,
+ * and the 20 random bytes appended to it should make it extremely
+ * likely for each metadata resource to be unique, even if the exact
+ * same image is captured. */
+ wimlib_assert(lte->out_refcnt == 0);
+ lte->out_refcnt = 1;
+
+ /* Make sure that the resource entry is written marked with the metadata
+ * flag. */
+ lte->output_resource_entry.flags |= WIM_RESHDR_FLAG_METADATA;
+out:
+ /* All the data has been written to the new WIM; no need for the buffer
+ * anymore */
+ FREE(buf);
+ return ret;
}