X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwim.c;h=cfe100d69b516fcb0633c1ad784496b9c2f39880;hp=27cf93f4587f3e477da4a33a1ffdc85cd2e9f3cf;hb=c9482ee98e12fa3f1073e4fc3c56f5eef3c40f32;hpb=f9695b9f40035f1a20968293255761a8301eaba0 diff --git a/src/wim.c b/src/wim.c index 27cf93f4..cfe100d6 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,12 +71,13 @@ image_print_files(WIMStruct *w) } static WIMStruct * -new_wim_struct() +new_wim_struct(void) { WIMStruct *w = CALLOC(1, sizeof(WIMStruct)); - w->in_fd = INVALID_FILEDES; - w->out_fd = INVALID_FILEDES; - w->current_image = WIMLIB_NO_IMAGE; + if (w) { + w->in_fd = -1; + w->out_fd = -1; + } return w; } @@ -105,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. */ @@ -149,6 +143,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: @@ -196,7 +192,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 @@ -216,7 +212,7 @@ select_wim_image(WIMStruct *w, int image) WIMLIBAPI int wimlib_get_compression_type(const WIMStruct *w) { - return wim_hdr_flags_compression_type(w->hdr.flags); + return w->compression_type; } WIMLIBAPI const tchar * @@ -282,7 +278,7 @@ wimlib_print_wim_information(const WIMStruct *w) 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))); + wimlib_get_compression_type_string(w->compression_type)); 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"), @@ -356,15 +352,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) + 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; - w->hdr.boot_idx = boot_idx; + wim->hdr.boot_idx = boot_idx; return 0; } @@ -384,11 +381,11 @@ wimlib_get_boot_idx(const WIMStruct *w) } static int -do_open_wim(const tchar *filename, filedes_t *fd_ret) +do_open_wim(const tchar *filename, int *fd_ret) { int fd; - fd = open(filename, O_RDONLY); + fd = topen(filename, O_RDONLY | O_BINARY); if (fd == -1) { ERROR_WITH_ERRNO("Can't open \"%"TS"\" read-only", filename); return WIMLIB_ERR_OPEN; @@ -400,15 +397,17 @@ do_open_wim(const tchar *filename, filedes_t *fd_ret) int reopen_wim(WIMStruct *w) { - wimlib_assert(w->in_fd == INVALID_FILEDES); + wimlib_assert(w->in_fd == -1); return do_open_wim(w->filename, &w->in_fd); } int close_wim(WIMStruct *w) { - close(w->in_fd); - w->in_fd = INVALID_FILEDES; + if (w->in_fd != -1) { + close(w->in_fd); + w->in_fd = -1; + } return 0; } @@ -450,10 +449,28 @@ begin_read(WIMStruct *w, const tchar *in_wim_path, int open_flags, return WIMLIB_ERR_OPEN; } - ret = read_header(w->in_fd, &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 */ @@ -464,10 +481,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) { @@ -515,24 +547,31 @@ 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; + ret = WIMLIB_ERR_INVALID_PARAM; + if (!wim_file || !wim_ret) + goto out; - w = new_wim_struct(); - if (!w) - return WIMLIB_ERR_NOMEM; + 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_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; } @@ -543,7 +582,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) { @@ -596,7 +635,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; @@ -659,6 +698,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 @@ -668,9 +763,9 @@ wimlib_free(WIMStruct *w) if (!w) return; - if (w->in_fd != INVALID_FILEDES) + if (w->in_fd != -1) close(w->in_fd); - if (w->out_fd != INVALID_FILEDES) + if (w->out_fd != -1) close(w->out_fd); free_lookup_table(w->lookup_table); @@ -687,7 +782,7 @@ wimlib_free(WIMStruct *w) } static bool -test_locale_ctype_utf8() +test_locale_ctype_utf8(void) { #ifdef __WIN32__ return false; @@ -721,7 +816,7 @@ wimlib_global_init(int init_flags) /* 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();