X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwim.c;h=ba0702f7949a4260650182b25de720409046fac6;hp=25b5c3367d9e2bd7421b6889a2234f22333756a4;hb=7c9fba5efecc3fd82b423238d1a4fe090f04e7f9;hpb=394c5bd3292c0f3168416c0a5f25989e557b3cfc diff --git a/src/wim.c b/src/wim.c index 25b5c336..ba0702f7 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,32 +21,43 @@ * along with wimlib; if not, see http://www.gnu.org/licenses/. */ -#include "config.h" +#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 "wimlib/ntfs_3g.h" /* for do_ntfs_umount() */ +#endif +#include "wimlib/security.h" +#include "wimlib/wim.h" +#include "wimlib/xml.h" + +#ifdef __WIN32__ +# include "wimlib/win32.h" /* for realpath() replacement */ +#endif #include #include +#ifndef __WIN32__ +# include +#endif #include #include #include #include -#ifdef __WIN32__ -# include "win32.h" -#else -# include -#endif - -#include "buffer_io.h" -#include "dentry.h" -#include "lookup_table.h" -#include "wimlib_internal.h" -#include "xml.h" - 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); } @@ -62,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; - } /* @@ -110,22 +115,6 @@ for_image(WIMStruct *w, int image, int (*visitor)(WIMStruct *)) 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. */ @@ -136,6 +125,8 @@ wimlib_create_new_wim(int ctype, WIMStruct **w_ret) 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)); @@ -154,6 +145,8 @@ wimlib_create_new_wim(int ctype, WIMStruct **w_ret) goto out_free; } w->lookup_table = table; + w->refcnts_ok = 1; + w->compression_type = ctype; *w_ret = w; return 0; out_free: @@ -161,12 +154,6 @@ out_free: return ret; } -WIMLIBAPI int -wimlib_get_num_images(const WIMStruct *w) -{ - return w->hdr.image_count; -} - int select_wim_image(WIMStruct *w, int image) { @@ -201,7 +188,7 @@ select_wim_image(WIMStruct *w, int image) } w->current_image = image; imd = wim_get_current_image_metadata(w); - if (imd->root_dentry) { + if (imd->root_dentry || imd->modified) { ret = 0; } else { #ifdef ENABLE_DEBUG @@ -217,13 +204,6 @@ select_wim_image(WIMStruct *w, int image) } -/* 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); -} - WIMLIBAPI const tchar * wimlib_get_compression_type_string(int ctype) { @@ -274,35 +254,31 @@ wimlib_resolve_image(WIMStruct *w, const tchar *image_name_or_num) /* Prints some basic information about a WIM file. */ WIMLIBAPI void -wimlib_print_wim_information(const WIMStruct *w) +wimlib_print_wim_information(const WIMStruct *wim) { - const struct wim_header *hdr; + struct wimlib_wim_info info; + + wimlib_get_wim_info((WIMStruct*)wim, &info); - hdr = &w->hdr; tputs(T("WIM Information:")); tputs(T("----------------")); - tprintf(T("Path: %"TS"\n"), w->filename); + tprintf(T("Path: %"TS"\n"), wim->filename); tfputs(T("GUID: 0x"), stdout); - print_byte_field(hdr->guid, WIM_GID_LEN, stdout); + print_byte_field(info.guid, WIM_GID_LEN, stdout); tputchar(T('\n')); - tprintf(T("Image Count: %d\n"), hdr->image_count); + tprintf(T("Image Count: %d\n"), info.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)); + wimlib_get_compression_type_string(info.compression_type)); + tprintf(T("Part Number: %d/%d\n"), info.part_number, info.total_parts); + tprintf(T("Boot Index: %d\n"), info.boot_index); + tprintf(T("Size: %"PRIu64" bytes\n"), info.total_bytes); tprintf(T("Integrity Info: %"TS"\n"), - (w->hdr.integrity.offset != 0) ? T("yes") : T("no")); + info.has_integrity_table ? T("yes") : T("no")); + tprintf(T("Relative path junction: %"TS"\n"), + info.has_rpfix ? T("yes") : T("no")); tputchar(T('\n')); } -WIMLIBAPI bool -wimlib_has_integrity_table(const WIMStruct *w) -{ - return w->hdr.integrity.size != 0; -} - WIMLIBAPI void wimlib_print_available_images(const WIMStruct *w, int image) { @@ -357,33 +333,169 @@ wimlib_print_files(WIMStruct *w, int image) return for_image(w, image, image_print_files); } -/* Sets the index of the bootable image. */ WIMLIBAPI int -wimlib_set_boot_idx(WIMStruct *w, int boot_idx) +wimlib_get_wim_info(WIMStruct *wim, struct wimlib_wim_info *info) { - 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; + 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; + if (wim->wim_info) + info->total_bytes = wim->wim_info->total_bytes; + else + info->total_bytes = 0; + info->has_integrity_table = wim->hdr.integrity.offset != 0; + 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; return 0; } + +/* Deprecated */ +WIMLIBAPI int +wimlib_get_boot_idx(const WIMStruct *wim) +{ + struct wimlib_wim_info info; + + wimlib_get_wim_info((WIMStruct*)wim, &info); + return info.boot_index; +} + +/* Deprecated */ +WIMLIBAPI int +wimlib_get_compression_type(const WIMStruct *wim) +{ + struct wimlib_wim_info info; + + wimlib_get_wim_info((WIMStruct*)wim, &info); + return info.compression_type; +} + +/* Deprecated */ +WIMLIBAPI int +wimlib_get_num_images(const WIMStruct *wim) +{ + struct wimlib_wim_info info; + + wimlib_get_wim_info((WIMStruct*)wim, &info); + return info.image_count; +} + +/* Deprecated */ WIMLIBAPI int -wimlib_get_part_number(const WIMStruct *w, int *total_parts_ret) +wimlib_get_part_number(const WIMStruct *wim, int *total_parts_ret) { + struct wimlib_wim_info info; + + wimlib_get_wim_info((WIMStruct*)wim, &info); if (total_parts_ret) - *total_parts_ret = w->hdr.total_parts; - return w->hdr.part_number; + *total_parts_ret = info.total_parts; + return info.part_number; } +/* Deprecated */ +WIMLIBAPI bool +wimlib_has_integrity_table(const WIMStruct *wim) +{ + struct wimlib_wim_info info; + + wimlib_get_wim_info((WIMStruct*)wim, &info); + return info.has_integrity_table; +} WIMLIBAPI int -wimlib_get_boot_idx(const WIMStruct *w) +wimlib_set_wim_info(WIMStruct *wim, const struct wimlib_wim_info *info, int which) { - return w->hdr.boot_idx; + 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); + + if (which & WIMLIB_CHANGE_BOOT_INDEX) { + if (info->boot_index < 0 || 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; + } + return 0; +} + +/* Deprecated */ +WIMLIBAPI int +wimlib_set_boot_idx(WIMStruct *wim, int boot_idx) +{ + struct wimlib_wim_info info; + + info.boot_index = boot_idx; + return wimlib_set_wim_info(wim, &info, WIMLIB_CHANGE_BOOT_INDEX); +} + +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; } /* @@ -399,12 +511,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 @@ -427,10 +536,28 @@ 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); + ret = read_header(w->filename, w->in_fd, &w->hdr); if (ret) return ret; + if (w->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.", in_wim_path); + } + + if (open_flags & WIMLIB_OPEN_FLAG_WRITE_ACCESS) { + ret = can_modify_wim(w); + if (ret) + return ret; + } + + if (w->hdr.total_parts != 1 && !(open_flags & WIMLIB_OPEN_FLAG_SPLIT_OK)) { + ERROR("\"%"TS"\": This WIM is part %u of a %u-part WIM", + in_wim_path, w->hdr.part_number, w->hdr.total_parts); + return WIMLIB_ERR_SPLIT_UNSUPPORTED; + } + DEBUG("According to header, WIM contains %u images", w->hdr.image_count); /* If the boot index is invalid, print a warning and set it to 0 */ @@ -441,10 +568,25 @@ begin_read(WIMStruct *w, const tchar *in_wim_path, int open_flags, w->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 (w->hdr.flags & WIM_HDR_FLAG_COMPRESSION) { + if (w->hdr.flags & WIM_HDR_FLAG_COMPRESS_LZX) { + if (w->hdr.flags & WIM_HDR_FLAG_COMPRESS_XPRESS) { + ERROR("Multiple compression flags are set in \"%"TS"\"", + in_wim_path); + return WIMLIB_ERR_INVALID_COMPRESSION_TYPE; + } + w->compression_type = WIMLIB_COMPRESSION_TYPE_LZX; + } else if (w->hdr.flags & WIM_HDR_FLAG_COMPRESS_XPRESS) { + w->compression_type = WIMLIB_COMPRESSION_TYPE_XPRESS; + } else { + ERROR("The compression flag is set on \"%"TS"\", but " + "neither the XPRESS nor LZX flag is set", + in_wim_path); + return WIMLIB_ERR_INVALID_COMPRESSION_TYPE; + } + } else { + BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_NONE != 0); } if (open_flags & WIMLIB_OPEN_FLAG_CHECK_INTEGRITY) { @@ -470,8 +612,7 @@ begin_read(WIMStruct *w, const tchar *in_wim_path, int open_flags, if (ret) return ret; - ret = read_xml_data(w->fp, &w->hdr.xml_res_entry, - &w->xml_data, &w->wim_info); + ret = read_xml_data(w->in_fd, &w->hdr.xml_res_entry, &w->wim_info); if (ret) return ret; @@ -493,24 +634,33 @@ begin_read(WIMStruct *w, const tchar *in_wim_path, int open_flags, */ WIMLIBAPI int wimlib_open_wim(const tchar *wim_file, int open_flags, - WIMStruct **w_ret, + 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_file || !wim_ret) + goto out; - ret = begin_read(w, wim_file, open_flags, progress_func); - if (ret == 0) - *w_ret = w; - else - wimlib_free(w); + ret = WIMLIB_ERR_NOMEM; + wim = new_wim_struct(); + if (!wim) + goto out; + + ret = begin_read(wim, wim_file, 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; } @@ -521,7 +671,7 @@ 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) { @@ -537,7 +687,7 @@ destroy_image_metadata(struct wim_image_metadata *imd, INIT_LIST_HEAD(&imd->inode_list); #ifdef WITH_NTFS_3G if (imd->ntfs_vol) { - do_ntfs_umount(imd->ntfs_vol); + do_ntfs_umount(imd->ntfs_vol); imd->ntfs_vol = NULL; } #endif @@ -574,7 +724,7 @@ append_image_metadata(WIMStruct *w, struct wim_image_metadata *imd) struct wim_image_metadata * -new_image_metadata() +new_image_metadata(void) { struct wim_image_metadata *imd; @@ -627,10 +777,8 @@ 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; - list_for_each_entry_safe(lte, tmp, - &w->image_metadata[i]->unhashed_streams, - unhashed_list) - { + 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; @@ -639,6 +787,62 @@ wim_checksum_unhashed_streams(WIMStruct *w) 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 spanned set", + 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; +} + /* Frees the memory for the WIMStruct, including all internal memory; also * closes all files associated with the WIMStruct. */ WIMLIBAPI void @@ -648,25 +852,14 @@ 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++) @@ -678,7 +871,7 @@ wimlib_free(WIMStruct *w) } static bool -test_locale_ctype_utf8() +test_locale_ctype_utf8(void) { #ifdef __WIN32__ return false; @@ -692,26 +885,32 @@ test_locale_ctype_utf8() #endif } -/* Get global memory allocations out of the way, - * single-threaded programs like 'imagex'. */ WIMLIBAPI int -wimlib_global_init() +wimlib_global_init(int init_flags) { + static bool already_inited = false; + + 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(); #endif + already_inited = true; return 0; } /* 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();