X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwim.c;h=4a8e6a8be828c8a5282a0993ea96daf4a0f8293e;hp=bba8487f7f9e321405c37c237f383dde20004643;hb=4b8dbcb1723bacdd692ea57184cb49ce3d2b7774;hpb=276f9f9f9658f4a8bafd6216db46760abe8c848d diff --git a/src/wim.c b/src/wim.c index bba8487f..4a8e6a8b 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,37 +21,43 @@ * 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) { DEBUG("Printing metadata for image %d", w->current_image); - print_security_data(wim_security_data(w)); + print_wim_security_data(wim_security_data(w)); return for_dentry_in_tree(wim_root_dentry(w), print_dentry, w->lookup_table); } @@ -67,18 +71,14 @@ image_print_files(WIMStruct *w) } 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; + if (w) { + w->in_fd = -1; + w->out_fd = -1; } -#endif return w; - } /* @@ -115,49 +115,6 @@ for_image(WIMStruct *w, int image, int (*visitor)(WIMStruct *)) return 0; } -static int -sort_image_metadata_by_position(const void *p1, const void *p2) -{ - const struct wim_image_metadata *imd1 = p1; - const struct wim_image_metadata *imd2 = p2; - u64 offset1 = imd1->metadata_lte->resource_entry.offset; - u64 offset2 = imd2->metadata_lte->resource_entry.offset; - if (offset1 < offset2) - return -1; - else if (offset1 > offset2) - return 1; - else - return 0; -} - -/* - * If @lte points to a metadata resource, append it to the list of metadata - * resources in the WIMStruct. Otherwise, do nothing. - */ -static int -append_metadata_resource_entry(struct wim_lookup_table_entry *lte, void *wim_p) -{ - WIMStruct *w = wim_p; - int ret = 0; - - if (lte->resource_entry.flags & WIM_RESHDR_FLAG_METADATA) { - if (w->current_image == w->hdr.image_count) { - ERROR("The WIM header says there are %u images in the WIM,\n" - " but we found more metadata resources than this", - w->hdr.image_count); - ret = WIMLIB_ERR_IMAGE_COUNT; - } else { - DEBUG("Found metadata resource for image %u at " - "offset %"PRIu64".", - w->current_image + 1, - lte->resource_entry.offset); - w->image_metadata[ - w->current_image++].metadata_lte = lte; - } - } - return ret; -} - /* Returns the compression type given in the flags of a WIM header. */ static int wim_hdr_flags_compression_type(int wim_hdr_flags) @@ -184,7 +141,7 @@ wimlib_create_new_wim(int ctype, WIMStruct **w_ret) struct wim_lookup_table *table; int ret; - DEBUG("Creating new WIM with %s compression.", + DEBUG("Creating new WIM with %"TS" compression.", wimlib_get_compression_type_string(ctype)); /* Allocate the WIMStruct. */ @@ -242,22 +199,20 @@ select_wim_image(WIMStruct *w, int image) if (w->current_image != WIMLIB_NO_IMAGE) { imd = wim_get_current_image_metadata(w); if (!imd->modified) { + wimlib_assert(list_empty(&imd->unhashed_streams)); DEBUG("Freeing image %u", w->current_image); - destroy_image_metadata(imd, NULL); - imd->root_dentry = NULL; - imd->security_data = NULL; - INIT_HLIST_HEAD(&imd->inode_list); + destroy_image_metadata(imd, NULL, false); } } w->current_image = image; - imd = &w->image_metadata[image - 1]; - if (imd->root_dentry) { + imd = wim_get_current_image_metadata(w); + if (imd->root_dentry || imd->modified) { ret = 0; } else { #ifdef ENABLE_DEBUG DEBUG("Reading metadata resource specified by the following " "lookup table entry:"); - print_lookup_table_entry(imd->metadata_lte, stdout); + print_lookup_table_entry(imd->metadata_lte, stderr); #endif ret = read_metadata_resource(w, imd); if (ret) @@ -298,14 +253,14 @@ WIMLIBAPI int wimlib_resolve_image(WIMStruct *w, const tchar *image_name_or_num) { tchar *p; - int image; + long image; int i; if (!image_name_or_num || !*image_name_or_num) return WIMLIB_NO_IMAGE; - if (tstrcmp(image_name_or_num, T("all")) == 0 - || tstrcmp(image_name_or_num, T("*")) == 0) + if (!tstrcasecmp(image_name_or_num, T("all")) + || !tstrcasecmp(image_name_or_num, T("*"))) return WIMLIB_ALL_IMAGES; image = tstrtol(image_name_or_num, &p, 10); if (p != image_name_or_num && *p == T('\0') && image > 0) { @@ -314,8 +269,8 @@ wimlib_resolve_image(WIMStruct *w, const tchar *image_name_or_num) return image; } else { for (i = 1; i <= w->hdr.image_count; i++) { - if (tstrcmp(image_name_or_num, - wimlib_get_image_name(w, i)) == 0) + if (!tstrcmp(image_name_or_num, + wimlib_get_image_name(w, i))) return i; } return WIMLIB_NO_IMAGE; @@ -333,7 +288,7 @@ wimlib_print_wim_information(const WIMStruct *w) tputs(T("----------------")); tprintf(T("Path: %"TS"\n"), w->filename); tfputs(T("GUID: 0x"), stdout); - print_byte_field(hdr->guid, WIM_GID_LEN); + 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"), @@ -344,6 +299,8 @@ wimlib_print_wim_information(const WIMStruct *w) wim_info_get_total_bytes(w->wim_info)); tprintf(T("Integrity Info: %"TS"\n"), (w->hdr.integrity.offset != 0) ? T("yes") : T("no")); + tprintf(T("Relative path junction: %"TS"\n"), + (hdr->flags & WIM_HDR_FLAG_RP_FIX) ? T("yes") : T("no")); tputchar(T('\n')); } @@ -409,26 +366,16 @@ wimlib_print_files(WIMStruct *w, int image) /* Sets the index of the bootable image. */ WIMLIBAPI int -wimlib_set_boot_idx(WIMStruct *w, int boot_idx) +wimlib_set_boot_idx(WIMStruct *wim, int boot_idx) { - if (w->hdr.total_parts != 1) { - ERROR("Cannot modify the boot index of a split WIM!"); - return WIMLIB_ERR_SPLIT_UNSUPPORTED; - } - if (boot_idx < 0 || boot_idx > w->hdr.image_count) - return WIMLIB_ERR_INVALID_IMAGE; - w->hdr.boot_idx = boot_idx; - - if (boot_idx == 0) { - memset(&w->hdr.boot_metadata_res_entry, 0, - sizeof(struct resource_entry)); - } else { - memcpy(&w->hdr.boot_metadata_res_entry, - &w->image_metadata[ - boot_idx - 1].metadata_lte->resource_entry, - sizeof(struct resource_entry)); - } + int ret; + ret = can_modify_wim(wim); + if (ret) + return ret; + if (boot_idx < 0 || boot_idx > wim->hdr.image_count) + return WIMLIB_ERR_INVALID_IMAGE; + wim->hdr.boot_idx = boot_idx; return 0; } @@ -447,6 +394,37 @@ wimlib_get_boot_idx(const WIMStruct *w) return w->hdr.boot_idx; } +static int +do_open_wim(const tchar *filename, int *fd_ret) +{ + int fd; + + fd = topen(filename, O_RDONLY | O_BINARY); + if (fd == -1) { + ERROR_WITH_ERRNO("Can't open \"%"TS"\" read-only", filename); + return WIMLIB_ERR_OPEN; + } + *fd_ret = fd; + return 0; +} + +int +reopen_wim(WIMStruct *w) +{ + wimlib_assert(w->in_fd == -1); + return do_open_wim(w->filename, &w->in_fd); +} + +int +close_wim(WIMStruct *w) +{ + if (w->in_fd != -1) { + close(w->in_fd); + w->in_fd = -1; + } + return 0; +} + /* * Begins the reading of a WIM file; opens the file and reads its header and * lookup table, and optionally checks the integrity. @@ -460,12 +438,9 @@ begin_read(WIMStruct *w, const tchar *in_wim_path, int open_flags, 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; - } + ret = do_open_wim(in_wim_path, &w->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 @@ -488,8 +463,8 @@ begin_read(WIMStruct *w, const tchar *in_wim_path, int open_flags, return WIMLIB_ERR_OPEN; } - ret = read_header(w->fp, &w->hdr, open_flags); - if (ret != 0) + ret = read_header(w->filename, w->in_fd, &w->hdr, open_flags); + if (ret) return ret; DEBUG("According to header, WIM contains %u images", w->hdr.image_count); @@ -521,55 +496,18 @@ begin_read(WIMStruct *w, const tchar *in_wim_path, int open_flags, } } - ret = read_lookup_table(w); - if (ret != 0) - return ret; - - if (w->hdr.image_count != 0) { - w->image_metadata = CALLOC(w->hdr.image_count, - sizeof(struct wim_image_metadata)); - - if (!w->image_metadata) { - ERROR("Failed to allocate memory for %u image metadata structures", - w->hdr.image_count); + 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) return WIMLIB_ERR_NOMEM; - } } - w->current_image = 0; - DEBUG("Looking for metadata resources in the lookup table."); - - /* Find the images in the WIM by searching the lookup table. */ - ret = for_lookup_table_entry(w->lookup_table, - append_metadata_resource_entry, w); - - if (ret != 0) + ret = read_lookup_table(w); + if (ret) return ret; - /* Make sure all the expected images were found. (We already have - * returned WIMLIB_ERR_IMAGE_COUNT if *extra* images were found) */ - if (w->current_image != w->hdr.image_count && - w->hdr.part_number == 1) - { - ERROR("Only found %d images in WIM, but expected %u", - w->current_image, w->hdr.image_count); - return WIMLIB_ERR_IMAGE_COUNT; - } - - /* Sort images by the position of their metadata resources. I'm - * assuming that is what determines the other of the images in the WIM - * file, rather than their order in the lookup table, which is random - * because of hashing. */ - qsort(w->image_metadata, w->current_image, - sizeof(struct wim_image_metadata), sort_image_metadata_by_position); - - w->current_image = WIMLIB_NO_IMAGE; - - /* Read the XML data. */ - ret = read_xml_data(w->fp, &w->hdr.xml_res_entry, - &w->xml_data, &w->wim_info); - - if (ret != 0) + ret = read_xml_data(w->in_fd, &w->hdr.xml_res_entry, &w->wim_info); + if (ret) return ret; xml_num_images = wim_info_get_num_images(w->wim_info); @@ -613,17 +551,152 @@ wimlib_open_wim(const tchar *wim_file, int open_flags, void destroy_image_metadata(struct wim_image_metadata *imd, - struct wim_lookup_table *table) + struct wim_lookup_table *table, + bool free_metadata_lte) { free_dentry_tree(imd->root_dentry, table); - free_security_data(imd->security_data); + imd->root_dentry = NULL; + free_wim_security_data(imd->security_data); + imd->security_data = NULL; - /* Get rid of the lookup table entry for this image's metadata resource - * */ - if (table) { - lookup_table_unlink(table, imd->metadata_lte); + 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 +put_image_metadata(struct wim_image_metadata *imd, + struct wim_lookup_table *table) +{ + if (imd && --imd->refcnt == 0) { + destroy_image_metadata(imd, table, true); + FREE(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) +{ + 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)); + + if (!imd_array) + return WIMLIB_ERR_NOMEM; + w->image_metadata = imd_array; + imd_array[w->hdr.image_count++] = imd; + return 0; +} + + +struct wim_image_metadata * +new_image_metadata(void) +{ + struct wim_image_metadata *imd; + + imd = CALLOC(1, sizeof(*imd)); + if (imd) { + imd->refcnt = 1; + INIT_LIST_HEAD(&imd->inode_list); + INIT_LIST_HEAD(&imd->unhashed_streams); + DEBUG("Created new image metadata (refcnt=1)"); + } else { + ERROR_WITH_ERRNO("Failed to allocate new image metadata structure"); } + return imd; +} + +struct wim_image_metadata ** +new_image_metadata_array(unsigned num_images) +{ + struct wim_image_metadata **imd_array; + + DEBUG("Creating new image metadata array for %u images", + num_images); + + imd_array = CALLOC(num_images, sizeof(imd_array[0])); + + if (!imd_array) { + ERROR("Failed to allocate memory for %u image metadata structures", + num_images); + return NULL; + } + for (unsigned i = 0; i < num_images; i++) { + imd_array[i] = new_image_metadata(); + if (!imd_array[i]) { + for (unsigned j = 0; j < i; j++) + put_image_metadata(imd_array[j], NULL); + FREE(imd_array); + return NULL; + } + } + return imd_array; +} + +/* 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 *w) +{ + int ret; + for (int i = 0; i < w->hdr.image_count; i++) { + struct wim_lookup_table_entry *lte, *tmp; + struct wim_image_metadata *imd = w->image_metadata[i]; + image_for_each_unhashed_stream_safe(lte, tmp, imd) { + ret = hash_unhashed_stream(lte, w->lookup_table, NULL); + if (ret) + return ret; + } + } + return 0; +} + +int +can_modify_wim(WIMStruct *wim) +{ + if (wim->hdr.total_parts != 1) { + ERROR("Cannot modify \"%"TS"\": is part of a spanned set", + wim->filename); + return WIMLIB_ERR_SPLIT_UNSUPPORTED; + } + if (wim->hdr.flags & WIM_HDR_FLAG_READONLY) { + ERROR("Cannot modify \"%"TS"\": is marked read-only", + wim->filename); + return WIMLIB_ERR_WIM_IS_MARKED_READONLY; + } + return 0; +} + +int +can_delete_from_wim(WIMStruct *wim) +{ + int ret; + + ret = can_modify_wim(wim); + if (ret == 0 && !wim->all_images_verified) + ret = wim_run_full_verifications(wim); + return ret; } /* Frees the memory for the WIMStruct, including all internal memory; also @@ -635,62 +708,50 @@ wimlib_free(WIMStruct *w) if (!w) 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 + if (w->in_fd != -1) + close(w->in_fd); + if (w->out_fd != -1) + close(w->out_fd); free_lookup_table(w->lookup_table); 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++) - destroy_image_metadata(&w->image_metadata[i], NULL); + put_image_metadata(w->image_metadata[i], NULL); FREE(w->image_metadata); } -#ifdef WITH_NTFS_3G - if (w->ntfs_vol) { - DEBUG("Unmounting NTFS volume"); - ntfs_umount(w->ntfs_vol, FALSE); - } -#endif FREE(w); DEBUG("Freed WIMStruct"); } static bool -test_locale_ctype_utf8() +test_locale_ctype_utf8(void) { +#ifdef __WIN32__ + return false; +#else char *ctype = nl_langinfo(CODESET); - return (strstr(ctype, "UTF-8") == 0 || - strstr(ctype, "UTF8") == 0 || - strstr(ctype, "utf8") == 0 || - strstr(ctype, "utf-8") == 0); + return (!strstr(ctype, "UTF-8") || + !strstr(ctype, "UTF8") || + !strstr(ctype, "utf8") || + !strstr(ctype, "utf-8")); +#endif } -/* Get global memory allocations out of the way. Not strictly necessary in - * single-threaded programs like 'imagex'. */ WIMLIBAPI int -wimlib_global_init() +wimlib_global_init(int init_flags) { 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(); #endif @@ -700,7 +761,7 @@ wimlib_global_init() /* Free global memory allocations. Not strictly necessary if the process using * wimlib is just about to exit (as is the case for 'imagex'). */ WIMLIBAPI void -wimlib_global_cleanup() +wimlib_global_cleanup(void) { libxml_global_cleanup(); iconv_global_cleanup();