#include "wimlib/progress.h"
#include "wimlib/resource.h"
#include "wimlib/solid.h"
-#ifdef __WIN32__
-# include "wimlib/win32.h" /* win32_rename_replacement() */
-#endif
+#include "wimlib/win32.h" /* win32_rename_replacement() */
#include "wimlib/write.h"
#include "wimlib/xml.h"
#define WRITE_RESOURCE_FLAG_SEND_DONE_WITH_FILE 0x00000008
#define WRITE_RESOURCE_FLAG_SOLID_SORT 0x00000010
-static inline int
+static int
write_flags_to_resource_flags(int write_flags)
{
int write_resource_flags = 0;
if (write_flags & WIMLIB_WRITE_FLAG_RECOMPRESS)
write_resource_flags |= WRITE_RESOURCE_FLAG_RECOMPRESS;
+
if (write_flags & WIMLIB_WRITE_FLAG_PIPABLE)
write_resource_flags |= WRITE_RESOURCE_FLAG_PIPABLE;
+
if (write_flags & WIMLIB_WRITE_FLAG_SOLID)
write_resource_flags |= WRITE_RESOURCE_FLAG_SOLID;
+
if (write_flags & WIMLIB_WRITE_FLAG_SEND_DONE_WITH_FILE_MESSAGES)
write_resource_flags |= WRITE_RESOURCE_FLAG_SEND_DONE_WITH_FILE;
+
if ((write_flags & (WIMLIB_WRITE_FLAG_SOLID |
WIMLIB_WRITE_FLAG_NO_SOLID_SORT)) ==
WIMLIB_WRITE_FLAG_SOLID)
write_resource_flags |= WRITE_RESOURCE_FLAG_SOLID_SORT;
+
return write_resource_flags;
}
return false;
}
-static u8
-filter_resource_flags(u8 flags)
+static u32
+reshdr_flags_for_blob(const struct blob_descriptor *blob)
{
- return (flags & ~(WIM_RESHDR_FLAG_SOLID |
- WIM_RESHDR_FLAG_COMPRESSED |
- WIM_RESHDR_FLAG_SPANNED |
- WIM_RESHDR_FLAG_FREE));
+ u32 reshdr_flags = 0;
+ if (blob->is_metadata)
+ reshdr_flags |= WIM_RESHDR_FLAG_METADATA;
+ return reshdr_flags;
}
static void
rdesc = blob->rdesc;
if (rdesc->flags & WIM_RESHDR_FLAG_SOLID) {
-
- wimlib_assert(blob->flags & WIM_RESHDR_FLAG_SOLID);
-
blob->out_reshdr.offset_in_wim = blob->offset_in_res;
blob->out_reshdr.uncompressed_size = 0;
blob->out_reshdr.size_in_wim = blob->size;
blob->out_res_size_in_wim = rdesc->size_in_wim;
blob->out_res_uncompressed_size = rdesc->uncompressed_size;
} else {
- wimlib_assert(!(blob->flags & WIM_RESHDR_FLAG_SOLID));
-
blob->out_reshdr.offset_in_wim = rdesc->offset_in_wim;
blob->out_reshdr.uncompressed_size = rdesc->uncompressed_size;
blob->out_reshdr.size_in_wim = rdesc->size_in_wim;
}
- blob->out_reshdr.flags = blob->flags;
+ blob->out_reshdr.flags = rdesc->flags;
}
/* Write the header for a blob in a pipable WIM. */
static int
write_pwm_blob_header(const struct blob_descriptor *blob,
- struct filedes *out_fd, int additional_reshdr_flags)
+ struct filedes *out_fd, bool compressed)
{
struct pwm_blob_hdr blob_hdr;
u32 reshdr_flags;
int ret;
+ wimlib_assert(!blob->unhashed);
+
blob_hdr.magic = cpu_to_le64(PWM_BLOB_MAGIC);
blob_hdr.uncompressed_size = cpu_to_le64(blob->size);
- if (additional_reshdr_flags & PWM_RESHDR_FLAG_UNHASHED) {
- zero_out_hash(blob_hdr.hash);
- } else {
- wimlib_assert(!blob->unhashed);
- copy_hash(blob_hdr.hash, blob->hash);
- }
-
- reshdr_flags = filter_resource_flags(blob->flags);
- reshdr_flags |= additional_reshdr_flags;
+ copy_hash(blob_hdr.hash, blob->hash);
+ reshdr_flags = reshdr_flags_for_blob(blob);
+ if (compressed)
+ reshdr_flags |= WIM_RESHDR_FLAG_COMPRESSED;
blob_hdr.flags = cpu_to_le32(reshdr_flags);
ret = full_write(out_fd, &blob_hdr, sizeof(blob_hdr));
if (ret)
wimlib_progress_func_t progfunc;
void *progctx;
union wimlib_progress_info progress;
- uint64_t next_progress;
+ u64 next_progress;
};
static int
if (discarded) {
progress->write_streams.total_bytes -= complete_size;
progress->write_streams.total_streams -= complete_count;
- if (progress_data->next_progress != ~(uint64_t)0 &&
+ if (progress_data->next_progress != ~(u64)0 &&
progress_data->next_progress > progress->write_streams.total_bytes)
{
progress_data->next_progress = progress->write_streams.total_bytes;
progress->write_streams.completed_streams += complete_count;
}
- if (progress->write_streams.completed_bytes >= progress_data->next_progress)
- {
+ if (progress->write_streams.completed_bytes >= progress_data->next_progress) {
+
ret = call_progress(progress_data->progfunc,
WIMLIB_PROGRESS_MSG_WRITE_STREAMS,
progress,
if (ret)
return ret;
- if (progress_data->next_progress == progress->write_streams.total_bytes) {
- progress_data->next_progress = ~(uint64_t)0;
- } else {
- /* Handle rate-limiting of messages */
-
- /* Send new message as soon as another 1/128 of the
- * total has been written. (Arbitrary number.) */
- progress_data->next_progress =
- progress->write_streams.completed_bytes +
- progress->write_streams.total_bytes / 128;
-
- /* ... Unless that would be more than 5000000 bytes, in
- * which case send the next after the next 5000000
- * bytes. (Another arbitrary number.) */
- if (progress->write_streams.completed_bytes + 5000000 <
- progress_data->next_progress)
- progress_data->next_progress =
- progress->write_streams.completed_bytes + 5000000;
-
- /* ... But always send a message as soon as we're
- * completely done. */
- if (progress->write_streams.total_bytes <
- progress_data->next_progress)
- progress_data->next_progress =
- progress->write_streams.total_bytes;
- }
+ set_next_progress(progress->write_streams.completed_bytes,
+ progress->write_streams.total_bytes,
+ &progress_data->next_progress);
}
return 0;
}
hdr.chunk_size = cpu_to_le32(ctx->out_chunk_size);
hdr.compression_format = cpu_to_le32(ctx->out_ctype);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_XPRESS != 1);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_LZX != 2);
- BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_LZMS != 3);
+ STATIC_ASSERT(WIMLIB_COMPRESSION_TYPE_XPRESS == 1);
+ STATIC_ASSERT(WIMLIB_COMPRESSION_TYPE_LZX == 2);
+ STATIC_ASSERT(WIMLIB_COMPRESSION_TYPE_LZMS == 3);
ret = full_pwrite(ctx->out_fd, &hdr, sizeof(hdr),
chunk_table_offset - sizeof(hdr));
out_reshdr->uncompressed_size = res_uncompressed_size;
out_reshdr->size_in_wim = res_size_in_wim;
out_reshdr->offset_in_wim = res_offset_in_wim;
- DEBUG("Finished writing resource: %"PRIu64" => %"PRIu64" @ %"PRIu64"",
- res_uncompressed_size, res_size_in_wim, res_offset_in_wim);
return 0;
}
{
int ret;
struct wim_inode *inode;
+ tchar *cookie1;
+ tchar *cookie2;
if (!blob->may_send_done_with_file)
return 0;
inode = blob->file_inode;
wimlib_assert(inode != NULL);
- wimlib_assert(inode->num_remaining_streams > 0);
- if (--inode->num_remaining_streams > 0)
+ wimlib_assert(inode->i_num_remaining_streams > 0);
+ if (--inode->i_num_remaining_streams > 0)
return 0;
-#ifdef __WIN32__
- /* XXX: This logic really should be somewhere else. */
-
- /* We want the path to the file, but blob->file_on_disk might actually
- * refer to a named data stream. Temporarily strip the named data
- * stream from the path. */
- wchar_t *p_colon = NULL;
- wchar_t *p_question_mark = NULL;
- const wchar_t *p_stream_name;
-
- p_stream_name = path_stream_name(blob->file_on_disk);
- if (unlikely(p_stream_name)) {
- p_colon = (wchar_t *)(p_stream_name - 1);
- wimlib_assert(*p_colon == L':');
- *p_colon = L'\0';
- }
-
- /* We also should use a fake Win32 path instead of a NT path */
- if (!wcsncmp(blob->file_on_disk, L"\\??\\", 4)) {
- p_question_mark = &blob->file_on_disk[1];
- *p_question_mark = L'\\';
- }
-#endif
+ cookie1 = progress_get_streamless_path(blob->file_on_disk);
+ cookie2 = progress_get_win32_path(blob->file_on_disk);
ret = done_with_file(blob->file_on_disk, progfunc, progctx);
-#ifdef __WIN32__
- if (p_colon)
- *p_colon = L':';
- if (p_question_mark)
- *p_question_mark = L'?';
-#endif
+ progress_put_win32_path(cookie2);
+ progress_put_streamless_path(cookie1);
+
return ret;
}
* (and reading it again) entirely, passing its
* output reference count to the duplicate blob
* in the former case. */
- DEBUG("Discarding duplicate blob of "
- "length %"PRIu64, blob->size);
ret = do_write_blobs_progress(&ctx->progress_data,
blob->size, 1, true);
list_del(&blob->write_blobs_list);
* blob descriptor must wait until
* read_blob_list() has finished reading its
* data. */
- DEBUG("Blob duplicate, but not already "
- "selected for writing.");
list_replace(&blob->write_blobs_list,
&new_blob->write_blobs_list);
list_replace(&blob->blob_table_list,
return 0;
}
-/* Rewrite a blob that was just written compressed as uncompressed instead.
- */
+/* Rewrite a blob that was just written compressed (as a non-solid WIM resource)
+ * as uncompressed instead. */
static int
write_blob_uncompressed(struct blob_descriptor *blob, struct filedes *out_fd)
{
if (filedes_seek(out_fd, begin_offset) == -1)
return 0;
- ret = extract_full_blob_to_fd(blob, out_fd);
+ ret = extract_blob_to_fd(blob, out_fd);
if (ret) {
/* Error reading the uncompressed data. */
if (out_fd->offset == begin_offset &&
* seeked to the end of the compressed resource, so
* don't issue a hard error; just keep the compressed
* resource instead. */
- WARNING("Recovered compressed blob of "
+ WARNING("Recovered compressed resource of "
"size %"PRIu64", continuing on.", blob->size);
return 0;
}
wimlib_assert(out_fd->offset - begin_offset == blob->size);
- if (out_fd->offset < end_offset &&
- 0 != ftruncate(out_fd->fd, out_fd->offset))
- {
- ERROR_WITH_ERRNO("Can't truncate output file to "
- "offset %"PRIu64, out_fd->offset);
- return WIMLIB_ERR_WRITE;
- }
+ /* We could ftruncate() the file to 'out_fd->offset' here, but there
+ * isn't much point. Usually we will only be truncating by a few bytes
+ * and will just overwrite the data immediately. */
blob->out_reshdr.size_in_wim = blob->size;
blob->out_reshdr.flags &= ~(WIM_RESHDR_FLAG_COMPRESSED |
* uncompressed data by decompressing the compressed data we wrote to
* the output file.
*/
- if ((blob->flags & WIM_RESHDR_FLAG_SOLID) &&
- (blob->out_reshdr.size_in_wim != blob->out_reshdr.uncompressed_size))
+ if (blob->blob_location == BLOB_IN_WIM &&
+ blob->size != blob->rdesc->uncompressed_size &&
+ blob->size != blob->out_reshdr.size_in_wim)
return false;
return true;
/* Starting to write a new blob in non-solid mode. */
if (ctx->write_resource_flags & WRITE_RESOURCE_FLAG_PIPABLE) {
- int additional_reshdr_flags = 0;
- if (ctx->compressor != NULL)
- additional_reshdr_flags |= WIM_RESHDR_FLAG_COMPRESSED;
-
- DEBUG("Writing pipable WIM blob header "
- "(offset=%"PRIu64")", ctx->out_fd->offset);
-
ret = write_pwm_blob_header(blob, ctx->out_fd,
- additional_reshdr_flags);
+ ctx->compressor != NULL);
if (ret)
return ret;
}
if (ret)
return ret;
- blob->out_reshdr.flags = filter_resource_flags(blob->flags);
+ blob->out_reshdr.flags = reshdr_flags_for_blob(blob);
if (ctx->compressor != NULL)
blob->out_reshdr.flags |= WIM_RESHDR_FLAG_COMPRESSED;
struct blob_descriptor *blob;
u64 out_offset_in_wim;
- DEBUG("Copying raw compressed data (size_in_wim=%"PRIu64", "
- "uncompressed_size=%"PRIu64")",
- in_rdesc->size_in_wim, in_rdesc->uncompressed_size);
-
/* Copy the raw data. */
cur_read_offset = in_rdesc->offset_in_wim;
end_read_offset = cur_read_offset + in_rdesc->size_in_wim;
}
static void
-remove_empty_blobs(struct list_head *blob_list)
+validate_blob_list(struct list_head *blob_list)
{
- struct blob_descriptor *blob, *tmp;
+ struct blob_descriptor *blob;
- list_for_each_entry_safe(blob, tmp, blob_list, write_blobs_list) {
+ list_for_each_entry(blob, blob_list, write_blobs_list) {
wimlib_assert(blob->will_be_in_output_wim);
- if (blob->size == 0) {
- list_del(&blob->write_blobs_list);
- blob->out_reshdr.offset_in_wim = 0;
- blob->out_reshdr.size_in_wim = 0;
- blob->out_reshdr.uncompressed_size = 0;
- blob->out_reshdr.flags = filter_resource_flags(blob->flags);
- }
+ wimlib_assert(blob->size != 0);
}
}
+static inline bool
+blob_is_in_file(const struct blob_descriptor *blob)
+{
+ return blob->blob_location == BLOB_IN_FILE_ON_DISK
+#ifdef __WIN32__
+ || blob->blob_location == BLOB_IN_WINNT_FILE_ON_DISK
+ || blob->blob_location == BLOB_WIN32_ENCRYPTED
+#endif
+ ;
+}
+
static void
init_done_with_file_info(struct list_head *blob_list)
{
list_for_each_entry(blob, blob_list, write_blobs_list) {
if (blob_is_in_file(blob)) {
- blob->file_inode->num_remaining_streams = 0;
+ blob->file_inode->i_num_remaining_streams = 0;
blob->may_send_done_with_file = 1;
} else {
blob->may_send_done_with_file = 0;
list_for_each_entry(blob, blob_list, write_blobs_list)
if (blob->may_send_done_with_file)
- blob->file_inode->num_remaining_streams++;
+ blob->file_inode->i_num_remaining_streams++;
}
/*
(WRITE_RESOURCE_FLAG_SOLID |
WRITE_RESOURCE_FLAG_PIPABLE));
- remove_empty_blobs(blob_list);
+ validate_blob_list(blob_list);
- if (list_empty(blob_list)) {
- DEBUG("No blobs to write.");
+ if (list_empty(blob_list))
return 0;
- }
/* If needed, set auxiliary information so that we can detect when the
* library has finished using each external file. */
out_chunk_size,
&raw_copy_blobs);
- DEBUG("Writing blob list "
- "(offset = %"PRIu64", write_resource_flags=0x%08x, "
- "out_ctype=%d, out_chunk_size=%u, num_threads=%u, "
- "total_bytes=%"PRIu64", num_bytes_to_compress=%"PRIu64")",
- out_fd->offset, write_resource_flags,
- out_ctype, out_chunk_size, num_threads,
- ctx.progress_data.progress.write_streams.total_bytes,
- ctx.num_bytes_to_compress);
-
- if (ctx.num_bytes_to_compress == 0) {
- DEBUG("No compression needed; skipping to raw copy!");
+ if (ctx.num_bytes_to_compress == 0)
goto out_write_raw_copy_resources;
- }
/* Unless uncompressed output was required, allocate a chunk_compressor
* to do compression. There are serial and parallel implementations of
else
ctx.progress_data.progress.write_streams.num_threads = 1;
- DEBUG("Actually using %u threads",
- ctx.progress_data.progress.write_streams.num_threads);
-
INIT_LIST_HEAD(&ctx.blobs_being_compressed);
INIT_LIST_HEAD(&ctx.blobs_in_solid_resource);
/* Read the list of blobs needing to be compressed, using the specified
* callbacks to execute processing of the data. */
- struct read_blob_list_callbacks cbs = {
- .begin_blob = write_blob_begin_read,
- .begin_blob_ctx = &ctx,
- .consume_chunk = write_blob_process_chunk,
- .consume_chunk_ctx = &ctx,
- .end_blob = write_blob_end_read,
- .end_blob_ctx = &ctx,
+ struct read_blob_callbacks cbs = {
+ .begin_blob = write_blob_begin_read,
+ .consume_chunk = write_blob_process_chunk,
+ .end_blob = write_blob_end_read,
+ .ctx = &ctx,
};
ret = read_blob_list(blob_list,
if (ret)
goto out_destroy_context;
- DEBUG("Ending solid resource: %lu %lu %lu.",
- reshdr.offset_in_wim,
- reshdr.size_in_wim,
- reshdr.uncompressed_size);
-
offset_in_res = 0;
list_for_each_entry(blob, &ctx.blobs_in_solid_resource, write_blobs_list) {
blob->out_reshdr.size_in_wim = blob->size;
- blob->out_reshdr.flags = filter_resource_flags(blob->flags);
- blob->out_reshdr.flags |= WIM_RESHDR_FLAG_SOLID;
+ blob->out_reshdr.flags = reshdr_flags_for_blob(blob) |
+ WIM_RESHDR_FLAG_SOLID;
blob->out_reshdr.uncompressed_size = 0;
blob->out_reshdr.offset_in_wim = offset_in_res;
blob->out_res_offset_in_wim = reshdr.offset_in_wim;
FREE(ctx.chunk_csizes);
if (ctx.compressor)
ctx.compressor->destroy(ctx.compressor);
- DEBUG("Done (ret=%d)", ret);
return ret;
}
-static int
-is_blob_in_solid_resource(struct blob_descriptor *blob, void *_ignore)
-{
- return blob_is_in_solid_wim_resource(blob);
-}
-
-static bool
-wim_has_solid_resources(WIMStruct *wim)
-{
- return for_blob_in_table(wim->blob_table, is_blob_in_solid_resource, NULL);
-}
static int
-wim_write_blob_list(WIMStruct *wim,
- struct list_head *blob_list,
- int write_flags,
- unsigned num_threads,
- struct filter_context *filter_ctx)
+write_file_data_blobs(WIMStruct *wim,
+ struct list_head *blob_list,
+ int write_flags,
+ unsigned num_threads,
+ struct filter_context *filter_ctx)
{
int out_ctype;
u32 out_chunk_size;
write_resource_flags = write_flags_to_resource_flags(write_flags);
- /* wimlib v1.7.0: create a solid WIM file by default if the WIM version
- * has been set to WIM_VERSION_SOLID and at least one blob in the WIM's
- * blob table is located in a solid resource (may be the same WIM, or a
- * different one in the case of export). */
- if (wim->hdr.wim_version == WIM_VERSION_SOLID &&
- wim_has_solid_resources(wim))
- {
- write_resource_flags |= WRITE_RESOURCE_FLAG_SOLID;
- }
-
if (write_resource_flags & WRITE_RESOURCE_FLAG_SOLID) {
out_chunk_size = wim->out_solid_chunk_size;
out_ctype = wim->out_solid_compression_type;
wim->progctx);
}
+/* Write the contents of the specified blob as a WIM resource. */
static int
write_wim_resource(struct blob_descriptor *blob,
struct filedes *out_fd,
NULL);
}
+/* Write the contents of the specified buffer as a WIM resource. */
int
-write_wim_resource_from_buffer(const void *buf, size_t buf_size,
- int reshdr_flags, struct filedes *out_fd,
+write_wim_resource_from_buffer(const void *buf,
+ size_t buf_size,
+ bool is_metadata,
+ struct filedes *out_fd,
int out_ctype,
u32 out_chunk_size,
struct wim_reshdr *out_reshdr,
- u8 *hash,
+ u8 *hash_ret,
int write_resource_flags)
{
int ret;
- struct blob_descriptor *blob;
-
- /* Set up a temporary blob descriptor to provide to
- * write_wim_resource(). */
-
- blob = new_blob_descriptor();
- if (blob == NULL)
- return WIMLIB_ERR_NOMEM;
-
- blob->blob_location = BLOB_IN_ATTACHED_BUFFER;
- blob->attached_buffer = (void*)buf;
- blob->size = buf_size;
- blob->flags = reshdr_flags;
+ struct blob_descriptor blob;
- if (write_resource_flags & WRITE_RESOURCE_FLAG_PIPABLE) {
- sha1_buffer(buf, buf_size, blob->hash);
- blob->unhashed = 0;
- } else {
- blob->unhashed = 1;
+ if (unlikely(buf_size == 0)) {
+ zero_reshdr(out_reshdr);
+ if (hash_ret)
+ copy_hash(hash_ret, zero_hash);
+ return 0;
}
- ret = write_wim_resource(blob, out_fd, out_ctype, out_chunk_size,
+ blob_set_is_located_in_attached_buffer(&blob, (void *)buf, buf_size);
+ sha1_buffer(buf, buf_size, blob.hash);
+ blob.unhashed = 0;
+ blob.is_metadata = is_metadata;
+
+ ret = write_wim_resource(&blob, out_fd, out_ctype, out_chunk_size,
write_resource_flags);
if (ret)
- goto out_free_blob;
+ return ret;
- copy_reshdr(out_reshdr, &blob->out_reshdr);
+ copy_reshdr(out_reshdr, &blob.out_reshdr);
- if (hash)
- copy_hash(hash, blob->hash);
- ret = 0;
-out_free_blob:
- blob->blob_location = BLOB_NONEXISTENT;
- free_blob_descriptor(blob);
- return ret;
+ if (hash_ret)
+ copy_hash(hash_ret, blob.hash);
+ return 0;
}
struct blob_size_table {
struct blob_size_table *tab = _tab;
size_t pos;
struct blob_descriptor *same_size_blob;
- struct hlist_node *tmp;
pos = hash_u64(blob->size) % tab->capacity;
blob->unique_size = 1;
- hlist_for_each_entry(same_size_blob, tmp, &tab->array[pos], hash_list_2) {
+ hlist_for_each_entry(same_size_blob, &tab->array[pos], hash_list_2) {
if (same_size_blob->size == blob->size) {
blob->unique_size = 0;
same_size_blob->unique_size = 0;
for (unsigned i = 0; i < inode->i_num_streams; i++) {
struct blob_descriptor *blob;
+ const u8 *hash;
blob = stream_blob(&inode->i_streams[i], table);
- if (blob)
+ if (blob) {
reference_blob_for_write(blob, blob_list, inode->i_nlink);
- else if (!is_zero_hash(stream_hash(&inode->i_streams[i])))
- return WIMLIB_ERR_RESOURCE_NOT_FOUND;
+ } else {
+ hash = stream_hash(&inode->i_streams[i]);
+ if (!is_zero_hash(hash))
+ return blob_not_found_error(inode, hash);
+ }
}
return 0;
}
}
static int
-write_file_blobs(WIMStruct *wim, int image, int write_flags,
- unsigned num_threads,
- struct list_head *blob_list_override,
- struct list_head *blob_table_list_ret)
+write_file_data(WIMStruct *wim, int image, int write_flags,
+ unsigned num_threads,
+ struct list_head *blob_list_override,
+ struct list_head *blob_table_list_ret)
{
int ret;
struct list_head _blob_list;
}
}
- return wim_write_blob_list(wim,
- blob_list,
- write_flags,
- num_threads,
- filter_ctx);
+ return write_file_data_blobs(wim,
+ blob_list,
+ write_flags,
+ num_threads,
+ filter_ctx);
}
static int
-write_metadata_blobs(WIMStruct *wim, int image, int write_flags)
+write_metadata_resources(WIMStruct *wim, int image, int write_flags)
{
int ret;
int start_image;
int end_image;
int write_resource_flags;
- if (write_flags & WIMLIB_WRITE_FLAG_NO_METADATA) {
- DEBUG("Not writing any metadata resources.");
+ if (write_flags & WIMLIB_WRITE_FLAG_NO_METADATA)
return 0;
- }
write_resource_flags = write_flags_to_resource_flags(write_flags);
write_resource_flags &= ~WRITE_RESOURCE_FLAG_SOLID;
- DEBUG("Writing metadata resources (offset=%"PRIu64")",
- wim->out_fd.offset);
-
ret = call_progress(wim->progfunc,
WIMLIB_PROGRESS_MSG_WRITE_METADATA_BEGIN,
NULL, wim->progctx);
* the original (or was newly added). Otherwise just copy the
* existing one. */
if (imd->modified) {
- DEBUG("Image %u was modified; building and writing new "
- "metadata resource", i);
ret = write_metadata_resource(wim, i,
write_resource_flags);
} else if (write_flags & WIMLIB_WRITE_FLAG_OVERWRITE) {
- DEBUG("Image %u was not modified; re-using existing "
- "metadata resource.", i);
blob_set_out_reshdr_for_reuse(imd->metadata_blob);
ret = 0;
} else {
- DEBUG("Image %u was not modified; copying existing "
- "metadata resource.", i);
ret = write_wim_resource(imd->metadata_blob,
&wim->out_fd,
wim->out_compression_type,
static int
open_wim_writable(WIMStruct *wim, const tchar *path, int open_flags)
{
- int raw_fd;
- DEBUG("Opening \"%"TS"\" for writing.", path);
-
- raw_fd = topen(path, open_flags | O_BINARY, 0644);
+ int raw_fd = topen(path, open_flags | O_BINARY, 0644);
if (raw_fd < 0) {
ERROR_WITH_ERRNO("Failed to open \"%"TS"\" for writing", path);
return WIMLIB_ERR_OPEN;
{
int ret = 0;
- if (!(write_flags & WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR)) {
- DEBUG("Closing WIM file.");
+ if (!(write_flags & WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR))
if (filedes_valid(&wim->out_fd))
if (filedes_close(&wim->out_fd))
ret = WIMLIB_ERR_WRITE;
- }
filedes_invalidate(&wim->out_fd);
return ret;
}
static int
write_blob_table(WIMStruct *wim, int image, int write_flags,
- struct wim_reshdr *out_reshdr,
struct list_head *blob_table_list)
{
int ret;
return write_blob_table_from_blob_list(blob_table_list,
&wim->out_fd,
- wim->hdr.part_number,
- out_reshdr,
+ wim->out_hdr.part_number,
+ &wim->out_hdr.blob_table_reshdr,
write_flags_to_resource_flags(write_flags));
}
/*
- * finish_write():
- *
* Finish writing a WIM file: write the blob table, xml data, and integrity
- * table, then overwrite the WIM header. By default, closes the WIM file
- * descriptor (@wim->out_fd) if successful.
- *
- * write_flags is a bitwise OR of the following:
- *
- * (public) WIMLIB_WRITE_FLAG_CHECK_INTEGRITY:
- * Include an integrity table.
- *
- * (public) WIMLIB_WRITE_FLAG_FSYNC:
- * fsync() the output file before closing it.
- *
- * (public) WIMLIB_WRITE_FLAG_PIPABLE:
- * Writing a pipable WIM, possibly to a pipe; include pipable WIM
- * blob headers before the blob table and XML data, and also write
- * the WIM header at the end instead of seeking to the beginning.
- * Can't be combined with WIMLIB_WRITE_FLAG_CHECK_INTEGRITY.
- *
- * (private) WIMLIB_WRITE_FLAG_NO_BLOB_TABLE:
- * Don't write the blob table.
- *
- * (private) WIMLIB_WRITE_FLAG_CHECKPOINT_AFTER_XML:
- * After writing the XML data but before writing the integrity
- * table, write a temporary WIM header and flush the file
- * descriptor so that the WIM is less likely to become corrupted
- * upon abrupt program termination.
- * (private) WIMLIB_WRITE_FLAG_HEADER_AT_END:
- * Instead of overwriting the WIM header at the beginning of the
- * file, simply append it to the end of the file. (Used when
- * writing to pipe.)
- * (private) WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR:
- * Do not close the file descriptor @wim->out_fd on either success
- * on failure.
- * (private) WIMLIB_WRITE_FLAG_USE_EXISTING_TOTALBYTES:
- * Use the existing <TOTALBYTES> stored in the in-memory XML
- * information, rather than setting it to the offset of the XML
- * data being written.
- * (private) WIMLIB_WRITE_FLAG_OVERWRITE
- * The existing WIM file is being updated in-place. The entries
- * from its integrity table may be re-used.
+ * table, then overwrite the WIM header.
+ *
+ * The output file descriptor is closed on success, except when writing to a
+ * user-specified file descriptor (WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR set).
*/
static int
finish_write(WIMStruct *wim, int image, int write_flags,
struct list_head *blob_table_list)
{
- int ret;
- off_t hdr_offset;
int write_resource_flags;
off_t old_blob_table_end = 0;
+ struct integrity_table *old_integrity_table = NULL;
off_t new_blob_table_end;
u64 xml_totalbytes;
- struct integrity_table *old_integrity_table = NULL;
-
- DEBUG("image=%d, write_flags=%08x", image, write_flags);
+ int ret;
write_resource_flags = write_flags_to_resource_flags(write_flags);
* metadata resource labeled as the "boot metadata". This entry should
* be zeroed out if there is no bootable image (boot_idx 0). Otherwise,
* it should be a copy of the resource entry for the image that is
- * marked as bootable. This is not well documented... */
- if (wim->hdr.boot_idx == 0) {
- zero_reshdr(&wim->hdr.boot_metadata_reshdr);
+ * marked as bootable. */
+ if (wim->out_hdr.boot_idx == 0) {
+ zero_reshdr(&wim->out_hdr.boot_metadata_reshdr);
} else {
- copy_reshdr(&wim->hdr.boot_metadata_reshdr,
+ copy_reshdr(&wim->out_hdr.boot_metadata_reshdr,
&wim->image_metadata[
- wim->hdr.boot_idx - 1]->metadata_blob->out_reshdr);
+ wim->out_hdr.boot_idx - 1]->metadata_blob->out_reshdr);
}
/* If overwriting the WIM file containing an integrity table in-place,
&& wim_has_integrity_table(wim))
{
old_blob_table_end = wim->hdr.blob_table_reshdr.offset_in_wim +
- wim->hdr.blob_table_reshdr.size_in_wim;
+ wim->hdr.blob_table_reshdr.size_in_wim;
(void)read_integrity_table(wim,
old_blob_table_end - WIM_HEADER_DISK_SIZE,
&old_integrity_table);
* ignoring of the return value. */
}
- /* Write blob table. */
- if (!(write_flags & WIMLIB_WRITE_FLAG_NO_BLOB_TABLE)) {
+ /* Write blob table if needed. */
+ if (!(write_flags & WIMLIB_WRITE_FLAG_NO_NEW_BLOBS)) {
ret = write_blob_table(wim, image, write_flags,
- &wim->hdr.blob_table_reshdr,
blob_table_list);
if (ret) {
free_integrity_table(old_integrity_table);
if (write_flags & WIMLIB_WRITE_FLAG_USE_EXISTING_TOTALBYTES)
xml_totalbytes = WIM_TOTALBYTES_USE_EXISTING;
ret = write_wim_xml_data(wim, image, xml_totalbytes,
- &wim->hdr.xml_data_reshdr,
+ &wim->out_hdr.xml_data_reshdr,
write_resource_flags);
if (ret) {
free_integrity_table(old_integrity_table);
return ret;
}
- /* Write integrity table (optional). */
+ /* Write integrity table if needed. */
if (write_flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY) {
- if (write_flags & WIMLIB_WRITE_FLAG_CHECKPOINT_AFTER_XML) {
+ if (write_flags & WIMLIB_WRITE_FLAG_NO_NEW_BLOBS) {
+ /* The XML data we wrote may have overwritten part of
+ * the old integrity table, so while calculating the new
+ * integrity table we should temporarily update the WIM
+ * header to remove the integrity table reference. */
struct wim_header checkpoint_hdr;
- memcpy(&checkpoint_hdr, &wim->hdr, sizeof(struct wim_header));
+ memcpy(&checkpoint_hdr, &wim->out_hdr, sizeof(struct wim_header));
zero_reshdr(&checkpoint_hdr.integrity_table_reshdr);
checkpoint_hdr.flags |= WIM_HDR_FLAG_WRITE_IN_PROGRESS;
- ret = write_wim_header_at_offset(&checkpoint_hdr,
- &wim->out_fd, 0);
+ ret = write_wim_header(&checkpoint_hdr, &wim->out_fd, 0);
if (ret) {
free_integrity_table(old_integrity_table);
return ret;
}
}
- new_blob_table_end = wim->hdr.blob_table_reshdr.offset_in_wim +
- wim->hdr.blob_table_reshdr.size_in_wim;
+ new_blob_table_end = wim->out_hdr.blob_table_reshdr.offset_in_wim +
+ wim->out_hdr.blob_table_reshdr.size_in_wim;
ret = write_integrity_table(wim,
new_blob_table_end,
return ret;
} else {
/* No integrity table. */
- zero_reshdr(&wim->hdr.integrity_table_reshdr);
+ zero_reshdr(&wim->out_hdr.integrity_table_reshdr);
}
/* Now that all information in the WIM header has been determined, the
* preliminary header written earlier can be overwritten, the header of
* the existing WIM file can be overwritten, or the final header can be
* written to the end of the pipable WIM. */
- wim->hdr.flags &= ~WIM_HDR_FLAG_WRITE_IN_PROGRESS;
- hdr_offset = 0;
- if (write_flags & WIMLIB_WRITE_FLAG_HEADER_AT_END)
- hdr_offset = wim->out_fd.offset;
- DEBUG("Writing new header @ %"PRIu64".", hdr_offset);
- ret = write_wim_header_at_offset(&wim->hdr, &wim->out_fd, hdr_offset);
+ wim->out_hdr.flags &= ~WIM_HDR_FLAG_WRITE_IN_PROGRESS;
+ if (write_flags & WIMLIB_WRITE_FLAG_PIPABLE)
+ ret = write_wim_header(&wim->out_hdr, &wim->out_fd, wim->out_fd.offset);
+ else
+ ret = write_wim_header(&wim->out_hdr, &wim->out_fd, 0);
if (ret)
return ret;
* operation has been written to disk, but the new file data has not.
*/
if (write_flags & WIMLIB_WRITE_FLAG_FSYNC) {
- DEBUG("Syncing WIM file.");
if (fsync(wim->out_fd.fd)) {
ERROR_WITH_ERRNO("Error syncing data to WIM file");
return WIMLIB_ERR_WRITE;
* reading the WIM from a pipe. This copy of the XML data is ignored if the
* WIM is read from a seekable file (not a pipe).
*
+ * - Solid resources are not allowed. Each blob is always stored in its own
+ * resource.
+ *
* - The format of resources, or blobs, has been modified to allow them to be
* used before the "blob table" has been read. Each blob is prefixed with a
* `struct pwm_blob_hdr' that is basically an abbreviated form of `struct
WARNING("Creating a pipable WIM, which will "
"be incompatible\n"
- " with Microsoft's software (wimgapi/imagex/Dism).");
+ " with Microsoft's software (WIMGAPI/ImageX/DISM).");
/* At this point, the header at the beginning of the file has already
* been written. */
/* For efficiency, when wimlib adds an image to the WIM with
- * wimlib_add_image(), the SHA-1 message digests of files is not
+ * wimlib_add_image(), the SHA-1 message digests of files are not
* calculated; instead, they are calculated while the files are being
* written. However, this does not work when writing a pipable WIM,
* since when writing a blob to a pipable WIM, its SHA-1 message digest
/* Write metadata resources for the image(s) being included in the
* output WIM. */
- ret = write_metadata_blobs(wim, image, write_flags);
+ ret = write_metadata_resources(wim, image, write_flags);
if (ret)
return ret;
- /* Write blobs needed for the image(s) being included in the output WIM,
- * or blobs needed for the split WIM part. */
- return write_file_blobs(wim, image, write_flags,
- num_threads, blob_list_override,
- blob_table_list_ret);
+ /* Write file data needed for the image(s) being included in the output
+ * WIM, or file data needed for the split WIM part. */
+ return write_file_data(wim, image, write_flags,
+ num_threads, blob_list_override,
+ blob_table_list_ret);
/* The blob table, XML data, and header at end are handled by
* finish_write(). */
}
+static bool
+should_default_to_solid_compression(WIMStruct *wim, int write_flags)
+{
+ return wim->out_hdr.wim_version == WIM_VERSION_SOLID &&
+ !(write_flags & (WIMLIB_WRITE_FLAG_SOLID |
+ WIMLIB_WRITE_FLAG_PIPABLE)) &&
+ wim_has_solid_resources(wim);
+}
+
/* Write a standalone WIM or split WIM (SWM) part to a new file or to a file
* descriptor. */
int
const u8 *guid)
{
int ret;
- struct wim_header hdr_save;
struct list_head blob_table_list;
- if (total_parts == 1)
- DEBUG("Writing standalone WIM.");
- else
- DEBUG("Writing split WIM part %u/%u", part_number, total_parts);
- if (image == WIMLIB_ALL_IMAGES)
- DEBUG("Including all images.");
- else
- DEBUG("Including image %d only.", image);
- if (write_flags & WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR)
- DEBUG("File descriptor: %d", *(const int*)path_or_fd);
- else
- DEBUG("Path: \"%"TS"\"", (const tchar*)path_or_fd);
- DEBUG("Write flags: 0x%08x", write_flags);
-
- if (write_flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY)
- DEBUG("\tCHECK_INTEGRITY");
-
- if (write_flags & WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY)
- DEBUG("\tNO_CHECK_INTEGRITY");
-
- if (write_flags & WIMLIB_WRITE_FLAG_PIPABLE)
- DEBUG("\tPIPABLE");
-
- if (write_flags & WIMLIB_WRITE_FLAG_NOT_PIPABLE)
- DEBUG("\tNOT_PIPABLE");
-
- if (write_flags & WIMLIB_WRITE_FLAG_RECOMPRESS)
- DEBUG("\tRECOMPRESS");
-
- if (write_flags & WIMLIB_WRITE_FLAG_FSYNC)
- DEBUG("\tFSYNC");
-
- if (write_flags & WIMLIB_WRITE_FLAG_REBUILD)
- DEBUG("\tREBUILD");
-
- if (write_flags & WIMLIB_WRITE_FLAG_SOFT_DELETE)
- DEBUG("\tSOFT_DELETE");
-
- if (write_flags & WIMLIB_WRITE_FLAG_IGNORE_READONLY_FLAG)
- DEBUG("\tIGNORE_READONLY_FLAG");
-
- if (write_flags & WIMLIB_WRITE_FLAG_SKIP_EXTERNAL_WIMS)
- DEBUG("\tSKIP_EXTERNAL_WIMS");
-
- if (write_flags & WIMLIB_WRITE_FLAG_STREAMS_OK)
- DEBUG("\tSTREAMS_OK");
-
- if (write_flags & WIMLIB_WRITE_FLAG_RETAIN_GUID)
- DEBUG("\tRETAIN_GUID");
-
- if (write_flags & WIMLIB_WRITE_FLAG_SOLID)
- DEBUG("\tSOLID");
-
- if (write_flags & WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR)
- DEBUG("\tFILE_DESCRIPTOR");
-
- if (write_flags & WIMLIB_WRITE_FLAG_NO_METADATA)
- DEBUG("\tNO_METADATA");
-
- if (write_flags & WIMLIB_WRITE_FLAG_USE_EXISTING_TOTALBYTES)
- DEBUG("\tUSE_EXISTING_TOTALBYTES");
-
- if (num_threads == 0)
- DEBUG("Number of threads: autodetect");
- else
- DEBUG("Number of threads: %u", num_threads);
- DEBUG("Progress function: %s", (wim->progfunc ? "yes" : "no"));
- DEBUG("Blob list: %s", (blob_list_override ? "specified" : "autodetect"));
- DEBUG("GUID: %s", (write_flags &
- WIMLIB_WRITE_FLAG_RETAIN_GUID) ? "retain"
- : guid ? "explicit" : "generate new");
-
/* Internally, this is always called with a valid part number and total
* parts. */
wimlib_assert(total_parts >= 1);
WIMLIB_WRITE_FLAG_NOT_PIPABLE))
return WIMLIB_ERR_INVALID_PARAM;
- /* Save previous header, then start initializing the new one. */
- memcpy(&hdr_save, &wim->hdr, sizeof(struct wim_header));
+ /* Include an integrity table by default if no preference was given and
+ * the WIM already had an integrity table. */
+ if (!(write_flags & (WIMLIB_WRITE_FLAG_CHECK_INTEGRITY |
+ WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY))) {
+ if (wim_has_integrity_table(wim))
+ write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
+ }
- /* Set default integrity, pipable, and solid flags. */
+ /* Write a pipable WIM by default if no preference was given and the WIM
+ * was already pipable. */
if (!(write_flags & (WIMLIB_WRITE_FLAG_PIPABLE |
- WIMLIB_WRITE_FLAG_NOT_PIPABLE)))
- if (wim_is_pipable(wim)) {
- DEBUG("WIM is pipable; default to PIPABLE.");
+ WIMLIB_WRITE_FLAG_NOT_PIPABLE))) {
+ if (wim_is_pipable(wim))
write_flags |= WIMLIB_WRITE_FLAG_PIPABLE;
- }
-
- if (!(write_flags & (WIMLIB_WRITE_FLAG_CHECK_INTEGRITY |
- WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY)))
- if (wim_has_integrity_table(wim)) {
- DEBUG("Integrity table present; default to CHECK_INTEGRITY.");
- write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
- }
+ }
if ((write_flags & (WIMLIB_WRITE_FLAG_PIPABLE |
WIMLIB_WRITE_FLAG_SOLID))
== (WIMLIB_WRITE_FLAG_PIPABLE |
WIMLIB_WRITE_FLAG_SOLID))
{
- ERROR("Cannot specify both PIPABLE and SOLID!");
+ ERROR("Solid compression is unsupported in pipable WIMs");
return WIMLIB_ERR_INVALID_PARAM;
}
- /* Set appropriate magic number. */
+ /* Start initializing the new file header. */
+ memset(&wim->out_hdr, 0, sizeof(wim->out_hdr));
+
+ /* Set the magic number. */
if (write_flags & WIMLIB_WRITE_FLAG_PIPABLE)
- wim->hdr.magic = PWM_MAGIC;
+ wim->out_hdr.magic = PWM_MAGIC;
else
- wim->hdr.magic = WIM_MAGIC;
+ wim->out_hdr.magic = WIM_MAGIC;
- /* Set appropriate version number. */
+ /* Set the version number. */
if ((write_flags & WIMLIB_WRITE_FLAG_SOLID) ||
wim->out_compression_type == WIMLIB_COMPRESSION_TYPE_LZMS)
- wim->hdr.wim_version = WIM_VERSION_SOLID;
+ wim->out_hdr.wim_version = WIM_VERSION_SOLID;
else
- wim->hdr.wim_version = WIM_VERSION_DEFAULT;
+ wim->out_hdr.wim_version = WIM_VERSION_DEFAULT;
- /* Clear header flags that will be set automatically. */
- wim->hdr.flags &= ~(WIM_HDR_FLAG_METADATA_ONLY |
- WIM_HDR_FLAG_RESOURCE_ONLY |
- WIM_HDR_FLAG_SPANNED |
- WIM_HDR_FLAG_WRITE_IN_PROGRESS);
+ /* Default to solid compression if it is valid in the chosen WIM file
+ * format and the WIMStruct references any solid resources. This is
+ * useful when exporting an image from a solid WIM. */
+ if (should_default_to_solid_compression(wim, write_flags))
+ write_flags |= WIMLIB_WRITE_FLAG_SOLID;
- /* Set SPANNED header flag if writing part of a split WIM. */
+ /* Set the header flags. */
+ wim->out_hdr.flags = (wim->hdr.flags & (WIM_HDR_FLAG_RP_FIX |
+ WIM_HDR_FLAG_READONLY));
if (total_parts != 1)
- wim->hdr.flags |= WIM_HDR_FLAG_SPANNED;
-
- /* Set part number and total parts of split WIM. This will be 1 and 1
- * if the WIM is standalone. */
- wim->hdr.part_number = part_number;
- wim->hdr.total_parts = total_parts;
-
- /* Set compression type if different. */
- if (wim->compression_type != wim->out_compression_type) {
- ret = set_wim_hdr_cflags(wim->out_compression_type, &wim->hdr);
- wimlib_assert(ret == 0);
+ wim->out_hdr.flags |= WIM_HDR_FLAG_SPANNED;
+ if (wim->out_compression_type != WIMLIB_COMPRESSION_TYPE_NONE) {
+ wim->out_hdr.flags |= WIM_HDR_FLAG_COMPRESSION;
+ switch (wim->out_compression_type) {
+ case WIMLIB_COMPRESSION_TYPE_XPRESS:
+ wim->out_hdr.flags |= WIM_HDR_FLAG_COMPRESS_XPRESS;
+ break;
+ case WIMLIB_COMPRESSION_TYPE_LZX:
+ wim->out_hdr.flags |= WIM_HDR_FLAG_COMPRESS_LZX;
+ break;
+ case WIMLIB_COMPRESSION_TYPE_LZMS:
+ wim->out_hdr.flags |= WIM_HDR_FLAG_COMPRESS_LZMS;
+ break;
+ }
}
- /* Set chunk size if different. */
- wim->hdr.chunk_size = wim->out_chunk_size;
+ /* Set the chunk size. */
+ wim->out_hdr.chunk_size = wim->out_chunk_size;
- /* Set GUID. */
- if (!(write_flags & WIMLIB_WRITE_FLAG_RETAIN_GUID)) {
- if (guid)
- memcpy(wim->hdr.guid, guid, WIMLIB_GUID_LEN);
- else
- randomize_byte_array(wim->hdr.guid, WIMLIB_GUID_LEN);
- }
+ /* Set the GUID. */
+ if (write_flags & WIMLIB_WRITE_FLAG_RETAIN_GUID)
+ guid = wim->hdr.guid;
+ if (guid)
+ copy_guid(wim->out_hdr.guid, guid);
+ else
+ generate_guid(wim->out_hdr.guid);
- /* Clear references to resources that have not been written yet. */
- zero_reshdr(&wim->hdr.blob_table_reshdr);
- zero_reshdr(&wim->hdr.xml_data_reshdr);
- zero_reshdr(&wim->hdr.boot_metadata_reshdr);
- zero_reshdr(&wim->hdr.integrity_table_reshdr);
+ /* Set the part number and total parts. */
+ wim->out_hdr.part_number = part_number;
+ wim->out_hdr.total_parts = total_parts;
- /* Set image count and boot index correctly for single image writes. */
- if (image != WIMLIB_ALL_IMAGES) {
- wim->hdr.image_count = 1;
- if (wim->hdr.boot_idx == image)
- wim->hdr.boot_idx = 1;
- else
- wim->hdr.boot_idx = 0;
- }
+ /* Set the image count. */
+ if (image == WIMLIB_ALL_IMAGES)
+ wim->out_hdr.image_count = wim->hdr.image_count;
+ else
+ wim->out_hdr.image_count = 1;
- /* Split WIMs can't be bootable. */
- if (total_parts != 1)
- wim->hdr.boot_idx = 0;
+ /* Set the boot index. */
+ wim->out_hdr.boot_idx = 0;
+ if (total_parts == 1) {
+ if (image == WIMLIB_ALL_IMAGES)
+ wim->out_hdr.boot_idx = wim->hdr.boot_idx;
+ else if (image == wim->hdr.boot_idx)
+ wim->out_hdr.boot_idx = 1;
+ }
- /* Initialize output file descriptor. */
+ /* Set up the output file descriptor. */
if (write_flags & WIMLIB_WRITE_FLAG_FILE_DESCRIPTOR) {
- /* File descriptor was explicitly provided. Return error if
- * file descriptor is not seekable, unless writing a pipable WIM
- * was requested. */
- wim->out_fd.fd = *(const int*)path_or_fd;
- wim->out_fd.offset = 0;
+ /* File descriptor was explicitly provided. */
+ filedes_init(&wim->out_fd, *(const int *)path_or_fd);
if (!filedes_is_seekable(&wim->out_fd)) {
+ /* The file descriptor is a pipe. */
ret = WIMLIB_ERR_INVALID_PARAM;
if (!(write_flags & WIMLIB_WRITE_FLAG_PIPABLE))
- goto out_restore_hdr;
+ goto out_cleanup;
if (write_flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY) {
ERROR("Can't include integrity check when "
"writing pipable WIM to pipe!");
- goto out_restore_hdr;
+ goto out_cleanup;
}
}
-
} else {
/* Filename of WIM to write was provided; open file descriptor
* to it. */
ret = open_wim_writable(wim, (const tchar*)path_or_fd,
O_TRUNC | O_CREAT | O_RDWR);
if (ret)
- goto out_restore_hdr;
+ goto out_cleanup;
}
/* Write initial header. This is merely a "dummy" header since it
- * doesn't have all the information yet, so it will be overwritten later
- * (unless writing a pipable WIM). */
+ * doesn't have resource entries filled in yet, so it will be
+ * overwritten later (unless writing a pipable WIM). */
if (!(write_flags & WIMLIB_WRITE_FLAG_PIPABLE))
- wim->hdr.flags |= WIM_HDR_FLAG_WRITE_IN_PROGRESS;
- ret = write_wim_header(&wim->hdr, &wim->out_fd);
- wim->hdr.flags &= ~WIM_HDR_FLAG_WRITE_IN_PROGRESS;
+ wim->out_hdr.flags |= WIM_HDR_FLAG_WRITE_IN_PROGRESS;
+ ret = write_wim_header(&wim->out_hdr, &wim->out_fd, wim->out_fd.offset);
+ wim->out_hdr.flags &= ~WIM_HDR_FLAG_WRITE_IN_PROGRESS;
if (ret)
- goto out_restore_hdr;
+ goto out_cleanup;
- /* Write metadata resources and blobs. */
+ /* Write file data and metadata resources. */
if (!(write_flags & WIMLIB_WRITE_FLAG_PIPABLE)) {
/* Default case: create a normal (non-pipable) WIM. */
- ret = write_file_blobs(wim, image, write_flags,
- num_threads,
- blob_list_override,
- &blob_table_list);
+ ret = write_file_data(wim, image, write_flags,
+ num_threads,
+ blob_list_override,
+ &blob_table_list);
if (ret)
- goto out_restore_hdr;
+ goto out_cleanup;
- ret = write_metadata_blobs(wim, image, write_flags);
+ ret = write_metadata_resources(wim, image, write_flags);
if (ret)
- goto out_restore_hdr;
+ goto out_cleanup;
} else {
/* Non-default case: create pipable WIM. */
ret = write_pipable_wim(wim, image, write_flags, num_threads,
blob_list_override,
&blob_table_list);
if (ret)
- goto out_restore_hdr;
- write_flags |= WIMLIB_WRITE_FLAG_HEADER_AT_END;
+ goto out_cleanup;
}
-
/* Write blob table, XML data, and (optional) integrity table. */
ret = finish_write(wim, image, write_flags, &blob_table_list);
-out_restore_hdr:
- memcpy(&wim->hdr, &hdr_save, sizeof(struct wim_header));
+out_cleanup:
(void)close_wim_writable(wim, write_flags);
- DEBUG("ret=%d", ret);
return ret;
}
* header. This operation is potentially unsafe if the program is abruptly
* terminated while the XML data or integrity table are being overwritten, but
* before the new header has been written. To partially alleviate this problem,
- * a special flag (WIMLIB_WRITE_FLAG_CHECKPOINT_AFTER_XML) is passed to
- * finish_write() to cause a temporary WIM header to be written after the XML
- * data has been written. This may prevent the WIM from becoming corrupted if
- * the program is terminated while the integrity table is being calculated (but
- * no guarantees, due to write re-ordering...).
+ * we write a temporary header after the XML data has been written. This may
+ * prevent the WIM from becoming corrupted if the program is terminated while
+ * the integrity table is being calculated (but no guarantees, due to write
+ * re-ordering...).
*
* If we are adding new blobs, including new file data as well as any metadata
* for any new images, then the blob table needs to be changed, and those blobs
int ret;
off_t old_wim_end;
u64 old_blob_table_end, old_xml_begin, old_xml_end;
- struct wim_header hdr_save;
struct list_head blob_list;
struct list_head blob_table_list;
struct filter_context filter_ctx;
- DEBUG("Overwriting `%"TS"' in-place", wim->filename);
-
- /* Save original header so it can be restored in case of error */
- memcpy(&hdr_save, &wim->hdr, sizeof(struct wim_header));
-
- /* Set default integrity flag. */
+ /* Include an integrity table by default if no preference was given and
+ * the WIM already had an integrity table. */
if (!(write_flags & (WIMLIB_WRITE_FLAG_CHECK_INTEGRITY |
WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY)))
if (wim_has_integrity_table(wim))
write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
- /* Set WIM version if writing solid resources. */
+ /* Start preparing the updated file header. */
+ memcpy(&wim->out_hdr, &wim->hdr, sizeof(wim->out_hdr));
+
+ /* If using solid compression, the version number must be set to
+ * WIM_VERSION_SOLID. */
if (write_flags & WIMLIB_WRITE_FLAG_SOLID)
- wim->hdr.wim_version = WIM_VERSION_SOLID;
+ wim->out_hdr.wim_version = WIM_VERSION_SOLID;
+
+ /* Default to solid compression if it is valid in the chosen WIM file
+ * format and the WIMStruct references any solid resources. This is
+ * useful when updating a solid WIM. */
+ if (should_default_to_solid_compression(wim, write_flags))
+ write_flags |= WIMLIB_WRITE_FLAG_SOLID;
/* Set additional flags for overwrite. */
write_flags |= WIMLIB_WRITE_FLAG_OVERWRITE |
old_xml_end = old_xml_begin + wim->hdr.xml_data_reshdr.size_in_wim;
old_blob_table_end = wim->hdr.blob_table_reshdr.offset_in_wim +
wim->hdr.blob_table_reshdr.size_in_wim;
- if (wim->hdr.integrity_table_reshdr.offset_in_wim != 0 &&
+ if (wim_has_integrity_table(wim) &&
wim->hdr.integrity_table_reshdr.offset_in_wim < old_xml_end) {
WARNING("Didn't expect the integrity table to be before the XML data");
ret = WIMLIB_ERR_RESOURCE_ORDER;
- goto out_restore_memory_hdr;
+ goto out;
}
if (old_blob_table_end > old_xml_begin) {
WARNING("Didn't expect the blob table to be after the XML data");
ret = WIMLIB_ERR_RESOURCE_ORDER;
- goto out_restore_memory_hdr;
+ goto out;
}
/* Set @old_wim_end, which indicates the point beyond which we don't
* shall write the new XML data and optional integrity table
* immediately after the blob table. Note that this may
* overwrite an existing integrity table. */
- DEBUG("Skipping writing blob table "
- "(no images modified or deleted)");
old_wim_end = old_blob_table_end;
- write_flags |= WIMLIB_WRITE_FLAG_NO_BLOB_TABLE |
- WIMLIB_WRITE_FLAG_CHECKPOINT_AFTER_XML;
- } else if (wim->hdr.integrity_table_reshdr.offset_in_wim != 0) {
+ write_flags |= WIMLIB_WRITE_FLAG_NO_NEW_BLOBS;
+ } else if (wim_has_integrity_table(wim)) {
/* Old WIM has an integrity table; begin writing new blobs after
* it. */
old_wim_end = wim->hdr.integrity_table_reshdr.offset_in_wim +
ret = check_resource_offsets(wim, old_wim_end);
if (ret)
- goto out_restore_memory_hdr;
+ goto out;
ret = prepare_blob_list_for_write(wim, WIMLIB_ALL_IMAGES, write_flags,
&blob_list, &blob_table_list,
&filter_ctx);
if (ret)
- goto out_restore_memory_hdr;
+ goto out;
+
+ if (write_flags & WIMLIB_WRITE_FLAG_NO_NEW_BLOBS)
+ wimlib_assert(list_empty(&blob_list));
ret = open_wim_writable(wim, wim->filename, O_RDWR);
if (ret)
- goto out_restore_memory_hdr;
+ goto out;
ret = lock_wim_for_append(wim);
if (ret)
/* Set WIM_HDR_FLAG_WRITE_IN_PROGRESS flag in header. */
wim->hdr.flags |= WIM_HDR_FLAG_WRITE_IN_PROGRESS;
ret = write_wim_header_flags(wim->hdr.flags, &wim->out_fd);
+ wim->hdr.flags &= ~WIM_HDR_FLAG_WRITE_IN_PROGRESS;
if (ret) {
ERROR_WITH_ERRNO("Error updating WIM header flags");
goto out_unlock_wim;
if (filedes_seek(&wim->out_fd, old_wim_end) == -1) {
ERROR_WITH_ERRNO("Can't seek to end of WIM");
ret = WIMLIB_ERR_WRITE;
- goto out_restore_physical_hdr;
+ goto out_restore_hdr;
}
- ret = wim_write_blob_list(wim, &blob_list, write_flags,
- num_threads, &filter_ctx);
+ ret = write_file_data_blobs(wim, &blob_list, write_flags,
+ num_threads, &filter_ctx);
if (ret)
goto out_truncate;
- ret = write_metadata_blobs(wim, WIMLIB_ALL_IMAGES, write_flags);
+ ret = write_metadata_resources(wim, WIMLIB_ALL_IMAGES, write_flags);
if (ret)
goto out_truncate;
return 0;
out_truncate:
- if (!(write_flags & WIMLIB_WRITE_FLAG_NO_BLOB_TABLE)) {
- WARNING("Truncating `%"TS"' to its original size (%"PRIu64" bytes)",
- wim->filename, old_wim_end);
+ if (!(write_flags & WIMLIB_WRITE_FLAG_NO_NEW_BLOBS)) {
+ WARNING("Truncating \"%"TS"\" to its original size "
+ "(%"PRIu64" bytes)", wim->filename, old_wim_end);
/* Return value of ftruncate() is ignored because this is
* already an error path. */
(void)ftruncate(wim->out_fd.fd, old_wim_end);
}
-out_restore_physical_hdr:
- (void)write_wim_header_flags(hdr_save.flags, &wim->out_fd);
+out_restore_hdr:
+ (void)write_wim_header_flags(wim->hdr.flags, &wim->out_fd);
out_unlock_wim:
unlock_wim_for_append(wim);
out_close_wim:
(void)close_wim_writable(wim, write_flags);
-out_restore_memory_hdr:
- memcpy(&wim->hdr, &hdr_save, sizeof(struct wim_header));
+out:
return ret;
}
size_t wim_name_len;
int ret;
- DEBUG("Overwriting `%"TS"' via a temporary file", wim->filename);
-
/* Write the WIM to a temporary file in the same directory as the
* original WIM. */
wim_name_len = tstrlen(wim->filename);
/* Rename the new WIM file to the original WIM file. Note: on Windows
* this actually calls win32_rename_replacement(), not _wrename(), so
* that removing the existing destination file can be handled. */
- DEBUG("Renaming `%"TS"' to `%"TS"'", tmpfile, wim->filename);
ret = trename(tmpfile, wim->filename);
if (ret) {
ERROR_WITH_ERRNO("Failed to rename `%"TS"' to `%"TS"'",