X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwim.c;h=e1cda332488c76d34284e51301c3f47465707e99;hp=96fba59f284ac98c553b59291c69d5829b290eab;hb=6b8d739e7c68237499366546eb41bc4cb3fff9d4;hpb=062465170ddb4520ca6fbc64a0f6e27e786de101 diff --git a/src/wim.c b/src/wim.c index 96fba59f..e1cda332 100644 --- a/src/wim.c +++ b/src/wim.c @@ -5,8 +5,6 @@ /* * Copyright (C) 2012, 2013 Eric Biggers * - * wimlib - Library for working with WIM files - * * This file is part of wimlib, a library for working with WIM files. * * wimlib is free software; you can redistribute it and/or modify it under the @@ -23,62 +21,58 @@ * along with wimlib; if not, see http://www.gnu.org/licenses/. */ -#include "config.h" - -#include -#include -#include -#include -#include -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif +#include "wimlib/error.h" +#include "wimlib/dentry.h" +#include "wimlib/encoding.h" +#include "wimlib/file_io.h" +#include "wimlib/integrity.h" +#include "wimlib/lookup_table.h" +#include "wimlib/metadata.h" #ifdef WITH_NTFS_3G -# include -# include +# include "wimlib/ntfs_3g.h" /* for do_ntfs_umount() */ #endif +#include "wimlib/security.h" +#include "wimlib/wim.h" +#include "wimlib/xml.h" #ifdef __WIN32__ -# include "win32.h" -#else -# include +# include "wimlib/win32.h" /* for realpath() replacement */ #endif -#include "buffer_io.h" -#include "dentry.h" -#include "lookup_table.h" -#include "wimlib_internal.h" -#include "xml.h" +#include +#include +#ifndef __WIN32__ +# include +#endif +#include +#include +#include +#include static int -image_print_metadata(WIMStruct *w) +image_print_metadata(WIMStruct *wim) { - DEBUG("Printing metadata for image %d", w->current_image); - print_security_data(wim_security_data(w)); - return for_dentry_in_tree(wim_root_dentry(w), print_dentry, - w->lookup_table); + DEBUG("Printing metadata for image %d", wim->current_image); + print_wim_security_data(wim_security_data(wim)); + return for_dentry_in_tree(wim_root_dentry(wim), print_dentry, + wim->lookup_table); } -static int -image_print_files(WIMStruct *w) -{ - return for_dentry_in_tree(wim_root_dentry(w), print_dentry_full_path, - NULL); -} - static WIMStruct * -new_wim_struct() +new_wim_struct(void) { - WIMStruct *w = CALLOC(1, sizeof(WIMStruct)); -#ifdef WITH_FUSE - if (pthread_mutex_init(&w->fp_tab_mutex, NULL) != 0) { - ERROR_WITH_ERRNO("Failed to initialize mutex"); - FREE(w); - w = NULL; + WIMStruct *wim = CALLOC(1, sizeof(WIMStruct)); + if (wim) { + wim->in_fd.fd = -1; + wim->out_fd.fd = -1; + INIT_LIST_HEAD(&wim->subwims); } -#endif - return w; - + return wim; } /* @@ -88,7 +82,7 @@ new_wim_struct() * the WIM only once, with that image selected. */ int -for_image(WIMStruct *w, int image, int (*visitor)(WIMStruct *)) +for_image(WIMStruct *wim, int image, int (*visitor)(WIMStruct *)) { int ret; int start; @@ -97,59 +91,43 @@ for_image(WIMStruct *w, int image, int (*visitor)(WIMStruct *)) if (image == WIMLIB_ALL_IMAGES) { start = 1; - end = w->hdr.image_count; - } else if (image >= 1 && image <= w->hdr.image_count) { + end = wim->hdr.image_count; + } else if (image >= 1 && image <= wim->hdr.image_count) { start = image; end = image; } else { return WIMLIB_ERR_INVALID_IMAGE; } for (i = start; i <= end; i++) { - ret = select_wim_image(w, i); + ret = select_wim_image(wim, i); if (ret != 0) return ret; - ret = visitor(w); + ret = visitor(wim); if (ret != 0) return ret; } return 0; } -/* Returns the compression type given in the flags of a WIM header. */ -static int -wim_hdr_flags_compression_type(int wim_hdr_flags) -{ - if (wim_hdr_flags & WIM_HDR_FLAG_COMPRESSION) { - if (wim_hdr_flags & WIM_HDR_FLAG_COMPRESS_LZX) - return WIMLIB_COMPRESSION_TYPE_LZX; - else if (wim_hdr_flags & WIM_HDR_FLAG_COMPRESS_XPRESS) - return WIMLIB_COMPRESSION_TYPE_XPRESS; - else - return WIMLIB_COMPRESSION_TYPE_INVALID; - } else { - return WIMLIB_COMPRESSION_TYPE_NONE; - } -} - -/* - * Creates a WIMStruct for a new WIM file. - */ +/* API function documented in wimlib.h */ WIMLIBAPI int -wimlib_create_new_wim(int ctype, WIMStruct **w_ret) +wimlib_create_new_wim(int ctype, WIMStruct **wim_ret) { - WIMStruct *w; + WIMStruct *wim; struct wim_lookup_table *table; int ret; + wimlib_global_init(WIMLIB_INIT_FLAG_ASSUME_UTF8); + DEBUG("Creating new WIM with %"TS" compression.", wimlib_get_compression_type_string(ctype)); /* Allocate the WIMStruct. */ - w = new_wim_struct(); - if (!w) + wim = new_wim_struct(); + if (!wim) return WIMLIB_ERR_NOMEM; - ret = init_header(&w->hdr, ctype); + ret = init_wim_header(&wim->hdr, ctype); if (ret != 0) goto out_free; @@ -158,22 +136,18 @@ wimlib_create_new_wim(int ctype, WIMStruct **w_ret) ret = WIMLIB_ERR_NOMEM; goto out_free; } - w->lookup_table = table; - *w_ret = w; + wim->lookup_table = table; + wim->refcnts_ok = 1; + wim->compression_type = ctype; + *wim_ret = wim; return 0; out_free: - FREE(w); + FREE(wim); return ret; } -WIMLIBAPI int -wimlib_get_num_images(const WIMStruct *w) -{ - return w->hdr.image_count; -} - int -select_wim_image(WIMStruct *w, int image) +select_wim_image(WIMStruct *wim, int image) { struct wim_image_metadata *imd; int ret; @@ -185,27 +159,35 @@ select_wim_image(WIMStruct *w, int image) return WIMLIB_ERR_INVALID_IMAGE; } - if (image == w->current_image) + if (image == wim->current_image) return 0; - if (image < 1 || image > w->hdr.image_count) { + if (image < 1 || image > wim->hdr.image_count) { ERROR("Cannot select image %d: There are only %u images", - image, w->hdr.image_count); + image, wim->hdr.image_count); return WIMLIB_ERR_INVALID_IMAGE; } + if (!wim_has_metadata(wim)) { + ERROR("\"%"TS"\" does not contain metadata resources!", wim->filename); + if (wim->hdr.part_number != 1) + ERROR("Specify the first part of the split WIM instead."); + return WIMLIB_ERR_METADATA_NOT_FOUND; + } + /* If a valid image is currently selected, it can be freed if it is not * modified. */ - if (w->current_image != WIMLIB_NO_IMAGE) { - imd = wim_get_current_image_metadata(w); + if (wim->current_image != WIMLIB_NO_IMAGE) { + imd = wim_get_current_image_metadata(wim); if (!imd->modified) { - DEBUG("Freeing image %u", w->current_image); + wimlib_assert(list_empty(&imd->unhashed_streams)); + DEBUG("Freeing image %u", wim->current_image); destroy_image_metadata(imd, NULL, false); } } - w->current_image = image; - imd = wim_get_current_image_metadata(w); - if (imd->root_dentry) { + wim->current_image = image; + imd = wim_get_current_image_metadata(wim); + if (imd->root_dentry || imd->modified) { ret = 0; } else { #ifdef ENABLE_DEBUG @@ -213,21 +195,15 @@ select_wim_image(WIMStruct *w, int image) "lookup table entry:"); print_lookup_table_entry(imd->metadata_lte, stderr); #endif - ret = read_metadata_resource(w, imd); + ret = read_metadata_resource(wim, imd); if (ret) - w->current_image = WIMLIB_NO_IMAGE; + wim->current_image = WIMLIB_NO_IMAGE; } return ret; } -/* Returns the compression type of the WIM file. */ -WIMLIBAPI int -wimlib_get_compression_type(const WIMStruct *w) -{ - return wim_hdr_flags_compression_type(w->hdr.flags); -} - +/* API function documented in wimlib.h */ WIMLIBAPI const tchar * wimlib_get_compression_type_string(int ctype) { @@ -243,13 +219,9 @@ wimlib_get_compression_type_string(int ctype) } } -/* - * Returns the number of an image in the WIM file, given a string that is either - * the number of the image, or the name of the image. The images are numbered - * starting at 1. - */ +/* API function documented in wimlib.h */ WIMLIBAPI int -wimlib_resolve_image(WIMStruct *w, const tchar *image_name_or_num) +wimlib_resolve_image(WIMStruct *wim, const tchar *image_name_or_num) { tchar *p; long image; @@ -263,52 +235,22 @@ wimlib_resolve_image(WIMStruct *w, const tchar *image_name_or_num) return WIMLIB_ALL_IMAGES; image = tstrtol(image_name_or_num, &p, 10); if (p != image_name_or_num && *p == T('\0') && image > 0) { - if (image > w->hdr.image_count) + if (image > wim->hdr.image_count) return WIMLIB_NO_IMAGE; return image; } else { - for (i = 1; i <= w->hdr.image_count; i++) { + for (i = 1; i <= wim->hdr.image_count; i++) { if (!tstrcmp(image_name_or_num, - wimlib_get_image_name(w, i))) + wimlib_get_image_name(wim, i))) return i; } return WIMLIB_NO_IMAGE; } } -/* Prints some basic information about a WIM file. */ -WIMLIBAPI void -wimlib_print_wim_information(const WIMStruct *w) -{ - const struct wim_header *hdr; - - hdr = &w->hdr; - tputs(T("WIM Information:")); - tputs(T("----------------")); - tprintf(T("Path: %"TS"\n"), w->filename); - tfputs(T("GUID: 0x"), stdout); - print_byte_field(hdr->guid, WIM_GID_LEN, stdout); - tputchar(T('\n')); - tprintf(T("Image Count: %d\n"), hdr->image_count); - tprintf(T("Compression: %"TS"\n"), - wimlib_get_compression_type_string(wimlib_get_compression_type(w))); - tprintf(T("Part Number: %d/%d\n"), hdr->part_number, hdr->total_parts); - tprintf(T("Boot Index: %d\n"), hdr->boot_idx); - tprintf(T("Size: %"PRIu64" bytes\n"), - wim_info_get_total_bytes(w->wim_info)); - tprintf(T("Integrity Info: %"TS"\n"), - (w->hdr.integrity.offset != 0) ? T("yes") : T("no")); - tputchar(T('\n')); -} - -WIMLIBAPI bool -wimlib_has_integrity_table(const WIMStruct *w) -{ - return w->hdr.integrity.size != 0; -} - +/* API function documented in wimlib.h */ WIMLIBAPI void -wimlib_print_available_images(const WIMStruct *w, int image) +wimlib_print_available_images(const WIMStruct *wim, int image) { int first; int last; @@ -317,8 +259,8 @@ wimlib_print_available_images(const WIMStruct *w, int image) if (image == WIMLIB_ALL_IMAGES) { n = tprintf(T("Available Images:\n")); first = 1; - last = w->hdr.image_count; - } else if (image >= 1 && image <= w->hdr.image_count) { + last = wim->hdr.image_count; + } else if (image >= 1 && image <= wim->hdr.image_count) { n = tprintf(T("Information for Image %d\n"), image); first = image; last = image; @@ -331,63 +273,118 @@ wimlib_print_available_images(const WIMStruct *w, int image) tputchar(T('-')); tputchar(T('\n')); for (i = first; i <= last; i++) - print_image_info(w->wim_info, i); + print_image_info(wim->wim_info, i); } -/* Prints the metadata for the specified image, which may be WIMLIB_ALL_IMAGES, but - * not WIMLIB_NO_IMAGE. */ +/* API function documented in wimlib.h */ WIMLIBAPI int -wimlib_print_metadata(WIMStruct *w, int image) +wimlib_print_metadata(WIMStruct *wim, int image) { - if (w->hdr.part_number != 1) { - ERROR("Cannot show the metadata from part %hu of a %hu-part split WIM!", - w->hdr.part_number, w->hdr.total_parts); - ERROR("Select the first part of the split WIM to see the metadata."); - return WIMLIB_ERR_SPLIT_UNSUPPORTED; - } - return for_image(w, image, image_print_metadata); + return for_image(wim, image, image_print_metadata); } +/* API function documented in wimlib.h */ WIMLIBAPI int -wimlib_print_files(WIMStruct *w, int image) +wimlib_get_wim_info(WIMStruct *wim, struct wimlib_wim_info *info) { - if (w->hdr.part_number != 1) { - ERROR("Cannot list the files from part %hu of a %hu-part split WIM!", - w->hdr.part_number, w->hdr.total_parts); - ERROR("Select the first part of the split WIM if you'd like to list the files."); - return WIMLIB_ERR_SPLIT_UNSUPPORTED; - } - return for_image(w, image, image_print_files); + memset(info, 0, sizeof(struct wimlib_wim_info)); + memcpy(info->guid, wim->hdr.guid, WIMLIB_GUID_LEN); + info->image_count = wim->hdr.image_count; + info->boot_index = wim->hdr.boot_idx; + info->wim_version = WIM_VERSION; + info->chunk_size = WIM_CHUNK_SIZE; + info->part_number = wim->hdr.part_number; + info->total_parts = wim->hdr.total_parts; + info->compression_type = wim->compression_type; + info->total_bytes = wim_info_get_total_bytes(wim->wim_info); + info->has_integrity_table = wim_has_integrity_table(wim); + info->opened_from_file = (wim->filename != NULL); + info->is_readonly = (wim->hdr.flags & WIM_HDR_FLAG_READONLY) || + (wim->hdr.total_parts != 1) || + (wim->filename && taccess(wim->filename, W_OK)); + info->has_rpfix = (wim->hdr.flags & WIM_HDR_FLAG_RP_FIX) != 0; + info->is_marked_readonly = (wim->hdr.flags & WIM_HDR_FLAG_READONLY) != 0; + info->write_in_progress = (wim->hdr.flags & WIM_HDR_FLAG_WRITE_IN_PROGRESS) != 0; + info->metadata_only = (wim->hdr.flags & WIM_HDR_FLAG_METADATA_ONLY) != 0; + info->resource_only = (wim->hdr.flags & WIM_HDR_FLAG_RESOURCE_ONLY) != 0; + info->spanned = (wim->hdr.flags & WIM_HDR_FLAG_SPANNED) != 0; + info->pipable = wim_is_pipable(wim); + return 0; } -/* Sets the index of the bootable image. */ +/* API function documented in wimlib.h */ WIMLIBAPI int -wimlib_set_boot_idx(WIMStruct *w, int boot_idx) +wimlib_set_wim_info(WIMStruct *wim, const struct wimlib_wim_info *info, int which) { - if (w->hdr.total_parts != 1) { - ERROR("Cannot modify the boot index of a split WIM!"); - return WIMLIB_ERR_SPLIT_UNSUPPORTED; + int ret; + + if (which & WIMLIB_CHANGE_READONLY_FLAG) { + if (info->is_marked_readonly) + wim->hdr.flags |= WIM_HDR_FLAG_READONLY; + else + wim->hdr.flags &= ~WIM_HDR_FLAG_READONLY; + } + + if ((which & ~WIMLIB_CHANGE_READONLY_FLAG) == 0) + return 0; + + ret = can_modify_wim(wim); + if (ret) + return ret; + + if (which & WIMLIB_CHANGE_GUID) { + memcpy(wim->hdr.guid, info->guid, WIM_GID_LEN); + wim->guid_set_explicitly = 1; + } + + if (which & WIMLIB_CHANGE_BOOT_INDEX) { + if (info->boot_index > wim->hdr.image_count) { + ERROR("%u is not 0 or a valid image in the WIM to mark as bootable", + info->boot_index); + return WIMLIB_ERR_INVALID_IMAGE; + } + wim->hdr.boot_idx = info->boot_index; + } + + if (which & WIMLIB_CHANGE_RPFIX_FLAG) { + if (info->has_rpfix) + wim->hdr.flags |= WIM_HDR_FLAG_RP_FIX; + else + wim->hdr.flags &= ~WIM_HDR_FLAG_RP_FIX; } - if (boot_idx < 0 || boot_idx > w->hdr.image_count) - return WIMLIB_ERR_INVALID_IMAGE; - w->hdr.boot_idx = boot_idx; return 0; } -WIMLIBAPI int -wimlib_get_part_number(const WIMStruct *w, int *total_parts_ret) +static int +do_open_wim(const tchar *filename, struct filedes *fd_ret) { - if (total_parts_ret) - *total_parts_ret = w->hdr.total_parts; - return w->hdr.part_number; + int raw_fd; + + raw_fd = topen(filename, O_RDONLY | O_BINARY); + if (raw_fd < 0) { + ERROR_WITH_ERRNO("Can't open \"%"TS"\" read-only", filename); + return WIMLIB_ERR_OPEN; + } + filedes_init(fd_ret, raw_fd); + return 0; } +int +reopen_wim(WIMStruct *wim) +{ + wimlib_assert(!filedes_valid(&wim->in_fd)); + return do_open_wim(wim->filename, &wim->in_fd); +} -WIMLIBAPI int -wimlib_get_boot_idx(const WIMStruct *w) +int +close_wim(WIMStruct *wim) { - return w->hdr.boot_idx; + if (filedes_valid(&wim->in_fd)) { + filedes_close(&wim->in_fd); + filedes_invalidate(&wim->in_fd); + } + return 0; } /* @@ -395,67 +392,102 @@ wimlib_get_boot_idx(const WIMStruct *w) * lookup table, and optionally checks the integrity. */ static int -begin_read(WIMStruct *w, const tchar *in_wim_path, int open_flags, - wimlib_progress_func_t progress_func) +begin_read(WIMStruct *wim, const void *wim_filename_or_fd, + int open_flags, wimlib_progress_func_t progress_func) { int ret; int xml_num_images; + const tchar *wimfile; - DEBUG("Reading the WIM file `%"TS"'", in_wim_path); - - w->fp = tfopen(in_wim_path, T("rb")); - if (!w->fp) { - ERROR_WITH_ERRNO("Failed to open `%"TS"' for reading", - in_wim_path); - return WIMLIB_ERR_OPEN; - } + if (open_flags & WIMLIB_OPEN_FLAG_FROM_PIPE) { + wimfile = NULL; + filedes_init(&wim->in_fd, *(const int*)wim_filename_or_fd); + wim->in_fd.is_pipe = 1; + } else { + wimfile = wim_filename_or_fd; + DEBUG("Reading the WIM file `%"TS"'", wimfile); + ret = do_open_wim(wimfile, &wim->in_fd); + if (ret) + return ret; - /* The absolute path to the WIM is requested so that wimlib_overwrite() - * still works even if the process changes its working directory. This - * actually happens if a WIM is mounted read-write, since the FUSE - * thread changes directory to "/", and it needs to be able to find the - * WIM file again. - * - * This will break if the full path to the WIM changes in the - * intervening time... - * - * Warning: in Windows native builds, realpath() calls the replacement - * function in win32.c. - */ - w->filename = realpath(in_wim_path, NULL); - if (!w->filename) { - ERROR_WITH_ERRNO("Failed to resolve WIM filename"); - if (errno == ENOMEM) - return WIMLIB_ERR_NOMEM; - else - return WIMLIB_ERR_OPEN; + /* The absolute path to the WIM is requested so that + * wimlib_overwrite() still works even if the process changes + * its working directory. This actually happens if a WIM is + * mounted read-write, since the FUSE thread changes directory + * to "/", and it needs to be able to find the WIM file again. + * + * This will break if the full path to the WIM changes in the + * intervening time... + * + * Warning: in Windows native builds, realpath() calls the + * replacement function in win32_replacements.c. + */ + wim->filename = realpath(wimfile, NULL); + if (!wim->filename) { + ERROR_WITH_ERRNO("Failed to resolve WIM filename"); + if (errno == ENOMEM) + return WIMLIB_ERR_NOMEM; + else + return WIMLIB_ERR_OPEN; + } } - ret = read_header(w->fp, &w->hdr, open_flags); + ret = read_wim_header(wim->filename, &wim->in_fd, &wim->hdr); if (ret) return ret; - DEBUG("According to header, WIM contains %u images", w->hdr.image_count); + if (wim->hdr.flags & WIM_HDR_FLAG_WRITE_IN_PROGRESS) { + WARNING("The WIM_HDR_FLAG_WRITE_IN_PROGRESS is set in the header of \"%"TS"\".\n" + " It may be being changed by another process, or a process\n" + " may have crashed while writing the WIM.", wimfile); + } + + if (open_flags & WIMLIB_OPEN_FLAG_WRITE_ACCESS) { + ret = can_modify_wim(wim); + if (ret) + return ret; + } + + if ((open_flags & WIMLIB_OPEN_FLAG_ERROR_IF_SPLIT) && + (wim->hdr.total_parts != 1)) + return WIMLIB_ERR_IS_SPLIT_WIM; + + DEBUG("According to header, WIM contains %u images", wim->hdr.image_count); /* If the boot index is invalid, print a warning and set it to 0 */ - if (w->hdr.boot_idx > w->hdr.image_count) { + if (wim->hdr.boot_idx > wim->hdr.image_count) { WARNING("In `%"TS"', image %u is marked as bootable, " "but there are only %u images in the WIM", - in_wim_path, w->hdr.boot_idx, w->hdr.image_count); - w->hdr.boot_idx = 0; + wimfile, wim->hdr.boot_idx, wim->hdr.image_count); + wim->hdr.boot_idx = 0; } - if (wimlib_get_compression_type(w) == WIMLIB_COMPRESSION_TYPE_INVALID) { - ERROR("Invalid compression type (WIM header flags = 0x%x)", - w->hdr.flags); - return WIMLIB_ERR_INVALID_COMPRESSION_TYPE; + /* Check and cache the compression type */ + if (wim->hdr.flags & WIM_HDR_FLAG_COMPRESSION) { + if (wim->hdr.flags & WIM_HDR_FLAG_COMPRESS_LZX) { + if (wim->hdr.flags & WIM_HDR_FLAG_COMPRESS_XPRESS) { + ERROR("Multiple compression flags are set in \"%"TS"\"", + wimfile); + return WIMLIB_ERR_INVALID_COMPRESSION_TYPE; + } + wim->compression_type = WIMLIB_COMPRESSION_TYPE_LZX; + } else if (wim->hdr.flags & WIM_HDR_FLAG_COMPRESS_XPRESS) { + wim->compression_type = WIMLIB_COMPRESSION_TYPE_XPRESS; + } else { + ERROR("The compression flag is set on \"%"TS"\", but " + "neither the XPRESS nor LZX flag is set", + wimfile); + return WIMLIB_ERR_INVALID_COMPRESSION_TYPE; + } + } else { + wim->compression_type = WIMLIB_COMPRESSION_TYPE_NONE; } if (open_flags & WIMLIB_OPEN_FLAG_CHECK_INTEGRITY) { - ret = check_wim_integrity(w, progress_func); + ret = check_wim_integrity(wim, progress_func); if (ret == WIM_INTEGRITY_NONEXISTENT) { WARNING("No integrity information for `%"TS"'; skipping " - "integrity check.", in_wim_path); + "integrity check.", wimfile); } else if (ret == WIM_INTEGRITY_NOT_OK) { ERROR("WIM is not intact! (Failed integrity check)"); return WIMLIB_ERR_INTEGRITY; @@ -464,60 +496,79 @@ begin_read(WIMStruct *w, const tchar *in_wim_path, int open_flags, } } - if (w->hdr.image_count != 0 && w->hdr.part_number == 1) { - w->image_metadata = new_image_metadata_array(w->hdr.image_count); - if (!w->image_metadata) + if (wim->hdr.image_count != 0 && wim->hdr.part_number == 1) { + wim->image_metadata = new_image_metadata_array(wim->hdr.image_count); + if (!wim->image_metadata) return WIMLIB_ERR_NOMEM; } - ret = read_lookup_table(w); - if (ret) - return ret; + if (open_flags & WIMLIB_OPEN_FLAG_FROM_PIPE) { + wim->lookup_table = new_lookup_table(9001); + if (!wim->lookup_table) + return WIMLIB_ERR_NOMEM; + } else { + ret = read_wim_lookup_table(wim); + if (ret) + return ret; - ret = read_xml_data(w->fp, &w->hdr.xml_res_entry, - &w->xml_data, &w->wim_info); - if (ret) - return ret; + ret = read_wim_xml_data(wim); + if (ret) + return ret; - xml_num_images = wim_info_get_num_images(w->wim_info); - if (xml_num_images != w->hdr.image_count) { - ERROR("In the file `%"TS"', there are %u elements " - "in the XML data,", in_wim_path, xml_num_images); - ERROR("but %u images in the WIM! There must be exactly one " - " element per image.", w->hdr.image_count); - return WIMLIB_ERR_IMAGE_COUNT; + xml_num_images = wim_info_get_num_images(wim->wim_info); + if (xml_num_images != wim->hdr.image_count) { + ERROR("In the file `%"TS"', there are %u elements " + "in the XML data,", wimfile, xml_num_images); + ERROR("but %u images in the WIM! There must be exactly one " + " element per image.", wim->hdr.image_count); + return WIMLIB_ERR_IMAGE_COUNT; + } + DEBUG("Done beginning read of WIM file `%"TS"'.", wimfile); } - - DEBUG("Done beginning read of WIM file `%"TS"'.", in_wim_path); return 0; } -/* - * Opens a WIM file and creates a WIMStruct for it. - */ -WIMLIBAPI int -wimlib_open_wim(const tchar *wim_file, int open_flags, - WIMStruct **w_ret, - wimlib_progress_func_t progress_func) +int +open_wim_as_WIMStruct(const void *wim_filename_or_fd, int open_flags, + WIMStruct **wim_ret, wimlib_progress_func_t progress_func) { - WIMStruct *w; + WIMStruct *wim; int ret; - if (!wim_file || !w_ret) - return WIMLIB_ERR_INVALID_PARAM; + wimlib_global_init(WIMLIB_INIT_FLAG_ASSUME_UTF8); - w = new_wim_struct(); - if (!w) - return WIMLIB_ERR_NOMEM; + ret = WIMLIB_ERR_INVALID_PARAM; + if (!wim_ret) + goto out; + + ret = WIMLIB_ERR_NOMEM; + wim = new_wim_struct(); + if (!wim) + goto out; - ret = begin_read(w, wim_file, open_flags, progress_func); - if (ret == 0) - *w_ret = w; - else - wimlib_free(w); + ret = begin_read(wim, wim_filename_or_fd, open_flags, progress_func); + if (ret) + goto out_wimlib_free; + + ret = 0; + *wim_ret = wim; + goto out; +out_wimlib_free: + wimlib_free(wim); +out: return ret; } +/* API function documented in wimlib.h */ +WIMLIBAPI int +wimlib_open_wim(const tchar *wimfile, int open_flags, + WIMStruct **wim_ret, wimlib_progress_func_t progress_func) +{ + open_flags &= WIMLIB_OPEN_MASK_PUBLIC; + return open_wim_as_WIMStruct(wimfile, open_flags, wim_ret, + progress_func); +} + void destroy_image_metadata(struct wim_image_metadata *imd, struct wim_lookup_table *table, @@ -525,15 +576,26 @@ destroy_image_metadata(struct wim_image_metadata *imd, { free_dentry_tree(imd->root_dentry, table); imd->root_dentry = NULL; - free_security_data(imd->security_data); + free_wim_security_data(imd->security_data); imd->security_data = NULL; if (free_metadata_lte) { free_lookup_table_entry(imd->metadata_lte); imd->metadata_lte = NULL; } + if (!table) { + struct wim_lookup_table_entry *lte, *tmp; + list_for_each_entry_safe(lte, tmp, &imd->unhashed_streams, unhashed_list) + free_lookup_table_entry(lte); + } INIT_LIST_HEAD(&imd->unhashed_streams); INIT_LIST_HEAD(&imd->inode_list); +#ifdef WITH_NTFS_3G + if (imd->ntfs_vol) { + do_ntfs_umount(imd->ntfs_vol); + imd->ntfs_vol = NULL; + } +#endif } void @@ -549,28 +611,28 @@ put_image_metadata(struct wim_image_metadata *imd, /* Appends the specified image metadata structure to the array of image metadata * for a WIM, and increments the image count. */ int -append_image_metadata(WIMStruct *w, struct wim_image_metadata *imd) +append_image_metadata(WIMStruct *wim, struct wim_image_metadata *imd) { struct wim_image_metadata **imd_array; DEBUG("Reallocating image metadata array for image_count = %u", - w->hdr.image_count + 1); - imd_array = REALLOC(w->image_metadata, - sizeof(w->image_metadata[0]) * (w->hdr.image_count + 1)); + wim->hdr.image_count + 1); + imd_array = REALLOC(wim->image_metadata, + sizeof(wim->image_metadata[0]) * (wim->hdr.image_count + 1)); if (!imd_array) return WIMLIB_ERR_NOMEM; - w->image_metadata = imd_array; - imd_array[w->hdr.image_count++] = imd; + wim->image_metadata = imd_array; + imd_array[wim->hdr.image_count++] = imd; return 0; } struct wim_image_metadata * -new_image_metadata() +new_image_metadata(void) { struct wim_image_metadata *imd; - + imd = CALLOC(1, sizeof(*imd)); if (imd) { imd->refcnt = 1; @@ -610,52 +672,124 @@ new_image_metadata_array(unsigned num_images) return imd_array; } -/* Frees the memory for the WIMStruct, including all internal memory; also - * closes all files associated with the WIMStruct. */ -WIMLIBAPI void -wimlib_free(WIMStruct *w) +/* Checksum all streams that are unhashed (other than the metadata streams), + * merging them into the lookup table as needed. This is a no-op unless the + * library has previously used to add or mount an image using the same + * WIMStruct. */ +int +wim_checksum_unhashed_streams(WIMStruct *wim) { - DEBUG("Freeing WIMStruct"); + int ret; - if (!w) + if (!wim_has_metadata(wim)) + return 0; + for (int i = 0; i < wim->hdr.image_count; i++) { + struct wim_lookup_table_entry *lte, *tmp; + struct wim_image_metadata *imd = wim->image_metadata[i]; + image_for_each_unhashed_stream_safe(lte, tmp, imd) { + ret = hash_unhashed_stream(lte, wim->lookup_table, NULL); + if (ret) + return ret; + } + } + return 0; +} + +/* + * can_modify_wim - Check if a given WIM is writeable. This is only the case if + * it meets the following three conditions: + * + * 1. Write access is allowed to the underlying file (if any) at the filesystem level. + * 2. The WIM is not part of a spanned set. + * 3. The WIM_HDR_FLAG_READONLY flag is not set in the WIM header. + * + * Return value is 0 if writable; WIMLIB_ERR_WIM_IS_READONLY otherwise. + */ +int +can_modify_wim(WIMStruct *wim) +{ + if (wim->filename) { + if (taccess(wim->filename, W_OK)) { + ERROR_WITH_ERRNO("Can't modify \"%"TS"\"", wim->filename); + return WIMLIB_ERR_WIM_IS_READONLY; + } + } + if (wim->hdr.total_parts != 1) { + ERROR("Cannot modify \"%"TS"\": is part of a split WIM", + wim->filename); + return WIMLIB_ERR_WIM_IS_READONLY; + } + if (wim->hdr.flags & WIM_HDR_FLAG_READONLY) { + ERROR("Cannot modify \"%"TS"\": is marked read-only", + wim->filename); + return WIMLIB_ERR_WIM_IS_READONLY; + } + return 0; +} + +/* + * can_delete_from_wim - Check if files or images can be deleted from a given + * WIM file. + * + * This theoretically should be exactly the same as can_modify_wim(), but + * unfortunately, due to bugs in Microsoft's software that generate incorrect + * reference counts for some WIM resources, we need to run expensive + * verifications to make sure the reference counts are correct on all WIM + * resources. Otherwise we might delete a WIM resource whose reference count + * has fallen to 0, but is actually still referenced somewhere. + */ +int +can_delete_from_wim(WIMStruct *wim) +{ + int ret; + + ret = can_modify_wim(wim); + if (ret) + return ret; + if (!wim->refcnts_ok) + wim_recalculate_refcnts(wim); + return 0; +} + +/* API function documented in wimlib.h */ +WIMLIBAPI void +wimlib_free(WIMStruct *wim) +{ + if (!wim) return; - if (w->fp) - fclose(w->fp); - if (w->out_fp) - fclose(w->out_fp); - -#ifdef WITH_FUSE - if (w->fp_tab) { - for (size_t i = 0; i < w->num_allocated_fps; i++) - if (w->fp_tab[i]) - fclose(w->fp_tab[i]); - FREE(w->fp_tab); - } - pthread_mutex_destroy(&w->fp_tab_mutex); -#endif - free_lookup_table(w->lookup_table); + DEBUG("Freeing WIMStruct (filename=\"%"TS"\", image_count=%u)", + wim->filename, wim->hdr.image_count); + + while (!list_empty(&wim->subwims)) { + WIMStruct *subwim; - FREE(w->filename); - FREE(w->xml_data); - free_wim_info(w->wim_info); - if (w->image_metadata) { - for (unsigned i = 0; i < w->hdr.image_count; i++) - put_image_metadata(w->image_metadata[i], NULL); - FREE(w->image_metadata); + subwim = list_entry(wim->subwims.next, WIMStruct, subwim_node); + list_del(&subwim->subwim_node); + DEBUG("Freeing subwim."); + wimlib_free(subwim); } -#ifdef WITH_NTFS_3G - if (w->ntfs_vol) { - DEBUG("Unmounting NTFS volume"); - ntfs_umount(w->ntfs_vol, FALSE); + + if (filedes_valid(&wim->in_fd)) + filedes_close(&wim->in_fd); + if (filedes_valid(&wim->out_fd)) + filedes_close(&wim->out_fd); + + + free_lookup_table(wim->lookup_table); + + FREE(wim->filename); + free_wim_info(wim->wim_info); + if (wim->image_metadata) { + for (unsigned i = 0; i < wim->hdr.image_count; i++) + put_image_metadata(wim->image_metadata[i], NULL); + FREE(wim->image_metadata); } -#endif - FREE(w); - DEBUG("Freed WIMStruct"); + FREE(wim); } static bool -test_locale_ctype_utf8() +test_locale_ctype_utf8(void) { #ifdef __WIN32__ return false; @@ -669,26 +803,37 @@ test_locale_ctype_utf8() #endif } -/* Get global memory allocations out of the way, - * single-threaded programs like 'imagex'. */ +/* API function documented in wimlib.h */ WIMLIBAPI int -wimlib_global_init() +wimlib_global_init(int init_flags) { + static bool already_inited = false; + int ret; + + if (already_inited) + return 0; libxml_global_init(); -#ifdef WITH_NTFS_3G - libntfs3g_global_init(); -#endif - wimlib_mbs_is_utf8 = test_locale_ctype_utf8(); + if (!(init_flags & WIMLIB_INIT_FLAG_ASSUME_UTF8)) { + wimlib_mbs_is_utf8 = test_locale_ctype_utf8(); + #ifdef WITH_NTFS_3G + if (!wimlib_mbs_is_utf8) + libntfs3g_global_init(); + #endif + } #ifdef __WIN32__ - win32_global_init(); + ret = win32_global_init(init_flags); + if (ret) + return ret; +#else + ret = 0; #endif - return 0; + already_inited = true; + return ret; } -/* Free global memory allocations. Not strictly necessary if the process using - * wimlib is just about to exit (as is the case for 'imagex'). */ +/* API function documented in wimlib.h */ WIMLIBAPI void -wimlib_global_cleanup() +wimlib_global_cleanup(void) { libxml_global_cleanup(); iconv_global_cleanup();