}
/*
- * Reads some data from a WIM resource.
+ * Reads some data from the resource corresponding to a WIM lookup table entry.
*
- * If %raw is true, compressed data is read literally rather than being
- * decompressed first.
+ * @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.
*/
-static int __read_wim_resource(const struct lookup_table_entry *lte,
- u8 buf[], size_t size, u64 offset, bool raw)
+int read_wim_resource(const struct lookup_table_entry *lte, u8 buf[],
+ size_t size, u64 offset, bool raw)
{
/* We shouldn't be allowing read over-runs in any part of the library.
* */
wimlib_assert(lte->wim->fp);
ctype = wim_resource_compression_type(lte);
- /* XXX This check should be moved elsewhere */
- 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,
}
}
-/*
- * 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.
- *
- * Returns 0 on success; nonzero on failure.
- */
-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.
*/
int read_full_wim_resource(const struct lookup_table_entry *lte, u8 buf[])
{
- return __read_wim_resource(lte, buf, wim_resource_size(lte), 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,
return ret;
}
+/*
+ * 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,
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;
+ wimlib_assert(chunk_size <= WIM_CHUNK_SIZE);
+
if (!chunk_tab) {
out_chunk = chunk;
out_chunk_size = 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(struct chunk_table *chunk_tab,
FILE *out_fp, u64 *compressed_size_p)
* 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
bool raw;
off_t file_offset;
+ /* 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 "
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)
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 */
char buf[min(WIM_CHUNK_SIZE, bytes_remaining)];
+ /* 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)
goto out;
}
+
+ /* 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)
{
goto out;
}
}
+
+ /* 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)
goto out_fclose;
if (!raw)
bytes_remaining -= to_read;
offset += to_read;
} while (bytes_remaining);
+
+ /* If writing a compressed resource and not doing a raw copy, write the
+ * chunk table, and finish_wim_resource_chunk_tab() will provide the
+ * compressed size of the resource we wrote. Otherwise, the compressed
+ * size of the written resource is the same as the compressed size of
+ * the existing resource. */
if (out_ctype != WIM_COMPRESSION_TYPE_NONE && !raw) {
ret = finish_wim_resource_chunk_tab(chunk_tab, out_fp,
&new_compressed_size);
new_compressed_size = old_compressed_size;
}
+ /* 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 (!hashes_equal(md, lte->hash)) {
+ 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_INTEGRITY;
+ ret = WIMLIB_ERR_INVALID_RESOURCE_HASH;
goto out_fclose;
}
}
if (out_res_entry) {
out_res_entry->size = new_compressed_size;
out_res_entry->original_size = original_size;
- out_res_entry->offset = file_offset;
- if (out_ctype == WIM_COMPRESSION_TYPE_NONE)
- out_res_entry->flags = 0;
- else
- out_res_entry->flags = WIM_RESHDR_FLAG_COMPRESSED;
- if (lte->resource_entry.flags & WIM_RESHDR_FLAG_METADATA)
- out_res_entry->flags |= WIM_RESHDR_FLAG_METADATA;
+ 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
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,
- u8 buf_hash[SHA1_HASH_SIZE],
FILE *out_fp, int out_ctype,
- struct resource_entry *out_res_entry)
+ 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;
+ 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;
- copy_hash(lte.hash, buf_hash);
- return write_wim_resource(<e, out_fp, out_ctype, out_res_entry);
+
+ zero_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)
char 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, 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.
* 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.
*/
*
* @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.
*/
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;
+ struct lookup_table_entry *lte, *duplicate_lte;
u64 metadata_original_size;
- u64 metadata_compressed_size;
- int metadata_ctype;
- u8 hash[SHA1_HASH_SIZE];
+
+ /*
+ * We 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.
+ */
+ 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;
struct wim_security_data *sd = wim_security_data(w);
if (sd)
else
subdir_offset = 8 + root->length + 8;
calculate_subdir_offsets(root, &subdir_offset);
- metadata_original_size = subdir_offset;
+ metadata_original_size = subdir_offset + random_tail_len;
buf = MALLOC(metadata_original_size);
if (!buf) {
ERROR("Failed to allocate %"PRIu64" bytes for "
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);
-
+ randomize_byte_array(p, random_tail_len);
+ wimlib_assert(p - buf + random_tail_len == metadata_original_size);
lte = wim_metadata_lookup_table_entry(w);
ret = write_wim_resource_from_buffer(buf, metadata_original_size,
- hash, out, metadata_ctype,
- <e->output_resource_entry);
-
+ w->out_fp,
+ wimlib_get_compression_type(w),
+ <e->output_resource_entry,
+ lte->hash);
lookup_table_unlink(w->lookup_table, lte);
- copy_hash(lte->hash, hash);
lookup_table_insert(w->lookup_table, lte);
+ wimlib_assert(lte->out_refcnt == 0);
lte->out_refcnt++;
lte->output_resource_entry.flags |= WIM_RESHDR_FLAG_METADATA;
+out:
FREE(buf);
- if (ret != 0)
- return ret;
-
- return 0;
+ return ret;
}
git://wimlib.net / wimlib / blobdiff