wimlib.net Git - wimlib/blob - src/write.c

   1 /*
   2  * write.c
   3  *
   4  * Support for writing WIM files; write a WIM file, overwrite a WIM file, write
   5  * compressed file resources, etc.
   6  */
   7
   8 /*
   9  * Copyright (C) 2010 Carl Thijssen
  10  * Copyright (C) 2012 Eric Biggers
  11  *
  12  * This file is part of wimlib, a library for working with WIM files.
  13  *
  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)
  17  * any later version.
  18  *
  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
  22  * details.
  23  *
  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/.
  26  */
  27
  28 #include "wimlib_internal.h"
  29 #include "io.h"
  30 #include "dentry.h"
  31 #include "lookup_table.h"
  32 #include "xml.h"
  33 #include <unistd.h>
  34
  35 /* Reopens the FILE* for a WIM read-write. */
  36 static int reopen_rw(WIMStruct *w)
  37 {
  38         FILE *fp;
  39
  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");
  43         if (!fp) {
  44                 ERROR_WITH_ERRNO("Failed to open `%s' for reading and writing",
  45                                  w->filename);
  46                 return WIMLIB_ERR_OPEN;
  47         }
  48         w->fp = fp;
  49         return 0;
  50 }
  51
  52
  53
  54 /*
  55  * Writes a WIM file to the original file that it was read from, overwriting it.
  56  */
  57 WIMLIBAPI int wimlib_overwrite(WIMStruct *w, int flags)
  58 {
  59         const char *wimfile_name;
  60         size_t wim_name_len;
  61         int ret;
  62
  63         if (!w)
  64                 return WIMLIB_ERR_INVALID_PARAM;
  65
  66         wimfile_name = w->filename;
  67
  68         DEBUG("Replacing WIM file `%s'.", wimfile_name);
  69
  70         if (!wimfile_name)
  71                 return WIMLIB_ERR_NO_FILENAME;
  72
  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';
  80
  81         ret = wimlib_write(w, tmpfile, WIM_ALL_IMAGES, flags);
  82         if (ret != 0) {
  83                 ERROR("Failed to write the WIM file `%s'", tmpfile);
  84                 return ret;
  85         }
  86
  87         DEBUG("Closing original WIM file.");
  88         /* Close the original WIM file that was opened for reading. */
  89         if (w->fp) {
  90                 if (fclose(w->fp) != 0) {
  91                         WARNING("Failed to close the file `%s'", wimfile_name);
  92                 }
  93                 w->fp = NULL;
  94         }
  95
  96         DEBUG("Renaming `%s' to `%s'", tmpfile, wimfile_name);
  97
  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;
 106         }
 107
 108         return 0;
 109 }
 110
 111
 112 WIMLIBAPI int wimlib_overwrite_xml_and_header(WIMStruct *w, int flags)
 113 {
 114         int ret;
 115         FILE *fp;
 116         u8 *integrity_table = NULL;
 117         off_t xml_end;
 118         off_t xml_size;
 119         size_t bytes_written;
 120
 121         DEBUG("Overwriting XML and header of `%s', flags = %d",
 122               w->filename, flags);
 123         if (!w->filename)
 124                 return WIMLIB_ERR_NO_FILENAME;
 125
 126         ret = reopen_rw(w);
 127         if (ret != 0)
 128                 return ret;
 129
 130         fp = w->fp;
 131
 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.
 135          * */
 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;
 142
 143                 ret = read_uncompressed_resource(fp, w->hdr.integrity.offset,
 144                                                  w->hdr.integrity.original_size,
 145                                                  integrity_table);
 146                 if (ret != 0)
 147                         goto err;
 148                 DEBUG("Done reading existing integrity table.");
 149         }
 150
 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;
 157                 goto err;
 158         }
 159         ret = write_xml_data(w->wim_info, WIM_ALL_IMAGES, fp, 0);
 160         if (ret != 0)
 161                 goto err;
 162
 163         DEBUG("Updating XML resource entry.");
 164         /* Update the XML resource entry in the WIM header. */
 165         xml_end = ftello(fp);
 166         if (xml_end == -1) {
 167                 ret = WIMLIB_ERR_WRITE;
 168                 goto err;
 169         }
 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;
 173
 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 "
 183                                                  "table");
 184                                 ret = WIMLIB_ERR_WRITE;
 185                                 goto err;
 186                         }
 187                         FREE(integrity_table);
 188                 } else {
 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);
 195                         if (ret != 0)
 196                                 goto err;
 197
 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;
 202                 }
 203         } else {
 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
 208                  * longer) */
 209                 if (fflush(fp) != 0) {
 210                         ERROR_WITH_ERRNO("Failed to flush stream for file `%s'",
 211                                          w->filename);
 212                         return WIMLIB_ERR_WRITE;
 213                 }
 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;
 218                 }
 219                 memset(&w->hdr.integrity, 0, sizeof(struct resource_entry));
 220         }
 221
 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'",
 226                                  w->filename);
 227                 return WIMLIB_ERR_WRITE;
 228         }
 229
 230         ret = write_header(&w->hdr, fp);
 231         if (ret != 0)
 232                 return ret;
 233
 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;
 238         }
 239         w->fp = NULL;
 240         DEBUG("Done.");
 241         return 0;
 242 err:
 243         FREE(integrity_table);
 244         return ret;
 245 }
 246
 247
 248 /* Write the file resources for the current image. */
 249 static int write_file_resources(WIMStruct *w)
 250 {
 251
 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);
 254 }
 255
 256 /* Write the lookup table, xml data, and integrity table, then overwrite the WIM
 257  * header.
 258  *
 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)
 262 {
 263         off_t lookup_table_offset;
 264         off_t xml_data_offset;
 265         off_t lookup_table_size;
 266         off_t integrity_offset;
 267         off_t xml_data_size;
 268         off_t end_offset;
 269         off_t integrity_size;
 270         int ret;
 271         struct wim_header hdr;
 272         FILE *out = w->out_fp;
 273
 274         if (write_lt) {
 275                 lookup_table_offset = ftello(out);
 276                 if (lookup_table_offset == -1)
 277                         return WIMLIB_ERR_WRITE;
 278
 279                 DEBUG("Writing lookup table (offset %"PRIu64")", lookup_table_offset);
 280                 /* Write the lookup table. */
 281                 ret = write_lookup_table(w->lookup_table, out);
 282                 if (ret != 0)
 283                         return ret;
 284         }
 285
 286
 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);
 291
 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
 295          * count.  */
 296         memcpy(&hdr, &w->hdr, sizeof(struct wim_header));
 297         if (write_lt) {
 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;
 301         }
 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;
 304
 305         ret = write_xml_data(w->wim_info, image, out,
 306                              write_lt ? 0 : wim_info_get_total_bytes(w->wim_info));
 307         if (ret != 0)
 308                 return ret;
 309
 310         integrity_offset = ftello(out);
 311         if (integrity_offset == -1)
 312                 return WIMLIB_ERR_WRITE;
 313         xml_data_size = integrity_offset - xml_data_offset;
 314
 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;
 319
 320         if (flags & WIMLIB_WRITE_FLAG_CHECK_INTEGRITY) {
 321                 ret = write_integrity_table(out, WIM_HEADER_DISK_SIZE,
 322                                             xml_data_offset,
 323                                             flags & WIMLIB_WRITE_FLAG_SHOW_PROGRESS);
 324                 if (ret != 0)
 325                         return ret;
 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;
 333         } else {
 334                 hdr.integrity.offset        = 0;
 335                 hdr.integrity.size          = 0;
 336                 hdr.integrity.original_size = 0;
 337         }
 338         hdr.integrity.flags = 0;
 339
 340         DEBUG("Updating WIM header.");
 341
 342         /*
 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...
 348          */
 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));
 353         } else {
 354                 memcpy(&hdr.boot_metadata_res_entry,
 355                        &w->image_metadata[
 356                           hdr.boot_idx - 1].metadata_lte->output_resource_entry,
 357                        sizeof(struct resource_entry));
 358         }
 359
 360         /* Set image count and boot index correctly for single image writes */
 361         if (image != WIM_ALL_IMAGES) {
 362                 hdr.image_count = 1;
 363                 if (hdr.boot_idx == image)
 364                         hdr.boot_idx = 1;
 365                 else
 366                         hdr.boot_idx = 0;
 367         }
 368
 369
 370         if (fseeko(out, 0, SEEK_SET) != 0)
 371                 return WIMLIB_ERR_WRITE;
 372
 373         return write_header(&hdr, out);
 374 }
 375
 376 /* Open file stream and write dummy header for WIM. */
 377 int begin_write(WIMStruct *w, const char *path, int flags)
 378 {
 379         const char *mode;
 380         DEBUG("Opening `%s' for new WIM", path);
 381
 382         /* checking the integrity requires going back over the file to read it.
 383          * XXX
 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)
 387                 mode = "w+b";
 388         else
 389                 mode = "wb";
 390
 391         w->out_fp = fopen(path, mode);
 392         if (!w->out_fp) {
 393                 ERROR_WITH_ERRNO("Failed to open the file `%s' for writing",
 394                                  path);
 395                 return WIMLIB_ERR_OPEN;
 396         }
 397
 398         /* Write dummy header. It will be overwritten later. */
 399         return write_header(&w->hdr, w->out_fp);
 400 }
 401
 402 /* Writes the WIM to a file.  */
 403 WIMLIBAPI int wimlib_write(WIMStruct *w, const char *path, int image, int flags)
 404 {
 405         int ret;
 406
 407         if (!w || !path)
 408                 return WIMLIB_ERR_INVALID_PARAM;
 409
 410         if (image != WIM_ALL_IMAGES &&
 411              (image < 1 || image > w->hdr.image_count))
 412                 return WIMLIB_ERR_INVALID_IMAGE;
 413
 414
 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;
 418         }
 419
 420         if (image == WIM_ALL_IMAGES)
 421                 DEBUG("Writing all images to `%s'.", path);
 422         else
 423                 DEBUG("Writing image %d to `%s'.", image, path);
 424
 425         ret = begin_write(w, path, flags);
 426         if (ret != 0)
 427                 goto done;
 428
 429         for_lookup_table_entry(w->lookup_table, lte_zero_out_refcnt, NULL);
 430
 431         w->write_flags = flags;
 432
 433         ret = for_image(w, image, write_file_resources);
 434         if (ret != 0) {
 435                 ERROR("Failed to write WIM file resources to `%s'", path);
 436                 goto done;
 437         }
 438
 439         ret = for_image(w, image, write_metadata_resource);
 440
 441         if (ret != 0) {
 442                 ERROR("Failed to write WIM image metadata to `%s'", path);
 443                 goto done;
 444         }
 445
 446         ret = finish_write(w, image, flags, 1);
 447
 448 done:
 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;
 454                 }
 455                 w->out_fp = NULL;
 456         }
 457         return ret;
 458 }