4 * Support for writing WIM files; write a WIM file, overwrite a WIM file, write
5 * compressed file resources, etc.
9 * Copyright (C) 2010 Carl Thijssen
10 * Copyright (C) 2012 Eric Biggers
12 * This file is part of wimlib, a library for working with WIM files.
14 * wimlib is free software; you can redistribute it and/or modify it under the
15 * terms of the GNU General Public License as published by the Free
16 * Software Foundation; either version 3 of the License, or (at your option)
19 * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
20 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
21 * A PARTICULAR PURPOSE. See the GNU General Public License for more
24 * You should have received a copy of the GNU General Public License
25 * along with wimlib; if not, see http://www.gnu.org/licenses/.
28 #include "wimlib_internal.h"
31 #include "lookup_table.h"
35 /* Reopens the FILE* for a WIM read-write. */
36 static int reopen_rw(WIMStruct *w)
40 if (fclose(w->fp) != 0)
41 ERROR_WITH_ERRNO("Failed to close the file `%s'", w->filename);
42 fp = fopen(w->filename, "r+b");
44 ERROR_WITH_ERRNO("Failed to open `%s' for reading and writing",
46 return WIMLIB_ERR_OPEN;
55 * Writes a WIM file to the original file that it was read from, overwriting it.
57 WIMLIBAPI int wimlib_overwrite(WIMStruct *w, int flags)
59 const char *wimfile_name;
64 return WIMLIB_ERR_INVALID_PARAM;
66 wimfile_name = w->filename;
68 DEBUG("Replacing WIM file `%s'.", wimfile_name);
71 return WIMLIB_ERR_NO_FILENAME;
73 /* Write the WIM to a temporary file. */
74 /* XXX should the temporary file be somewhere else? */
75 wim_name_len = strlen(wimfile_name);
76 char tmpfile[wim_name_len + 10];
77 memcpy(tmpfile, wimfile_name, wim_name_len);
78 randomize_char_array_with_alnum(tmpfile + wim_name_len, 9);
79 tmpfile[wim_name_len + 9] = '\0';
81 ret = wimlib_write(w, tmpfile, WIM_ALL_IMAGES, flags);
83 ERROR("Failed to write the WIM file `%s'", tmpfile);
87 DEBUG("Closing original WIM file.");
88 /* Close the original WIM file that was opened for reading. */
90 if (fclose(w->fp) != 0) {
91 WARNING("Failed to close the file `%s'", wimfile_name);
96 DEBUG("Renaming `%s' to `%s'", tmpfile, wimfile_name);
98 /* Rename the new file to the old file .*/
99 if (rename(tmpfile, wimfile_name) != 0) {
100 ERROR_WITH_ERRNO("Failed to rename `%s' to `%s'",
101 tmpfile, wimfile_name);
102 /* Remove temporary file. */
103 if (unlink(tmpfile) != 0)
104 ERROR_WITH_ERRNO("Failed to remove `%s'", tmpfile);
105 return WIMLIB_ERR_RENAME;
112 WIMLIBAPI int wimlib_overwrite_xml_and_header(WIMStruct *w, int flags)
116 u8 *integrity_table = NULL;
119 size_t bytes_written;
121 DEBUG("Overwriting XML and header of `%s', flags = %d",
124 return WIMLIB_ERR_NO_FILENAME;
132 /* The old integrity table is still OK, as the SHA1 message digests in
133 * the integrity table include neither the header nor the XML data.
134 * Save it for later if it exists and an integrity table was required.
136 if (flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY &&
137 w->hdr.integrity.offset != 0) {
138 DEBUG("Reading existing integrity table.");
139 integrity_table = MALLOC(w->hdr.integrity.size);
140 if (!integrity_table)
141 return WIMLIB_ERR_NOMEM;
143 ret = read_uncompressed_resource(fp, w->hdr.integrity.offset,
144 w->hdr.integrity.original_size,
148 DEBUG("Done reading existing integrity table.");
151 DEBUG("Overwriting XML data.");
152 /* Overwrite the XML data. */
153 if (fseeko(fp, w->hdr.xml_res_entry.offset, SEEK_SET) != 0) {
154 ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" "
155 "for XML data", w->hdr.xml_res_entry.offset);
156 ret = WIMLIB_ERR_WRITE;
159 ret = write_xml_data(w->wim_info, WIM_ALL_IMAGES, fp, 0);
163 DEBUG("Updating XML resource entry.");
164 /* Update the XML resource entry in the WIM header. */
165 xml_end = ftello(fp);
167 ret = WIMLIB_ERR_WRITE;
170 xml_size = xml_end - w->hdr.xml_res_entry.offset;
171 w->hdr.xml_res_entry.size = xml_size;
172 w->hdr.xml_res_entry.original_size = xml_size;
174 if (flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY) {
175 DEBUG("Writing integrity table.");
176 w->hdr.integrity.offset = xml_end;
177 if (integrity_table) {
178 /* The existing integrity table was saved. */
179 bytes_written = fwrite(integrity_table, 1,
180 w->hdr.integrity.size, fp);
181 if (bytes_written != w->hdr.integrity.size) {
182 ERROR_WITH_ERRNO("Failed to write integrity "
184 ret = WIMLIB_ERR_WRITE;
187 FREE(integrity_table);
189 /* There was no existing integrity table, so a new one
190 * must be calculated. */
191 ret = write_integrity_table(fp, WIM_HEADER_DISK_SIZE,
192 w->hdr.lookup_table_res_entry.offset +
193 w->hdr.lookup_table_res_entry.size,
194 flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS);
198 off_t integrity_size = ftello(fp) - xml_end;
199 w->hdr.integrity.size = integrity_size;
200 w->hdr.integrity.original_size = integrity_size;
201 w->hdr.integrity.flags = 0;
204 DEBUG("Truncating file to end of XML data.");
205 /* No integrity table to write. The file should be truncated
206 * because it's possible that the old file was longer (due to it
207 * including an integrity table, or due to its XML data being
209 if (fflush(fp) != 0) {
210 ERROR_WITH_ERRNO("Failed to flush stream for file `%s'",
212 return WIMLIB_ERR_WRITE;
214 if (ftruncate(fileno(fp), xml_end) != 0) {
215 ERROR_WITH_ERRNO("Failed to truncate `%s' to %"PRIu64" "
216 "bytes", w->filename, xml_end);
217 return WIMLIB_ERR_WRITE;
219 memset(&w->hdr.integrity, 0, sizeof(struct resource_entry));
222 DEBUG("Overwriting header.");
223 /* Overwrite the header. */
224 if (fseeko(fp, 0, SEEK_SET) != 0) {
225 ERROR_WITH_ERRNO("Failed to seek to beginning of `%s'",
227 return WIMLIB_ERR_WRITE;
230 ret = write_header(&w->hdr, fp);
234 DEBUG("Closing `%s'.", w->filename);
235 if (fclose(fp) != 0) {
236 ERROR_WITH_ERRNO("Failed to close `%s'", w->filename);
237 return WIMLIB_ERR_WRITE;
243 FREE(integrity_table);
248 /* Write the file resources for the current image. */
249 static int write_file_resources(WIMStruct *w)
252 DEBUG("Writing file resources for image %u.", w->current_image);
253 return for_dentry_in_tree(wim_root_dentry(w), write_dentry_resources, w);
256 /* Write the lookup table, xml data, and integrity table, then overwrite the WIM
259 * write_lt is zero iff the lookup table is not to be written; i.e. it is
260 * handled elsewhere. */
261 int finish_write(WIMStruct *w, int image, int flags, int write_lt)
263 off_t lookup_table_offset;
264 off_t xml_data_offset;
265 off_t lookup_table_size;
266 off_t integrity_offset;
269 off_t integrity_size;
271 struct wim_header hdr;
272 FILE *out = w->out_fp;
275 lookup_table_offset = ftello(out);
276 if (lookup_table_offset == -1)
277 return WIMLIB_ERR_WRITE;
279 DEBUG("Writing lookup table (offset %"PRIu64")", lookup_table_offset);
280 /* Write the lookup table. */
281 ret = write_lookup_table(w->lookup_table, out);
287 xml_data_offset = ftello(out);
288 if (xml_data_offset == -1)
289 return WIMLIB_ERR_WRITE;
290 DEBUG("Writing XML data (offset %"PRIu64")", xml_data_offset);
292 /* @hdr will be the header for the new WIM. First copy all the data
293 * from the header in the WIMStruct; then set all the fields that may
294 * have changed, including the resource entries, boot index, and image
296 memcpy(&hdr, &w->hdr, sizeof(struct wim_header));
298 lookup_table_size = xml_data_offset - lookup_table_offset;
299 hdr.lookup_table_res_entry.offset = lookup_table_offset;
300 hdr.lookup_table_res_entry.size = lookup_table_size;
302 hdr.lookup_table_res_entry.original_size = hdr.lookup_table_res_entry.size;
303 hdr.lookup_table_res_entry.flags = WIM_RESHDR_FLAG_METADATA;
305 ret = write_xml_data(w->wim_info, image, out,
306 write_lt ? 0 : wim_info_get_total_bytes(w->wim_info));
310 integrity_offset = ftello(out);
311 if (integrity_offset == -1)
312 return WIMLIB_ERR_WRITE;
313 xml_data_size = integrity_offset - xml_data_offset;
315 hdr.xml_res_entry.offset = xml_data_offset;
316 hdr.xml_res_entry.size = xml_data_size;
317 hdr.xml_res_entry.original_size = xml_data_size;
318 hdr.xml_res_entry.flags = 0;
320 if (flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY) {
321 ret = write_integrity_table(out, WIM_HEADER_DISK_SIZE,
323 flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS);
326 end_offset = ftello(out);
327 if (end_offset == -1)
328 return WIMLIB_ERR_WRITE;
329 integrity_size = end_offset - integrity_offset;
330 hdr.integrity.offset = integrity_offset;
331 hdr.integrity.size = integrity_size;
332 hdr.integrity.original_size = integrity_size;
334 hdr.integrity.offset = 0;
335 hdr.integrity.size = 0;
336 hdr.integrity.original_size = 0;
338 hdr.integrity.flags = 0;
340 DEBUG("Updating WIM header.");
343 * In the WIM header, there is room for the resource entry for a
344 * metadata resource labeled as the "boot metadata". This entry should
345 * be zeroed out if there is no bootable image (boot_idx 0). Otherwise,
346 * it should be a copy of the resource entry for the image that is
347 * marked as bootable. This is not well documented...
349 if (hdr.boot_idx == 0 || !w->image_metadata
350 || (image != WIM_ALL_IMAGES && image != hdr.boot_idx)) {
351 memset(&hdr.boot_metadata_res_entry, 0,
352 sizeof(struct resource_entry));
354 memcpy(&hdr.boot_metadata_res_entry,
356 hdr.boot_idx - 1].metadata_lte->output_resource_entry,
357 sizeof(struct resource_entry));
360 /* Set image count and boot index correctly for single image writes */
361 if (image != WIM_ALL_IMAGES) {
363 if (hdr.boot_idx == image)
370 if (fseeko(out, 0, SEEK_SET) != 0)
371 return WIMLIB_ERR_WRITE;
373 return write_header(&hdr, out);
376 /* Open file stream and write dummy header for WIM. */
377 int begin_write(WIMStruct *w, const char *path, int flags)
380 DEBUG("Opening `%s' for new WIM", path);
382 /* checking the integrity requires going back over the file to read it.
384 * (It also would be possible to keep a running sha1sum as the file
385 * as written-- this would be faster, but a bit more complicated) */
386 if (flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY)
391 w->out_fp = fopen(path, mode);
393 ERROR_WITH_ERRNO("Failed to open the file `%s' for writing",
395 return WIMLIB_ERR_OPEN;
398 /* Write dummy header. It will be overwritten later. */
399 return write_header(&w->hdr, w->out_fp);
402 /* Writes the WIM to a file. */
403 WIMLIBAPI int wimlib_write(WIMStruct *w, const char *path, int image, int flags)
408 return WIMLIB_ERR_INVALID_PARAM;
410 if (image != WIM_ALL_IMAGES &&
411 (image < 1 || image > w->hdr.image_count))
412 return WIMLIB_ERR_INVALID_IMAGE;
415 if (w->hdr.total_parts != 1) {
416 ERROR("Cannot call wimlib_write() on part of a split WIM");
417 return WIMLIB_ERR_SPLIT_UNSUPPORTED;
420 if (image == WIM_ALL_IMAGES)
421 DEBUG("Writing all images to `%s'.", path);
423 DEBUG("Writing image %d to `%s'.", image, path);
425 ret = begin_write(w, path, flags);
429 for_lookup_table_entry(w->lookup_table, zero_out_refcnts, NULL);
431 w->write_flags = flags;
433 ret = for_image(w, image, write_file_resources);
435 ERROR("Failed to write WIM file resources to `%s'", path);
439 ret = for_image(w, image, write_metadata_resource);
442 ERROR("Failed to write WIM image metadata to `%s'", path);
446 ret = finish_write(w, image, flags, 1);
449 DEBUG("Closing output file.");
450 if (w->out_fp != NULL) {
451 if (fclose(w->out_fp) != 0) {
452 ERROR_WITH_ERRNO("Failed to close the file `%s'", path);
453 ret = WIMLIB_ERR_WRITE;