X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwin32_apply.c;h=0367719558a6d9a747b1b284f71672b5d5f41d77;hp=507bde86e178862e339e2c43bdee4ff27956a677;hb=8b709192cd2811b83c248fbe61ca4f11ee9de797;hpb=b5ae4e48d30124e356aaf680e19622dc540b3836 diff --git a/src/win32_apply.c b/src/win32_apply.c index 507bde86..03677195 100644 --- a/src/win32_apply.c +++ b/src/win32_apply.c @@ -3,7 +3,7 @@ */ /* - * Copyright (C) 2013, 2014 Eric Biggers + * Copyright (C) 2013, 2014, 2015 Eric Biggers * * This file is free software; you can redistribute it and/or modify it under * the terms of the GNU Lesser General Public License as published by the Free @@ -28,16 +28,20 @@ #include "wimlib/win32_common.h" #include "wimlib/apply.h" +#include "wimlib/assert.h" +#include "wimlib/blob_table.h" #include "wimlib/capture.h" /* for mangle_pat() and match_pattern_list() */ #include "wimlib/dentry.h" +#include "wimlib/encoding.h" #include "wimlib/error.h" -#include "wimlib/lookup_table.h" #include "wimlib/metadata.h" +#include "wimlib/paths.h" +#include "wimlib/pattern.h" #include "wimlib/reparse.h" #include "wimlib/textfile.h" #include "wimlib/xml.h" -#include "wimlib/wildcard.h" #include "wimlib/wimboot.h" +#include "wimlib/wof.h" struct win32_apply_ctx { @@ -47,14 +51,27 @@ struct win32_apply_ctx { /* WIMBoot information, only filled in if WIMLIB_EXTRACT_FLAG_WIMBOOT * was provided */ struct { - u64 data_source_id; - struct string_set *prepopulate_pats; - void *mem_prepopulate_pats; - u8 wim_lookup_table_hash[SHA1_HASH_SIZE]; + /* This array contains the WIM files registered with WOF on the + * target volume for this extraction operation. All WIMStructs + * in this array are distinct and have ->filename != NULL. */ + struct wimboot_wim { + WIMStruct *wim; + u64 data_source_id; + u8 blob_table_hash[SHA1_HASH_SIZE]; + } *wims; + size_t num_wims; bool wof_running; - bool tried_to_load_prepopulate_list; + bool have_wrong_version_wims; + bool have_uncompressed_wims; + bool have_unsupported_compressed_resources; + bool have_huge_resources; } wimboot; + /* External backing information */ + struct string_set *prepopulate_pats; + void *mem_prepopulate_pats; + bool tried_to_load_prepopulate_list; + /* Open handle to the target directory */ HANDLE h_target; @@ -76,7 +93,7 @@ struct win32_apply_ctx { * target-relative NT paths */ wchar_t *print_buffer; - /* Allocated buffer for reading stream data when it cannot be extracted + /* Allocated buffer for reading blob data when it cannot be extracted * directly */ u8 *data_buffer; @@ -101,20 +118,20 @@ struct win32_apply_ctx { /* Array of open handles to filesystem streams currently being written */ - HANDLE open_handles[MAX_OPEN_STREAMS]; + HANDLE open_handles[MAX_OPEN_FILES]; /* Number of handles in @open_handles currently open (filled in from the * beginning of the array) */ unsigned num_open_handles; - /* List of dentries, joined by @tmp_list, that need to have reparse data - * extracted as soon as the whole stream has been read into + /* List of dentries, joined by @d_tmp_list, that need to have reparse + * data extracted as soon as the whole blob has been read into * @data_buffer. */ struct list_head reparse_dentries; - /* List of dentries, joined by @tmp_list, that need to have raw - * encrypted data extracted as soon as the whole stream has been read - * into @data_buffer. */ + /* List of dentries, joined by @d_tmp_list, that need to have raw + * encrypted data extracted as soon as the whole blob has been read into + * @data_buffer. */ struct list_head encrypted_dentries; /* Number of files for which we didn't have permission to set the full @@ -131,6 +148,9 @@ struct win32_apply_ctx { /* Number of files for which we couldn't remove the short name. */ unsigned long num_remove_short_name_failures; + /* Number of files on which we couldn't set System Compression. */ + unsigned long num_system_compression_failures; + /* Have we tried to enable short name support on the target volume yet? */ bool tried_to_enable_short_names; @@ -176,11 +196,9 @@ get_vol_flags(const wchar_t *target, DWORD *vol_flags_ret, vol_flags_ret, filesystem_name, ARRAY_LEN(filesystem_name))) { - DWORD err = GetLastError(); - set_errno_from_win32_error(err); - WARNING_WITH_ERRNO("Failed to get volume information for " - "\"%ls\" (err=%"PRIu32")", - target, (u32)err); + win32_warning(GetLastError(), + L"Failed to get volume information for \"%ls\"", + target); return; } @@ -202,6 +220,23 @@ static void build_extraction_path(const struct wim_dentry *dentry, struct win32_apply_ctx *ctx); +static int +report_dentry_apply_error(const struct wim_dentry *dentry, + struct win32_apply_ctx *ctx, int ret) +{ + build_extraction_path(dentry, ctx); + return report_apply_error(&ctx->common, ret, current_path(ctx)); +} + +static inline int +check_apply_error(const struct wim_dentry *dentry, + struct win32_apply_ctx *ctx, int ret) +{ + if (unlikely(ret)) + ret = report_dentry_apply_error(dentry, ctx, ret); + return ret; +} + static int win32_get_supported_features(const wchar_t *target, struct wim_features *supported_features) @@ -252,34 +287,55 @@ win32_get_supported_features(const wchar_t *target, return 0; } -/* Load the patterns from [PrepopulateList] of WimBootCompress.ini in the WIM - * image being extracted. */ +#define COMPACT_FLAGS (WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K | \ + WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K | \ + WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K | \ + WIMLIB_EXTRACT_FLAG_COMPACT_LZX) + + + +/* + * If not done already, load the patterns from the [PrepopulateList] section of + * WimBootCompress.ini in the WIM image being extracted. + * + * Note: WimBootCompress.ini applies to both types of "external backing": + * + * - WIM backing ("WIMBoot" - Windows 8.1 and later) + * - File backing ("System Compression" - Windows 10 and later) + */ static int load_prepopulate_pats(struct win32_apply_ctx *ctx) { const wchar_t *path = L"\\Windows\\System32\\WimBootCompress.ini"; struct wim_dentry *dentry; - struct wim_lookup_table_entry *lte; + const struct blob_descriptor *blob; int ret; void *buf; struct string_set *s; void *mem; struct text_file_section sec; - ctx->wimboot.tried_to_load_prepopulate_list = true; + if (ctx->tried_to_load_prepopulate_list) + return 0; + + ctx->tried_to_load_prepopulate_list = true; dentry = get_dentry(ctx->common.wim, path, WIMLIB_CASE_INSENSITIVE); if (!dentry || (dentry->d_inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_ENCRYPTED)) || - !(lte = inode_unnamed_lte(dentry->d_inode, ctx->common.wim->lookup_table))) + !(blob = inode_get_blob_for_unnamed_data_stream(dentry->d_inode, + ctx->common.wim->blob_table))) { - WARNING("%ls does not exist in WIM image!", path); + WARNING("%ls does not exist in the WIM image.\n" + " The default configuration will be used instead; it assumes that all\n" + " files are valid for external backing regardless of path, equivalent\n" + " to an empty [PrepopulateList] section.", path); return WIMLIB_ERR_PATH_DOES_NOT_EXIST; } - ret = read_full_stream_into_alloc_buf(lte, &buf); + ret = read_blob_into_alloc_buf(blob, &buf); if (ret) return ret; @@ -292,7 +348,7 @@ load_prepopulate_pats(struct win32_apply_ctx *ctx) sec.name = T("PrepopulateList"); sec.strings = s; - ret = do_load_text_file(path, buf, lte->size, &mem, &sec, 1, + ret = do_load_text_file(path, buf, blob->size, &mem, &sec, 1, LOAD_TEXT_FILE_REMOVE_QUOTES | LOAD_TEXT_FILE_NO_WARNINGS, mangle_pat); @@ -302,33 +358,19 @@ load_prepopulate_pats(struct win32_apply_ctx *ctx) FREE(s); return ret; } - ctx->wimboot.prepopulate_pats = s; - ctx->wimboot.mem_prepopulate_pats = mem; + ctx->prepopulate_pats = s; + ctx->mem_prepopulate_pats = mem; return 0; } -/* Returns %true if the specified absolute path to a file in the WIM image - * matches a pattern in [PrepopulateList] of WimBootCompress.ini. Otherwise - * returns %false. */ -static bool -in_prepopulate_list(const wchar_t *path, size_t path_nchars, - const struct win32_apply_ctx *ctx) -{ - const struct string_set *pats = ctx->wimboot.prepopulate_pats; - - if (!pats || !pats->num_strings) - return false; - - return match_pattern_list(path, path_nchars, pats); -} - /* Returns %true if the specified absolute path to a file in the WIM image can * be subject to external backing when extracted. Otherwise returns %false. */ static bool -can_externally_back_path(const wchar_t *path, size_t path_nchars, - const struct win32_apply_ctx *ctx) +can_externally_back_path(const wchar_t *path, const struct win32_apply_ctx *ctx) { - if (in_prepopulate_list(path, path_nchars, ctx)) + /* Does the path match a pattern given in the [PrepopulateList] section + * of WimBootCompress.ini? */ + if (ctx->prepopulate_pats && match_pattern_list(path, ctx->prepopulate_pats)) return false; /* Since we attempt to modify the SYSTEM registry after it's extracted @@ -340,26 +382,115 @@ can_externally_back_path(const wchar_t *path, size_t path_nchars, * However, a WIM that wasn't specifically captured in "WIMBoot mode" * may contain SYSTEM.* files. So to make things "just work", hard-code * the pattern. */ - if (match_path(path, path_nchars, L"\\Windows\\System32\\config\\SYSTEM*", - OS_PREFERRED_PATH_SEPARATOR, false)) + if (match_path(path, L"\\Windows\\System32\\config\\SYSTEM*", false)) + return false; + + return true; +} + +/* Can the specified WIM resource be used as the source of an external backing + * for the wof.sys WIM provider? */ +static bool +is_resource_valid_for_external_backing(const struct wim_resource_descriptor *rdesc, + struct win32_apply_ctx *ctx) +{ + /* Must be the original WIM file format. This check excludes pipable + * resources and solid resources. It also excludes other resources + * contained in such files even if they would be otherwise compatible. + */ + if (rdesc->wim->hdr.magic != WIM_MAGIC || + rdesc->wim->hdr.wim_version != WIM_VERSION_DEFAULT) + { + ctx->wimboot.have_wrong_version_wims = true; + return false; + } + + /* + * Whitelist of compression types and chunk sizes supported by + * Microsoft's WOF driver. + * + * Notes: + * - Uncompressed WIMs result in BSOD. However, this only applies to + * the WIM file itself, not to uncompressed resources in a WIM file + * that is otherwise compressed. + * - XPRESS 64K sometimes appears to work, but sometimes it causes + * reads to fail with STATUS_UNSUCCESSFUL. + */ + switch (rdesc->compression_type) { + case WIMLIB_COMPRESSION_TYPE_NONE: + if (rdesc->wim->compression_type == WIMLIB_COMPRESSION_TYPE_NONE) { + ctx->wimboot.have_uncompressed_wims = true; + return false; + } + break; + case WIMLIB_COMPRESSION_TYPE_XPRESS: + switch (rdesc->chunk_size) { + case 4096: + case 8192: + case 16384: + case 32768: + break; + default: + ctx->wimboot.have_unsupported_compressed_resources = true; + return false; + } + break; + case WIMLIB_COMPRESSION_TYPE_LZX: + switch (rdesc->chunk_size) { + case 32768: + break; + default: + ctx->wimboot.have_unsupported_compressed_resources = true; + return false; + } + break; + default: + ctx->wimboot.have_unsupported_compressed_resources = true; return false; + } + + /* Microsoft's WoF driver errors out if it tries to satisfy a read with + * ending offset >= 4 GiB from an externally backed file. */ + if (rdesc->uncompressed_size > 4200000000) { + ctx->wimboot.have_huge_resources = true; + return false; + } return true; } -#define WIM_BACKING_NOT_ENABLED -1 -#define WIM_BACKING_NOT_POSSIBLE -2 -#define WIM_BACKING_EXCLUDED -3 +#define EXTERNAL_BACKING_NOT_ENABLED -1 +#define EXTERNAL_BACKING_NOT_POSSIBLE -2 +#define EXTERNAL_BACKING_EXCLUDED -3 +/* + * Determines whether the specified file will be externally backed. Returns a + * negative status code if no, 0 if yes, or a positive wimlib error code on + * error. If the file is excluded from external backing based on its path, then + * *excluded_dentry_ret is set to the dentry for the path that matched the + * exclusion rule. + * + * Note that this logic applies to both types of "external backing": + * + * - WIM backing ("WIMBoot" - Windows 8.1 and later) + * - File backing ("System Compression" - Windows 10 and later) + * + * However, in the case of WIM backing we also need to validate that the WIM + * resource that would be the source of the backing is supported by the wof.sys + * WIM provider. + */ static int will_externally_back_inode(struct wim_inode *inode, struct win32_apply_ctx *ctx, - const struct wim_dentry **excluded_dentry_ret) + const struct wim_dentry **excluded_dentry_ret, + bool wimboot_mode) { - struct list_head *next; struct wim_dentry *dentry; - struct wim_lookup_table_entry *stream; + struct blob_descriptor *blob; int ret; + if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM) + return WIMLIB_ERR_NOMEM; + if (inode->i_can_externally_back) return 0; @@ -371,142 +502,222 @@ will_externally_back_inode(struct wim_inode *inode, struct win32_apply_ctx *ctx, if (inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_ENCRYPTED)) - return WIM_BACKING_NOT_POSSIBLE; + return EXTERNAL_BACKING_NOT_POSSIBLE; + + blob = inode_get_blob_for_unnamed_data_stream_resolved(inode); - stream = inode_unnamed_lte_resolved(inode); + if (!blob) + return EXTERNAL_BACKING_NOT_POSSIBLE; - if (!stream || - stream->resource_location != RESOURCE_IN_WIM || - stream->rspec->wim != ctx->common.wim || - stream->size != stream->rspec->uncompressed_size) - return WIM_BACKING_NOT_POSSIBLE; + if (wimboot_mode && + (blob->blob_location != BLOB_IN_WIM || + !is_resource_valid_for_external_backing(blob->rdesc, ctx))) + return EXTERNAL_BACKING_NOT_POSSIBLE; /* * We need to check the patterns in [PrepopulateList] against every name * of the inode, in case any of them match. */ - next = inode->i_extraction_aliases.next; - do { - dentry = list_entry(next, struct wim_dentry, - d_extraction_alias_node); + + inode_for_each_extraction_alias(dentry, inode) { ret = calculate_dentry_full_path(dentry); if (ret) return ret; - if (!can_externally_back_path(dentry->_full_path, - wcslen(dentry->_full_path), ctx)) - { + if (!can_externally_back_path(dentry->d_full_path, ctx)) { if (excluded_dentry_ret) *excluded_dentry_ret = dentry; - return WIM_BACKING_EXCLUDED; + return EXTERNAL_BACKING_EXCLUDED; } - next = next->next; - } while (next != &inode->i_extraction_aliases); + } inode->i_can_externally_back = 1; return 0; } /* - * Determines if the unnamed data stream of a file will be created as an - * external backing, as opposed to a standard extraction. + * Determines if the unnamed data stream of a file will be created as a WIM + * external backing (a "WIMBoot pointer file"), as opposed to a standard + * extraction. */ static int -win32_will_externally_back(struct wim_dentry *dentry, struct apply_ctx *_ctx) +win32_will_back_from_wim(struct wim_dentry *dentry, struct apply_ctx *_ctx) { struct win32_apply_ctx *ctx = (struct win32_apply_ctx *)_ctx; if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) - return WIM_BACKING_NOT_ENABLED; + return EXTERNAL_BACKING_NOT_ENABLED; - if (!ctx->wimboot.tried_to_load_prepopulate_list) - if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM) - return WIMLIB_ERR_NOMEM; + return will_externally_back_inode(dentry->d_inode, ctx, NULL, true); +} + +/* Find the WOF registration information for the specified WIM file. */ +static struct wimboot_wim * +find_wimboot_wim(WIMStruct *wim_to_find, struct win32_apply_ctx *ctx) +{ + for (size_t i = 0; i < ctx->wimboot.num_wims; i++) + if (wim_to_find == ctx->wimboot.wims[i].wim) + return &ctx->wimboot.wims[i]; - return will_externally_back_inode(dentry->d_inode, ctx, NULL); + wimlib_assert(0); + return NULL; } static int -set_external_backing(HANDLE h, struct wim_inode *inode, struct win32_apply_ctx *ctx) +set_backed_from_wim(HANDLE h, struct wim_inode *inode, struct win32_apply_ctx *ctx) { int ret; const struct wim_dentry *excluded_dentry; + const struct blob_descriptor *blob; + const struct wimboot_wim *wimboot_wim; - ret = will_externally_back_inode(inode, ctx, &excluded_dentry); + ret = will_externally_back_inode(inode, ctx, &excluded_dentry, true); if (ret > 0) /* Error. */ return ret; - if (ret < 0 && ret != WIM_BACKING_EXCLUDED) + if (ret < 0 && ret != EXTERNAL_BACKING_EXCLUDED) return 0; /* Not externally backing, other than due to exclusion. */ - if (unlikely(ret == WIM_BACKING_EXCLUDED)) { + if (unlikely(ret == EXTERNAL_BACKING_EXCLUDED)) { /* Not externally backing due to exclusion. */ union wimlib_progress_info info; build_extraction_path(excluded_dentry, ctx); - info.wimboot_exclude.path_in_wim = excluded_dentry->_full_path; + info.wimboot_exclude.path_in_wim = excluded_dentry->d_full_path; info.wimboot_exclude.extraction_path = current_path(ctx); return call_progress(ctx->common.progfunc, WIMLIB_PROGRESS_MSG_WIMBOOT_EXCLUDE, &info, ctx->common.progctx); - } else { - /* Externally backing. */ - if (unlikely(!wimboot_set_pointer(h, - inode_unnamed_lte_resolved(inode), - ctx->wimboot.data_source_id, - ctx->wimboot.wim_lookup_table_hash, - ctx->wimboot.wof_running))) - { - const DWORD err = GetLastError(); - - build_extraction_path(inode_first_extraction_dentry(inode), ctx); - set_errno_from_win32_error(err); - ERROR_WITH_ERRNO("\"%ls\": Couldn't set WIMBoot " - "pointer data (err=%"PRIu32")", - current_path(ctx), (u32)err); - return WIMLIB_ERR_WIMBOOT; - } - return 0; } + + /* Externally backing. */ + + blob = inode_get_blob_for_unnamed_data_stream_resolved(inode); + wimboot_wim = find_wimboot_wim(blob->rdesc->wim, ctx); + + if (unlikely(!wimboot_set_pointer(h, + blob, + wimboot_wim->data_source_id, + wimboot_wim->blob_table_hash, + ctx->wimboot.wof_running))) + { + const DWORD err = GetLastError(); + + build_extraction_path(inode_first_extraction_dentry(inode), ctx); + win32_error(err, L"\"%ls\": Couldn't set WIMBoot pointer data", + current_path(ctx)); + return WIMLIB_ERR_WIMBOOT; + } + return 0; } -/* Calculates the SHA-1 message digest of the WIM's lookup table. */ +/* Calculates the SHA-1 message digest of the WIM's blob table. */ static int -hash_lookup_table(WIMStruct *wim, u8 hash[SHA1_HASH_SIZE]) +hash_blob_table(WIMStruct *wim, u8 hash[SHA1_HASH_SIZE]) { - return wim_reshdr_to_hash(&wim->hdr.lookup_table_reshdr, wim, hash); + return wim_reshdr_to_hash(&wim->hdr.blob_table_reshdr, wim, hash); } -/* Prepare for doing a "WIMBoot" extraction by loading patterns from - * [PrepopulateList] of WimBootCompress.ini and allocating a WOF data source ID - * on the target volume. */ static int -start_wimboot_extraction(struct win32_apply_ctx *ctx) +register_wim_with_wof(WIMStruct *wim, struct win32_apply_ctx *ctx) { + struct wimboot_wim *p; int ret; - WIMStruct *wim = ctx->common.wim; - if (!ctx->wimboot.tried_to_load_prepopulate_list) - if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM) - return WIMLIB_ERR_NOMEM; + /* Check if already registered */ + for (size_t i = 0; i < ctx->wimboot.num_wims; i++) + if (wim == ctx->wimboot.wims[i].wim) + return 0; + + /* Not yet registered */ + + p = REALLOC(ctx->wimboot.wims, + (ctx->wimboot.num_wims + 1) * sizeof(ctx->wimboot.wims[0])); + if (!p) + return WIMLIB_ERR_NOMEM; + ctx->wimboot.wims = p; - if (!wim_info_get_wimboot(wim->wim_info, wim->current_image)) - WARNING("Image is not marked as WIMBoot compatible!"); + ctx->wimboot.wims[ctx->wimboot.num_wims].wim = wim; - ret = hash_lookup_table(ctx->common.wim, - ctx->wimboot.wim_lookup_table_hash); + ret = hash_blob_table(wim, ctx->wimboot.wims[ctx->wimboot.num_wims].blob_table_hash); if (ret) return ret; - return wimboot_alloc_data_source_id(wim->filename, - wim->hdr.guid, - wim->current_image, - ctx->common.target, - &ctx->wimboot.data_source_id, - &ctx->wimboot.wof_running); + ret = wimboot_alloc_data_source_id(wim->filename, + wim->hdr.guid, + ctx->common.wim->current_image, + ctx->common.target, + &ctx->wimboot.wims[ctx->wimboot.num_wims].data_source_id, + &ctx->wimboot.wof_running); + if (ret) + return ret; + + ctx->wimboot.num_wims++; + return 0; +} + +/* Prepare for doing a "WIMBoot" extraction by registering each source WIM file + * with WOF on the target volume. */ +static int +start_wimboot_extraction(struct list_head *dentry_list, struct win32_apply_ctx *ctx) +{ + int ret; + struct wim_dentry *dentry; + + if (!wim_info_get_wimboot(ctx->common.wim->wim_info, + ctx->common.wim->current_image)) + WARNING("The WIM image is not marked as WIMBoot compatible. This usually\n" + " means it is not intended to be used to back a Windows operating\n" + " system. Proceeding anyway."); + + list_for_each_entry(dentry, dentry_list, d_extraction_list_node) { + struct blob_descriptor *blob; + + ret = win32_will_back_from_wim(dentry, &ctx->common); + if (ret > 0) /* Error */ + return ret; + if (ret < 0) /* Won't externally back */ + continue; + + blob = inode_get_blob_for_unnamed_data_stream_resolved(dentry->d_inode); + ret = register_wim_with_wof(blob->rdesc->wim, ctx); + if (ret) + return ret; + } + + if (ctx->wimboot.have_wrong_version_wims) { + WARNING("At least one of the source WIM files uses a version of the WIM\n" +" file format that not supported by Microsoft's wof.sys driver.\n" +" Files whose data is contained in one of these WIM files will be\n" +" extracted as full files rather than externally backed."); + } + + if (ctx->wimboot.have_uncompressed_wims) { + WARNING("At least one of the source WIM files is uncompressed. Files whose\n" +" data is contained in an uncompressed WIM file will be extracted as\n" +" full files rather than externally backed, since uncompressed WIM\n" +" files are not supported by Microsoft's wof.sys driver."); + } + + if (ctx->wimboot.have_unsupported_compressed_resources) { + WARNING("At least one of the source WIM files uses a compression format that\n" +" is not supported by Microsoft's wof.sys driver. Files whose data is\n" +" contained in a compressed resource in one of these WIM files will be\n" +" extracted as full files rather than externally backed. (The\n" +" compression formats supported by wof.sys are: XPRESS 4K, XPRESS 8K,\n" +" XPRESS 16K, XPRESS 32K, and LZX 32K.)"); + } + + if (ctx->wimboot.have_huge_resources) { + WARNING("Some files exceeded 4.2 GB in size. Such files will be extracted\n" +" as full files rather than externally backed, since very large files\n" +" are not supported by Microsoft's wof.sys driver."); + } + + return 0; } static void @@ -574,10 +785,9 @@ out_unload_key: out_check_res: if (res) { /* Warning only. */ - set_errno_from_win32_error(res); - WARNING_WITH_ERRNO("Failed to set \\Setup: dword \"WimBoot\"=1 value " - "in registry hive \"%ls\" (err=%"PRIu32")", - ctx->pathbuf.Buffer, (u32)res); + win32_warning(res, L"Failed to set \\Setup: dword \"WimBoot\"=1 " + "value in registry hive \"%ls\"", + ctx->pathbuf.Buffer); } out: return 0; @@ -612,13 +822,16 @@ static size_t inode_longest_named_data_stream_spec(const struct wim_inode *inode) { size_t max = 0; - for (u16 i = 0; i < inode->i_num_ads; i++) { - size_t len = inode->i_ads_entries[i].stream_name_nbytes; + for (unsigned i = 0; i < inode->i_num_streams; i++) { + const struct wim_inode_stream *strm = &inode->i_streams[i]; + if (!stream_is_named_data_stream(strm)) + continue; + size_t len = utf16le_len_chars(strm->stream_name); if (len > max) max = len; } if (max) - max = 1 + (max / sizeof(wchar_t)); + max += 1; return max; } @@ -744,26 +957,19 @@ current_path(struct win32_apply_ctx *ctx) return ctx->print_buffer; } -/* - * Ensures the target directory exists and opens a handle to it, in preparation - * of using paths relative to it. - */ +/* Open handle to the target directory if it is not already open. If the target + * directory does not exist, this creates it. */ static int -prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx) +open_target_directory(struct win32_apply_ctx *ctx) { - int ret; NTSTATUS status; - size_t path_max; - /* Open handle to the target directory (possibly creating it). */ - - ret = win32_path_to_nt_path(ctx->common.target, &ctx->target_ntpath); - if (ret) - return ret; + if (ctx->h_target) + return 0; ctx->attr.Length = sizeof(ctx->attr); + ctx->attr.RootDirectory = NULL; ctx->attr.ObjectName = &ctx->target_ntpath; - status = (*func_NtCreateFile)(&ctx->h_target, FILE_TRAVERSE, &ctx->attr, @@ -777,17 +983,45 @@ prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx) FILE_OPEN_FOR_BACKUP_INTENT, NULL, 0); - if (!NT_SUCCESS(status)) { - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't open or create directory \"%ls\" " - "(status=0x%08"PRIx32")", - ctx->common.target, (u32)status); + winnt_error(status, L"Can't open or create directory \"%ls\"", + ctx->common.target); return WIMLIB_ERR_OPENDIR; } + ctx->attr.RootDirectory = ctx->h_target; + ctx->attr.ObjectName = &ctx->pathbuf; + return 0; +} - path_max = compute_path_max(dentry_list); +static void +close_target_directory(struct win32_apply_ctx *ctx) +{ + if (ctx->h_target) { + (*func_NtClose)(ctx->h_target); + ctx->h_target = NULL; + ctx->attr.RootDirectory = NULL; + } +} + +/* + * Ensures the target directory exists and opens a handle to it, in preparation + * of using paths relative to it. + */ +static int +prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx) +{ + int ret; + size_t path_max; + + ret = win32_path_to_nt_path(ctx->common.target, &ctx->target_ntpath); + if (ret) + return ret; + + ret = open_target_directory(ctx); + if (ret) + return ret; + path_max = compute_path_max(dentry_list); /* Add some extra for building Win32 paths for the file encryption APIs, * and ensure we have at least enough to potentially use a 8.3 name for * the last component. */ @@ -799,9 +1033,6 @@ prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx) if (!ctx->pathbuf.Buffer) return WIMLIB_ERR_NOMEM; - ctx->attr.RootDirectory = ctx->h_target; - ctx->attr.ObjectName = &ctx->pathbuf; - ctx->print_buffer = MALLOC((ctx->common.target_nchars + 1 + path_max + 1) * sizeof(wchar_t)); if (!ctx->print_buffer) @@ -816,17 +1047,12 @@ prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx) static struct wim_dentry * first_extraction_alias(const struct wim_inode *inode) { - struct list_head *next = inode->i_extraction_aliases.next; struct wim_dentry *dentry; - do { - dentry = list_entry(next, struct wim_dentry, - d_extraction_alias_node); + inode_for_each_extraction_alias(dentry, inode) if (dentry_has_short_name(dentry)) - break; - next = next->next; - } while (next != &inode->i_extraction_aliases); - return dentry; + return dentry; + return inode_first_extraction_dentry(inode); } /* @@ -884,81 +1110,11 @@ adjust_compression_attribute(HANDLE h, const struct wim_dentry *dentry, if (NT_SUCCESS(status)) return 0; - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't %s compression attribute on \"%ls\" " - "(status=0x%08"PRIx32")", - (compressed ? "set" : "clear"), - current_path(ctx), status); + winnt_error(status, L"Can't %s compression attribute on \"%ls\"", + (compressed ? "set" : "clear"), current_path(ctx)); return WIMLIB_ERR_SET_ATTRIBUTES; } -/* - * Clear FILE_ATTRIBUTE_ENCRYPTED if the file or directory is not supposed to be - * encrypted. - * - * You can provide FILE_ATTRIBUTE_ENCRYPTED to NtCreateFile() to set it on the - * created file. However, the file or directory will otherwise default to the - * encryption state of the parent directory. This function works around this - * limitation by using DecryptFile() to remove FILE_ATTRIBUTE_ENCRYPTED on files - * (and directories) that are not supposed to have it set. - * - * Regardless of whether it succeeds or fails, this function may close the - * handle to the file. If it does, it sets it to NULL. - */ -static int -maybe_clear_encryption_attribute(HANDLE *h_ptr, const struct wim_dentry *dentry, - struct win32_apply_ctx *ctx) -{ - if (dentry->d_inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED) - return 0; - - if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES) - return 0; - - if (!ctx->common.supported_features.encrypted_files) - return 0; - - FILE_BASIC_INFORMATION info; - NTSTATUS status; - BOOL bret; - - /* Get current attributes */ - status = (*func_NtQueryInformationFile)(*h_ptr, &ctx->iosb, - &info, sizeof(info), - FileBasicInformation); - if (NT_SUCCESS(status) && - !(info.FileAttributes & FILE_ATTRIBUTE_ENCRYPTED)) - { - /* Nothing needs to be done. */ - return 0; - } - - /* Set the new encryption state */ - - /* Due to Windows' crappy file encryption APIs, we need to close the - * handle to the file so we don't get ERROR_SHARING_VIOLATION. We also - * hack together a Win32 path, although we will use the \\?\ prefix so - * it will actually be a NT path in disguise... */ - (*func_NtClose)(*h_ptr); - *h_ptr = NULL; - - build_win32_extraction_path(dentry, ctx); - - bret = DecryptFile(ctx->pathbuf.Buffer, 0); - - /* Restore the NT namespace path */ - build_extraction_path(dentry, ctx); - - if (!bret) { - DWORD err = GetLastError(); - set_errno_from_win32_error(err); - ERROR_WITH_ERRNO("Can't decrypt file \"%ls\" (err=%"PRIu32")", - current_path(ctx), (u32)err); - return WIMLIB_ERR_SET_ATTRIBUTES; - } - return 0; -} - /* Try to enable short name support on the target volume. If successful, return * true. If unsuccessful, issue a warning and return false. */ static bool @@ -991,8 +1147,9 @@ try_to_enable_short_names(const wchar_t *volume) return true; fail: - WARNING("Failed to enable short name support on %ls " - "(err=%"PRIu32")", volume + 4, (u32)GetLastError()); + win32_warning(GetLastError(), + L"Failed to enable short name support on %ls", + volume + 4); return false; } @@ -1015,7 +1172,7 @@ remove_conflicting_short_name(const struct wim_dentry *dentry, struct win32_appl name = &ctx->pathbuf.Buffer[ctx->pathbuf.Length / sizeof(wchar_t)]; while (name != ctx->pathbuf.Buffer && *(name - 1) != L'\\') name--; - end = mempcpy(name, dentry->short_name, dentry->short_name_nbytes); + end = mempcpy(name, dentry->d_short_name, dentry->d_short_name_nbytes); ctx->pathbuf.Length = ((u8 *)end - (u8 *)ctx->pathbuf.Buffer); /* Open the conflicting file (by short name). */ @@ -1024,8 +1181,7 @@ remove_conflicting_short_name(const struct wim_dentry *dentry, struct win32_appl FILE_SHARE_VALID_FLAGS, FILE_OPEN_REPARSE_POINT | FILE_OPEN_FOR_BACKUP_INTENT); if (!NT_SUCCESS(status)) { - WARNING("Can't open \"%ls\" (status=0x%08"PRIx32")", - current_path(ctx), (u32)status); + winnt_warning(status, L"Can't open \"%ls\"", current_path(ctx)); goto out; } @@ -1093,7 +1249,7 @@ set_short_name(HANDLE h, const struct wim_dentry *dentry, */ size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) + - max(dentry->short_name_nbytes, sizeof(wchar_t)) + + max(dentry->d_short_name_nbytes, sizeof(wchar_t)) + sizeof(wchar_t); u8 buf[bufsize] _aligned_attribute(8); FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf; @@ -1102,8 +1258,8 @@ set_short_name(HANDLE h, const struct wim_dentry *dentry, memset(buf, 0, bufsize); - info->FileNameLength = dentry->short_name_nbytes; - memcpy(info->FileName, dentry->short_name, dentry->short_name_nbytes); + info->FileNameLength = dentry->d_short_name_nbytes; + memcpy(info->FileName, dentry->d_short_name, dentry->d_short_name_nbytes); retry: status = (*func_NtSetInformationFile)(h, &ctx->iosb, info, bufsize, @@ -1112,7 +1268,7 @@ retry: return 0; if (status == STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME) { - if (dentry->short_name_nbytes == 0) + if (dentry->d_short_name_nbytes == 0) return 0; if (!ctx->tried_to_enable_short_names) { wchar_t volume[7]; @@ -1146,7 +1302,7 @@ retry: * from files. */ if (unlikely(status == STATUS_OBJECT_NAME_COLLISION) && - dentry->short_name_nbytes && !tried_to_remove_existing) + dentry->d_short_name_nbytes && !tried_to_remove_existing) { tried_to_remove_existing = true; status = remove_conflicting_short_name(dentry, ctx); @@ -1157,20 +1313,14 @@ retry: /* By default, failure to set short names is not an error (since short * names aren't too important anymore...). */ if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SHORT_NAMES)) { - if (dentry->short_name_nbytes) + if (dentry->d_short_name_nbytes) ctx->num_set_short_name_failures++; else ctx->num_remove_short_name_failures++; return 0; } - if (status == STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME) { - ERROR("Can't set short name when short " - "names are not enabled on the volume!"); - } else { - ERROR("Can't set short name on \"%ls\" (status=0x%08"PRIx32")", - current_path(ctx), (u32)status); - } + winnt_error(status, L"Can't set short name on \"%ls\"", current_path(ctx)); return WIMLIB_ERR_SET_SHORT_NAME; } @@ -1227,115 +1377,270 @@ create_file(PHANDLE FileHandle, ctx); } -/* Create empty named data streams. - * - * Since these won't have 'struct wim_lookup_table_entry's, they won't show up - * in the call to extract_stream_list(). Hence the need for the special case. - */ static int -create_any_empty_ads(const struct wim_dentry *dentry, - struct win32_apply_ctx *ctx) +delete_file_or_stream(struct win32_apply_ctx *ctx) { - const struct wim_inode *inode = dentry->d_inode; - LARGE_INTEGER allocation_size; - bool path_modified = false; - int ret = 0; - - if (!ctx->common.supported_features.named_data_streams) - return 0; - - for (u16 i = 0; i < inode->i_num_ads; i++) { - const struct wim_ads_entry *entry; - NTSTATUS status; - HANDLE h; - - entry = &inode->i_ads_entries[i]; - - /* Not named? */ - if (!entry->stream_name_nbytes) - continue; + NTSTATUS status; + HANDLE h; + FILE_DISPOSITION_INFORMATION disposition_info; + FILE_BASIC_INFORMATION basic_info; + bool retried = false; - /* Not empty? */ - if (entry->lte) - continue; + status = do_create_file(&h, + DELETE, + NULL, + 0, + FILE_OPEN, + FILE_NON_DIRECTORY_FILE, + ctx); + if (unlikely(!NT_SUCCESS(status))) { + winnt_error(status, L"Can't open \"%ls\" for deletion", + current_path(ctx)); + return WIMLIB_ERR_OPEN; + } - /* Probably setting the allocation size to 0 has no effect, but - * we might as well try. */ - allocation_size.QuadPart = 0; +retry: + disposition_info.DoDeleteFile = TRUE; + status = (*func_NtSetInformationFile)(h, &ctx->iosb, + &disposition_info, + sizeof(disposition_info), + FileDispositionInformation); + (*func_NtClose)(h); + if (likely(NT_SUCCESS(status))) + return 0; - build_extraction_path_with_ads(dentry, ctx, - entry->stream_name, - entry->stream_name_nbytes / - sizeof(wchar_t)); - path_modified = true; - status = do_create_file(&h, FILE_WRITE_DATA, &allocation_size, - 0, FILE_SUPERSEDE, 0, ctx); + if (status == STATUS_CANNOT_DELETE && !retried) { + /* Clear file attributes and try again. This is necessary for + * FILE_ATTRIBUTE_READONLY files. */ + status = do_create_file(&h, + FILE_WRITE_ATTRIBUTES | DELETE, + NULL, + 0, + FILE_OPEN, + FILE_NON_DIRECTORY_FILE, + ctx); if (!NT_SUCCESS(status)) { - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't create \"%ls\" " - "(status=0x%08"PRIx32")", - current_path(ctx), (u32)status); - ret = WIMLIB_ERR_OPEN; - break; + winnt_error(status, + L"Can't open \"%ls\" to reset attributes", + current_path(ctx)); + return WIMLIB_ERR_OPEN; + } + memset(&basic_info, 0, sizeof(basic_info)); + basic_info.FileAttributes = FILE_ATTRIBUTE_NORMAL; + status = (*func_NtSetInformationFile)(h, &ctx->iosb, + &basic_info, + sizeof(basic_info), + FileBasicInformation); + if (!NT_SUCCESS(status)) { + winnt_error(status, + L"Can't reset file attributes on \"%ls\"", + current_path(ctx)); + (*func_NtClose)(h); + return WIMLIB_ERR_SET_ATTRIBUTES; } - (*func_NtClose)(h); + retried = true; + goto retry; } - /* Restore the path to the dentry itself */ - if (path_modified) - build_extraction_path(dentry, ctx); - return ret; + winnt_error(status, L"Can't delete \"%ls\"", current_path(ctx)); + return WIMLIB_ERR_OPEN; } /* - * Creates the directory named by @dentry, or uses an existing directory at that - * location. If necessary, sets the short name and/or fixes compression and - * encryption attributes. - * - * Returns 0, WIMLIB_ERR_MKDIR, or WIMLIB_ERR_SET_SHORT_NAME. + * Create a nondirectory file or named data stream at the current path, + * superseding any that already exists at that path. If successful, return an + * open handle to the file or named data stream. */ static int -create_directory(const struct wim_dentry *dentry, - struct win32_apply_ctx *ctx) +supersede_file_or_stream(struct win32_apply_ctx *ctx, HANDLE *h_ret) { - HANDLE h; NTSTATUS status; - int ret; - ULONG attrib; + bool retried = false; - /* Special attributes: - * - * Use FILE_ATTRIBUTE_ENCRYPTED if the directory needs to have it set. - * This doesn't work for FILE_ATTRIBUTE_COMPRESSED (unfortunately). - * - * Don't specify FILE_ATTRIBUTE_DIRECTORY; it gets set anyway as a - * result of the FILE_DIRECTORY_FILE option. */ - attrib = (dentry->d_inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED); - - /* DELETE is needed for set_short_name(). - * GENERIC_READ and GENERIC_WRITE are needed for - * adjust_compression_attribute(). */ - status = create_file(&h, GENERIC_READ | GENERIC_WRITE | DELETE, NULL, - attrib, FILE_OPEN_IF, FILE_DIRECTORY_FILE, - dentry, ctx); - if (!NT_SUCCESS(status)) { - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't create directory \"%ls\" " - "(status=0x%08"PRIx32")", - current_path(ctx), (u32)status); - return WIMLIB_ERR_MKDIR; - } + /* FILE_ATTRIBUTE_SYSTEM is needed to ensure that + * FILE_ATTRIBUTE_ENCRYPTED doesn't get set before we want it to be. */ +retry: + status = do_create_file(h_ret, + GENERIC_READ | GENERIC_WRITE | DELETE, + NULL, + FILE_ATTRIBUTE_SYSTEM, + FILE_CREATE, + FILE_NON_DIRECTORY_FILE, + ctx); + if (likely(NT_SUCCESS(status))) + return 0; - ret = set_short_name(h, dentry, ctx); + /* STATUS_OBJECT_NAME_COLLISION means that the file or stream already + * exists. Delete the existing file or stream, then try again. + * + * Note: we don't use FILE_OVERWRITE_IF or FILE_SUPERSEDE because of + * problems with certain file attributes, especially + * FILE_ATTRIBUTE_ENCRYPTED. FILE_SUPERSEDE is also broken in the + * Windows PE ramdisk. */ + if (status == STATUS_OBJECT_NAME_COLLISION && !retried) { + int ret = delete_file_or_stream(ctx); + if (ret) + return ret; + retried = true; + goto retry; + } + winnt_error(status, L"Can't create \"%ls\"", current_path(ctx)); + return WIMLIB_ERR_OPEN; +} - if (!ret) - ret = adjust_compression_attribute(h, dentry, ctx); +/* Set the reparse point @rpbuf of length @rpbuflen on the extracted file + * corresponding to the WIM dentry @dentry. */ +static int +do_set_reparse_point(const struct wim_dentry *dentry, + const struct reparse_buffer_disk *rpbuf, u16 rpbuflen, + struct win32_apply_ctx *ctx) +{ + NTSTATUS status; + HANDLE h; - if (!ret) - ret = maybe_clear_encryption_attribute(&h, dentry, ctx); - /* May close the handle!!! */ + status = create_file(&h, GENERIC_WRITE, NULL, + 0, FILE_OPEN, 0, dentry, ctx); + if (!NT_SUCCESS(status)) + goto fail; - if (h) - (*func_NtClose)(h); + status = (*func_NtFsControlFile)(h, NULL, NULL, NULL, + &ctx->iosb, FSCTL_SET_REPARSE_POINT, + (void *)rpbuf, rpbuflen, + NULL, 0); + (*func_NtClose)(h); + + if (NT_SUCCESS(status)) + return 0; + + /* On Windows, by default only the Administrator can create symbolic + * links for some reason. By default we just issue a warning if this + * appears to be the problem. Use WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS + * to get a hard error. */ + if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS) + && (status == STATUS_PRIVILEGE_NOT_HELD || + status == STATUS_ACCESS_DENIED) + && (dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK || + dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT)) + { + WARNING("Can't create symbolic link \"%ls\"! \n" + " (Need Administrator rights, or at least " + "the\n" + " SeCreateSymbolicLink privilege.)", + current_path(ctx)); + return 0; + } + +fail: + winnt_error(status, L"Can't set reparse data on \"%ls\"", + current_path(ctx)); + return WIMLIB_ERR_SET_REPARSE_DATA; +} + +/* + * Create empty named data streams and potentially a reparse point for the + * specified file, if any. + * + * Since these won't have blob descriptors, they won't show up in the call to + * extract_blob_list(). Hence the need for the special case. + */ +static int +create_empty_streams(const struct wim_dentry *dentry, + struct win32_apply_ctx *ctx) +{ + const struct wim_inode *inode = dentry->d_inode; + int ret; + + for (unsigned i = 0; i < inode->i_num_streams; i++) { + const struct wim_inode_stream *strm = &inode->i_streams[i]; + + if (stream_blob_resolved(strm) != NULL) + continue; + + if (strm->stream_type == STREAM_TYPE_REPARSE_POINT && + ctx->common.supported_features.reparse_points) + { + u8 buf[REPARSE_DATA_OFFSET] _aligned_attribute(8); + struct reparse_buffer_disk *rpbuf = + (struct reparse_buffer_disk *)buf; + complete_reparse_point(rpbuf, inode, 0); + ret = do_set_reparse_point(dentry, rpbuf, + REPARSE_DATA_OFFSET, ctx); + if (ret) + return ret; + } else if (stream_is_named_data_stream(strm) && + ctx->common.supported_features.named_data_streams) + { + HANDLE h; + + build_extraction_path_with_ads(dentry, ctx, + strm->stream_name, + utf16le_len_chars(strm->stream_name)); + ret = supersede_file_or_stream(ctx, &h); + + build_extraction_path(dentry, ctx); + + if (ret) + return ret; + (*func_NtClose)(h); + } + } + + return 0; +} + +/* + * Creates the directory named by @dentry, or uses an existing directory at that + * location. If necessary, sets the short name and/or fixes compression and + * encryption attributes. + * + * Returns 0, WIMLIB_ERR_MKDIR, or WIMLIB_ERR_SET_SHORT_NAME. + */ +static int +create_directory(const struct wim_dentry *dentry, struct win32_apply_ctx *ctx) +{ + DWORD perms; + NTSTATUS status; + HANDLE h; + int ret; + + /* DELETE is needed for set_short_name(); GENERIC_READ and GENERIC_WRITE + * are needed for adjust_compression_attribute(). */ + perms = GENERIC_READ | GENERIC_WRITE; + if (!dentry_is_root(dentry)) + perms |= DELETE; + + /* FILE_ATTRIBUTE_SYSTEM is needed to ensure that + * FILE_ATTRIBUTE_ENCRYPTED doesn't get set before we want it to be. */ + status = create_file(&h, perms, NULL, FILE_ATTRIBUTE_SYSTEM, + FILE_OPEN_IF, FILE_DIRECTORY_FILE, dentry, ctx); + if (!NT_SUCCESS(status)) { + winnt_error(status, L"Can't create directory \"%ls\"", + current_path(ctx)); + return WIMLIB_ERR_MKDIR; + } + + if (ctx->iosb.Information == FILE_OPENED) { + /* If we opened an existing directory, try to clear its file + * attributes. As far as I know, this only actually makes a + * difference in the case where a FILE_ATTRIBUTE_READONLY + * directory has a named data stream which needs to be + * extracted. You cannot create a named data stream of such a + * directory, even though this contradicts Microsoft's + * documentation for FILE_ATTRIBUTE_READONLY which states it is + * not honored for directories! */ + FILE_BASIC_INFORMATION basic_info = { .FileAttributes = FILE_ATTRIBUTE_NORMAL }; + (*func_NtSetInformationFile)(h, &ctx->iosb, &basic_info, + sizeof(basic_info), FileBasicInformation); + } + + if (!dentry_is_root(dentry)) { + ret = set_short_name(h, dentry, ctx); + if (ret) + goto out; + } + + ret = adjust_compression_attribute(h, dentry, ctx); +out: + (*func_NtClose)(h); return ret; } @@ -1362,17 +1667,14 @@ create_directories(struct list_head *dentry_list, * FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT, but we * wait until later to actually set the reparse data. */ - /* If the root dentry is being extracted, it was already done so - * in prepare_target(). */ - if (!dentry_is_root(dentry)) { - ret = create_directory(dentry, ctx); - if (ret) - return ret; + ret = create_directory(dentry, ctx); - ret = create_any_empty_ads(dentry, ctx); - if (ret) - return ret; - } + if (!ret) + ret = create_empty_streams(dentry, ctx); + + ret = check_apply_error(dentry, ctx, ret); + if (ret) + return ret; ret = report_file_created(&ctx->common); if (ret) @@ -1386,116 +1688,36 @@ create_directories(struct list_head *dentry_list, * * On success, returns an open handle to the file in @h_ret, with GENERIC_READ, * GENERIC_WRITE, and DELETE access. Also, the path to the file will be saved - * in ctx->pathbuf. On failure, returns WIMLIB_ERR_OPEN. + * in ctx->pathbuf. On failure, returns an error code. */ static int create_nondirectory_inode(HANDLE *h_ret, const struct wim_dentry *dentry, struct win32_apply_ctx *ctx) { - const struct wim_inode *inode; - ULONG attrib; - NTSTATUS status; - bool retried = false; - - inode = dentry->d_inode; + int ret; + HANDLE h; - /* If the file already exists and has FILE_ATTRIBUTE_SYSTEM and/or - * FILE_ATTRIBUTE_HIDDEN, these must be specified in order to supersede - * the file. - * - * Normally the user shouldn't be trying to overwrite such files anyway, - * but we at least provide FILE_ATTRIBUTE_SYSTEM and - * FILE_ATTRIBUTE_HIDDEN if the WIM inode has those attributes so that - * we catch the case where the user extracts the same files to the same - * location more than one time. - * - * Also specify FILE_ATTRIBUTE_ENCRYPTED if the file needs to be - * encrypted. - * - * In NO_ATTRIBUTES mode just don't specify any attributes at all. - */ - if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES) { - attrib = 0; - } else { - attrib = (inode->i_attributes & (FILE_ATTRIBUTE_SYSTEM | - FILE_ATTRIBUTE_HIDDEN | - FILE_ATTRIBUTE_ENCRYPTED)); - } build_extraction_path(dentry, ctx); -retry: - status = do_create_file(h_ret, GENERIC_READ | GENERIC_WRITE | DELETE, - NULL, attrib, FILE_SUPERSEDE, - FILE_NON_DIRECTORY_FILE, ctx); - if (NT_SUCCESS(status)) { - int ret; - - ret = adjust_compression_attribute(*h_ret, dentry, ctx); - if (ret) { - (*func_NtClose)(*h_ret); - return ret; - } - - ret = maybe_clear_encryption_attribute(h_ret, dentry, ctx); - /* May close the handle!!! */ - - if (ret) { - if (*h_ret) - (*func_NtClose)(*h_ret); - return ret; - } - - if (!*h_ret) { - /* Re-open the handle so that we can return it on - * success. */ - status = do_create_file(h_ret, - GENERIC_READ | - GENERIC_WRITE | DELETE, - NULL, 0, FILE_OPEN, - FILE_NON_DIRECTORY_FILE, ctx); - if (!NT_SUCCESS(status)) - goto fail; - } - - ret = create_any_empty_ads(dentry, ctx); - if (ret) { - (*func_NtClose)(*h_ret); - return ret; - } - return 0; - } - if (status == STATUS_ACCESS_DENIED && !retried) { - /* We also can't supersede an existing file that has - * FILE_ATTRIBUTE_READONLY set; doing so causes NtCreateFile() - * to return STATUS_ACCESS_DENIED . The only workaround seems - * to be to explicitly remove FILE_ATTRIBUTE_READONLY on the - * existing file, then try again. */ + ret = supersede_file_or_stream(ctx, &h); + if (ret) + goto out; - FILE_BASIC_INFORMATION info; - HANDLE h; + ret = adjust_compression_attribute(h, dentry, ctx); + if (ret) + goto out_close; - status = do_create_file(&h, FILE_WRITE_ATTRIBUTES, NULL, 0, - FILE_OPEN, FILE_NON_DIRECTORY_FILE, ctx); - if (!NT_SUCCESS(status)) - goto fail; + ret = create_empty_streams(dentry, ctx); + if (ret) + goto out_close; - memset(&info, 0, sizeof(info)); - info.FileAttributes = FILE_ATTRIBUTE_NORMAL; + *h_ret = h; + return 0; - status = (*func_NtSetInformationFile)(h, &ctx->iosb, - &info, sizeof(info), - FileBasicInformation); - (*func_NtClose)(h); - if (!NT_SUCCESS(status)) - goto fail; - retried = true; - goto retry; - } -fail: - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't create file \"%ls\" (status=0x%08"PRIx32")", - current_path(ctx), (u32)status); - return WIMLIB_ERR_OPEN; +out_close: + (*func_NtClose)(h); +out: + return ret; } /* Creates a hard link at the location named by @dentry to the file represented @@ -1531,8 +1753,8 @@ create_link(HANDLE h, const struct wim_dentry *dentry, FileLinkInformation); if (NT_SUCCESS(status)) return 0; - ERROR("Failed to create link \"%ls\" (status=0x%08"PRIx32")", - current_path(ctx), (u32)status); + winnt_error(status, L"Failed to create link \"%ls\"", + current_path(ctx)); return WIMLIB_ERR_LINK; } else { HANDLE h2; @@ -1558,23 +1780,17 @@ static int create_links(HANDLE h, const struct wim_dentry *first_dentry, struct win32_apply_ctx *ctx) { - const struct wim_inode *inode; - const struct list_head *next; + const struct wim_inode *inode = first_dentry->d_inode; const struct wim_dentry *dentry; int ret; - inode = first_dentry->d_inode; - next = inode->i_extraction_aliases.next; - do { - dentry = list_entry(next, struct wim_dentry, - d_extraction_alias_node); + inode_for_each_extraction_alias(dentry, inode) { if (dentry != first_dentry) { ret = create_link(h, dentry, ctx); if (ret) return ret; } - next = next->next; - } while (next != &inode->i_extraction_aliases); + } return 0; } @@ -1603,7 +1819,7 @@ create_nondirectory(struct wim_inode *inode, struct win32_apply_ctx *ctx) /* "WIMBoot" extraction: set external backing by the WIM file if needed. */ if (!ret && unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) - ret = set_external_backing(h, inode, ctx); + ret = set_backed_from_wim(h, inode, ctx); (*func_NtClose)(h); return ret; @@ -1625,6 +1841,7 @@ create_nondirectories(struct list_head *dentry_list, struct win32_apply_ctx *ctx /* Call create_nondirectory() only once per inode */ if (dentry == inode_first_extraction_dentry(inode)) { ret = create_nondirectory(inode, ctx); + ret = check_apply_error(dentry, ctx, ret); if (ret) return ret; } @@ -1642,96 +1859,88 @@ close_handles(struct win32_apply_ctx *ctx) (*func_NtClose)(ctx->open_handles[i]); } -/* Prepare to read the next stream, which has size @stream_size, into an - * in-memory buffer. */ -static int -prepare_data_buffer(struct win32_apply_ctx *ctx, u64 stream_size) +/* Prepare to read the next blob, which has size @blob_size, into an in-memory + * buffer. */ +static bool +prepare_data_buffer(struct win32_apply_ctx *ctx, u64 blob_size) { - if (stream_size > ctx->data_buffer_size) { + if (blob_size > ctx->data_buffer_size) { /* Larger buffer needed. */ void *new_buffer; - if ((size_t)stream_size != stream_size) - return WIMLIB_ERR_NOMEM; - new_buffer = REALLOC(ctx->data_buffer, stream_size); + if ((size_t)blob_size != blob_size) + return false; + new_buffer = REALLOC(ctx->data_buffer, blob_size); if (!new_buffer) - return WIMLIB_ERR_NOMEM; + return false; ctx->data_buffer = new_buffer; - ctx->data_buffer_size = stream_size; + ctx->data_buffer_size = blob_size; } /* On the first call this changes data_buffer_ptr from NULL, which tells * extract_chunk() that the data buffer needs to be filled while reading * the stream data. */ ctx->data_buffer_ptr = ctx->data_buffer; - return 0; + return true; } static int -begin_extract_stream_instance(const struct wim_lookup_table_entry *stream, - struct wim_dentry *dentry, - const wchar_t *stream_name, - struct win32_apply_ctx *ctx) +begin_extract_blob_instance(const struct blob_descriptor *blob, + struct wim_dentry *dentry, + const struct wim_inode_stream *strm, + struct win32_apply_ctx *ctx) { - const struct wim_inode *inode = dentry->d_inode; - size_t stream_name_nchars = 0; FILE_ALLOCATION_INFORMATION alloc_info; HANDLE h; NTSTATUS status; - if (unlikely(stream_name)) - stream_name_nchars = wcslen(stream_name); - - if (unlikely(stream_name_nchars)) { - build_extraction_path_with_ads(dentry, ctx, - stream_name, stream_name_nchars); - } else { - build_extraction_path(dentry, ctx); - } - - /* Reparse point? */ - if (unlikely(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) - && (stream_name_nchars == 0)) - { - if (!ctx->common.supported_features.reparse_points) - return 0; - - /* We can't write the reparse stream directly; we must set it - * with FSCTL_SET_REPARSE_POINT, which requires that all the + if (unlikely(strm->stream_type == STREAM_TYPE_REPARSE_POINT)) { + /* We can't write the reparse point stream directly; we must set + * it with FSCTL_SET_REPARSE_POINT, which requires that all the * data be available. So, stage the data in a buffer. */ - - list_add_tail(&dentry->tmp_list, &ctx->reparse_dentries); - return prepare_data_buffer(ctx, stream->size); + if (!prepare_data_buffer(ctx, blob->size)) + return WIMLIB_ERR_NOMEM; + list_add_tail(&dentry->d_tmp_list, &ctx->reparse_dentries); + return 0; } - /* Encrypted file? */ - if (unlikely(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED) - && (stream_name_nchars == 0)) - { - if (!ctx->common.supported_features.encrypted_files) - return 0; - - /* We can't write encrypted file streams directly; we must use + if (unlikely(strm->stream_type == STREAM_TYPE_EFSRPC_RAW_DATA)) { + /* We can't write encrypted files directly; we must use * WriteEncryptedFileRaw(), which requires providing the data * through a callback function. This can't easily be combined * with our own callback-based approach. * - * The current workaround is to simply read the stream into - * memory and write the encrypted file from that. + * The current workaround is to simply read the blob into memory + * and write the encrypted file from that. * * TODO: This isn't sufficient for extremely large encrypted * files. Perhaps we should create an extra thread to write * such files... */ - list_add_tail(&dentry->tmp_list, &ctx->encrypted_dentries); - return prepare_data_buffer(ctx, stream->size); + if (!prepare_data_buffer(ctx, blob->size)) + return WIMLIB_ERR_NOMEM; + list_add_tail(&dentry->d_tmp_list, &ctx->encrypted_dentries); + return 0; } - if (ctx->num_open_handles == MAX_OPEN_STREAMS) { + /* It's a data stream (may be unnamed or named). */ + wimlib_assert(strm->stream_type == STREAM_TYPE_DATA); + + if (ctx->num_open_handles == MAX_OPEN_FILES) { /* XXX: Fix this. But because of the checks in - * extract_stream_list(), this can now only happen on a - * filesystem that does not support hard links. */ + * extract_blob_list(), this can now only happen on a filesystem + * that does not support hard links. */ ERROR("Can't extract data: too many open files!"); return WIMLIB_ERR_UNSUPPORTED; } + + if (unlikely(stream_is_named(strm))) { + build_extraction_path_with_ads(dentry, ctx, + strm->stream_name, + utf16le_len_chars(strm->stream_name)); + } else { + build_extraction_path(dentry, ctx); + } + + /* Open a new handle */ status = do_create_file(&h, FILE_WRITE_DATA | SYNCHRONIZE, @@ -1740,73 +1949,21 @@ begin_extract_stream_instance(const struct wim_lookup_table_entry *stream, FILE_SYNCHRONOUS_IO_NONALERT, ctx); if (!NT_SUCCESS(status)) { - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't open \"%ls\" for writing " - "(status=0x%08"PRIx32")", - current_path(ctx), (u32)status); + winnt_error(status, L"Can't open \"%ls\" for writing", + current_path(ctx)); return WIMLIB_ERR_OPEN; } ctx->open_handles[ctx->num_open_handles++] = h; /* Allocate space for the data. */ - alloc_info.AllocationSize.QuadPart = stream->size; + alloc_info.AllocationSize.QuadPart = blob->size; (*func_NtSetInformationFile)(h, &ctx->iosb, &alloc_info, sizeof(alloc_info), FileAllocationInformation); return 0; } -/* Set the reparse data @rpbuf of length @rpbuflen on the extracted file - * corresponding to the WIM dentry @dentry. */ -static int -do_set_reparse_data(const struct wim_dentry *dentry, - const void *rpbuf, u16 rpbuflen, - struct win32_apply_ctx *ctx) -{ - NTSTATUS status; - HANDLE h; - - status = create_file(&h, GENERIC_WRITE, NULL, - 0, FILE_OPEN, 0, dentry, ctx); - if (!NT_SUCCESS(status)) - goto fail; - - status = (*func_NtFsControlFile)(h, NULL, NULL, NULL, - &ctx->iosb, FSCTL_SET_REPARSE_POINT, - (void *)rpbuf, rpbuflen, - NULL, 0); - (*func_NtClose)(h); - - if (NT_SUCCESS(status)) - return 0; - - /* On Windows, by default only the Administrator can create symbolic - * links for some reason. By default we just issue a warning if this - * appears to be the problem. Use WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS - * to get a hard error. */ - if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS) - && (status == STATUS_PRIVILEGE_NOT_HELD || - status == STATUS_ACCESS_DENIED) - && (dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK || - dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT)) - { - WARNING("Can't create symbolic link \"%ls\"! \n" - " (Need Administrator rights, or at least " - "the\n" - " SeCreateSymbolicLink privilege.)", - current_path(ctx)); - return 0; - } - -fail: - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't set reparse data on \"%ls\" " - "(status=0x%08"PRIx32")", - current_path(ctx), (u32)status); - return WIMLIB_ERR_SET_REPARSE_DATA; -} - /* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a * pointer to the suffix of the path that begins with the device directly, such * as e:\Windows\System32. */ @@ -1818,33 +1975,27 @@ skip_nt_toplevel_component(const wchar_t *path, size_t path_nchars) L"\\DosDevices\\", L"\\Device\\", }; - size_t first_dir_len = 0; const wchar_t * const end = path + path_nchars; for (size_t i = 0; i < ARRAY_LEN(dirs); i++) { size_t len = wcslen(dirs[i]); - if (len <= (end - path) && !wcsnicmp(path, dirs[i], len)) { - first_dir_len = len; - break; + if (len <= (end - path) && !wmemcmp(path, dirs[i], len)) { + path += len; + while (path != end && *path == L'\\') + path++; + return path; } } - if (first_dir_len == 0) - return path; - path += first_dir_len; - while (path != end && *path == L'\\') - path++; return path; } -/* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a - * pointer to the suffix of the path that is device-relative, such as - * Windows\System32. +/* + * Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a + * pointer to the suffix of the path that is device-relative but possibly with + * leading slashes, such as \Windows\System32. * * The path has an explicit length and is not necessarily null terminated. - * - * If the path just something like \??\e: then the returned pointer will point - * just past the colon. In this case the length of the result will be 0 - * characters. */ + */ static const wchar_t * get_device_relative_path(const wchar_t *path, size_t path_nchars) { @@ -1855,24 +2006,22 @@ get_device_relative_path(const wchar_t *path, size_t path_nchars) if (path == orig_path) return orig_path; - path = wmemchr(path, L'\\', (end - path)); - if (!path) - return end; - do { + while (path != end && *path != L'\\') path++; - } while (path != end && *path == L'\\'); + return path; } /* - * Given a reparse point buffer for a symbolic link or junction, adjust its - * contents so that the target of the link is consistent with the new location - * of the files. + * Given a reparse point buffer for an inode for which the absolute link target + * was relativized when it was archived, de-relative the link target to be + * consistent with the actual extraction location. */ static void -try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx) +try_rpfix(struct reparse_buffer_disk *rpbuf, u16 *rpbuflen_p, + struct win32_apply_ctx *ctx) { - struct reparse_data rpdata; + struct link_reparse_point link; size_t orig_subst_name_nchars; const wchar_t *relpath; size_t relpath_nchars; @@ -1881,43 +2030,33 @@ try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx) const wchar_t *fixed_print_name; size_t fixed_print_name_nchars; - if (parse_reparse_data(rpbuf, *rpbuflen_p, &rpdata)) { - /* Do nothing if the reparse data is invalid. */ + /* Do nothing if the reparse data is invalid. */ + if (parse_link_reparse_point(rpbuf, *rpbuflen_p, &link)) return; - } - if (rpdata.rptag == WIM_IO_REPARSE_TAG_SYMLINK && - (rpdata.rpflags & SYMBOLIC_LINK_RELATIVE)) - { - /* Do nothing if it's a relative symbolic link. */ + /* Do nothing if the reparse point is a relative symbolic link. */ + if (link_is_relative_symlink(&link)) return; - } /* Build the new substitute name from the NT namespace path to the * target directory, then a path separator, then the "device relative" * part of the old substitute name. */ - orig_subst_name_nchars = rpdata.substitute_name_nbytes / sizeof(wchar_t); + orig_subst_name_nchars = link.substitute_name_nbytes / sizeof(wchar_t); - relpath = get_device_relative_path(rpdata.substitute_name, + relpath = get_device_relative_path(link.substitute_name, orig_subst_name_nchars); relpath_nchars = orig_subst_name_nchars - - (relpath - rpdata.substitute_name); + (relpath - link.substitute_name); target_ntpath_nchars = ctx->target_ntpath.Length / sizeof(wchar_t); - fixed_subst_name_nchars = target_ntpath_nchars; - if (relpath_nchars) - fixed_subst_name_nchars += 1 + relpath_nchars; + fixed_subst_name_nchars = target_ntpath_nchars + relpath_nchars; + wchar_t fixed_subst_name[fixed_subst_name_nchars]; - wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer, - target_ntpath_nchars); - if (relpath_nchars) { - fixed_subst_name[target_ntpath_nchars] = L'\\'; - wmemcpy(&fixed_subst_name[target_ntpath_nchars + 1], - relpath, relpath_nchars); - } + wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer, target_ntpath_nchars); + wmemcpy(&fixed_subst_name[target_ntpath_nchars], relpath, relpath_nchars); /* Doesn't need to be null-terminated. */ /* Print name should be Win32, but not all NT names can even be @@ -1929,33 +2068,29 @@ try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx) fixed_print_name_nchars = fixed_subst_name_nchars - (fixed_print_name - fixed_subst_name); - rpdata.substitute_name = fixed_subst_name; - rpdata.substitute_name_nbytes = fixed_subst_name_nchars * sizeof(wchar_t); - rpdata.print_name = (wchar_t *)fixed_print_name; - rpdata.print_name_nbytes = fixed_print_name_nchars * sizeof(wchar_t); - make_reparse_buffer(&rpdata, rpbuf, rpbuflen_p); + link.substitute_name = fixed_subst_name; + link.substitute_name_nbytes = fixed_subst_name_nchars * sizeof(wchar_t); + link.print_name = (wchar_t *)fixed_print_name; + link.print_name_nbytes = fixed_print_name_nchars * sizeof(wchar_t); + make_link_reparse_point(&link, rpbuf, rpbuflen_p); } -/* Sets reparse data on the specified file. This handles "fixing" the targets - * of absolute symbolic links and junctions if WIMLIB_EXTRACT_FLAG_RPFIX was - * specified. */ +/* Sets the reparse point on the specified file. This handles "fixing" the + * targets of absolute symbolic links and junctions if WIMLIB_EXTRACT_FLAG_RPFIX + * was specified. */ static int -set_reparse_data(const struct wim_dentry *dentry, - const void *_rpbuf, u16 rpbuflen, struct win32_apply_ctx *ctx) +set_reparse_point(const struct wim_dentry *dentry, + const struct reparse_buffer_disk *rpbuf, u16 rpbuflen, + struct win32_apply_ctx *ctx) { - const struct wim_inode *inode = dentry->d_inode; - const void *rpbuf = _rpbuf; - if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) - && !inode->i_not_rpfixed - && (inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK || - inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT)) + && !(dentry->d_inode->i_rp_flags & WIM_RP_FLAG_NOT_FIXED)) { - memcpy(&ctx->rpfixbuf, _rpbuf, rpbuflen); - try_rpfix((u8 *)&ctx->rpfixbuf, &rpbuflen, ctx); + memcpy(&ctx->rpfixbuf, rpbuf, rpbuflen); + try_rpfix(&ctx->rpfixbuf, &rpbuflen, ctx); rpbuf = &ctx->rpfixbuf; } - return do_set_reparse_data(dentry, rpbuf, rpbuflen, ctx); + return do_set_reparse_point(dentry, rpbuf, rpbuflen, ctx); } @@ -1973,31 +2108,49 @@ import_encrypted_data(PBYTE pbData, PVOID pvCallbackContext, PULONG Length) return ERROR_SUCCESS; } -/* Write the raw encrypted data to the already-created file corresponding to - * @dentry. +/* + * Write the raw encrypted data to the already-created file (or directory) + * corresponding to @dentry. * * The raw encrypted data is provided in ctx->data_buffer, and its size is - * ctx->encrypted_size. */ + * ctx->encrypted_size. + * + * This function may close the target directory, in which case the caller needs + * to re-open it if needed. + */ static int extract_encrypted_file(const struct wim_dentry *dentry, struct win32_apply_ctx *ctx) { void *rawctx; DWORD err; + ULONG flags; + bool retried; /* Temporarily build a Win32 path for OpenEncryptedFileRaw() */ build_win32_extraction_path(dentry, ctx); - err = OpenEncryptedFileRaw(ctx->pathbuf.Buffer, - CREATE_FOR_IMPORT, &rawctx); + flags = CREATE_FOR_IMPORT | OVERWRITE_HIDDEN; + if (dentry->d_inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) + flags |= CREATE_FOR_DIR; + + retried = false; +retry: + err = OpenEncryptedFileRaw(ctx->pathbuf.Buffer, flags, &rawctx); + if (err == ERROR_SHARING_VIOLATION && !retried) { + /* This can be caused by the handle we have open to the target + * directory. Try closing it temporarily. */ + close_target_directory(ctx); + retried = true; + goto retry; + } /* Restore the NT namespace path */ build_extraction_path(dentry, ctx); if (err != ERROR_SUCCESS) { - set_errno_from_win32_error(err); - ERROR_WITH_ERRNO("Can't open \"%ls\" for encrypted import " - "(err=%"PRIu32")", current_path(ctx), (u32)err); + win32_error(err, L"Can't open \"%ls\" for encrypted import", + current_path(ctx)); return WIMLIB_ERR_OPEN; } @@ -2008,21 +2161,20 @@ extract_encrypted_file(const struct wim_dentry *dentry, CloseEncryptedFileRaw(rawctx); if (err != ERROR_SUCCESS) { - set_errno_from_win32_error(err); - ERROR_WITH_ERRNO("Can't import encrypted file \"%ls\" " - "(err=%"PRIu32")", current_path(ctx), (u32)err); + win32_error(err, L"Can't import encrypted file \"%ls\"", + current_path(ctx)); return WIMLIB_ERR_WRITE; } return 0; } -/* Called when starting to read a stream for extraction on Windows */ +/* Called when starting to read a blob for extraction on Windows */ static int -begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx) +begin_extract_blob(struct blob_descriptor *blob, void *_ctx) { struct win32_apply_ctx *ctx = _ctx; - const struct stream_owner *owners = stream_owners(stream); + const struct blob_extraction_target *targets = blob_extraction_targets(blob); int ret; ctx->num_open_handles = 0; @@ -2030,36 +2182,28 @@ begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx) INIT_LIST_HEAD(&ctx->reparse_dentries); INIT_LIST_HEAD(&ctx->encrypted_dentries); - for (u32 i = 0; i < stream->out_refcnt; i++) { - const struct wim_inode *inode = owners[i].inode; - const wchar_t *stream_name = owners[i].stream_name; + for (u32 i = 0; i < blob->out_refcnt; i++) { + const struct wim_inode *inode = targets[i].inode; + const struct wim_inode_stream *strm = targets[i].stream; struct wim_dentry *dentry; - /* A copy of the stream needs to be extracted to @inode. */ + /* A copy of the blob needs to be extracted to @inode. */ if (ctx->common.supported_features.hard_links) { dentry = inode_first_extraction_dentry(inode); - ret = begin_extract_stream_instance(stream, dentry, - stream_name, ctx); + ret = begin_extract_blob_instance(blob, dentry, strm, ctx); + ret = check_apply_error(dentry, ctx, ret); if (ret) goto fail; } else { - /* Hard links not supported. Extract the stream + /* Hard links not supported. Extract the blob * separately to each alias of the inode. */ - struct list_head *next; - - next = inode->i_extraction_aliases.next; - do { - dentry = list_entry(next, struct wim_dentry, - d_extraction_alias_node); - ret = begin_extract_stream_instance(stream, - dentry, - stream_name, - ctx); + inode_for_each_extraction_alias(dentry, inode) { + ret = begin_extract_blob_instance(blob, dentry, strm, ctx); + ret = check_apply_error(dentry, ctx, ret); if (ret) goto fail; - next = next->next; - } while (next != &inode->i_extraction_aliases); + } } } @@ -2070,8 +2214,8 @@ fail: return ret; } -/* Called when the next chunk of a stream has been read for extraction on - * Windows */ +/* Called when the next chunk of a blob has been read for extraction on Windows + */ static int extract_chunk(const void *chunk, size_t size, void *_ctx) { @@ -2090,10 +2234,7 @@ extract_chunk(const void *chunk, size_t size, void *_ctx) &ctx->iosb, bufptr, count, NULL, NULL); if (!NT_SUCCESS(status)) { - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Error writing data to target " - "volume (status=0x%08"PRIx32")", - (u32)status); + winnt_error(status, L"Error writing data to target volume"); return WIMLIB_ERR_WRITE; } bufptr += ctx->iosb.Information; @@ -2108,9 +2249,126 @@ extract_chunk(const void *chunk, size_t size, void *_ctx) return 0; } -/* Called when a stream has been fully read for extraction on Windows */ static int -end_extract_stream(struct wim_lookup_table_entry *stream, int status, void *_ctx) +get_system_compression_format(int extract_flags) +{ + if (extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K) + return FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS4K; + + if (extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K) + return FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS8K; + + if (extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K) + return FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS16K; + + return FILE_PROVIDER_COMPRESSION_FORMAT_LZX; +} + +static DWORD +set_system_compression(HANDLE h, int format) +{ + DWORD bytes_returned; + DWORD err; + struct { + struct wof_external_info wof_info; + struct file_provider_external_info file_info; + } in = { + .wof_info = { + .version = WOF_CURRENT_VERSION, + .provider = WOF_PROVIDER_FILE, + }, + .file_info = { + .version = FILE_PROVIDER_CURRENT_VERSION, + .compression_format = format, + }, + }; + + if (DeviceIoControl(h, FSCTL_SET_EXTERNAL_BACKING, &in, sizeof(in), + NULL, 0, &bytes_returned, NULL)) + return 0; + + err = GetLastError(); + + if (err == 344) /* "Compressing this object would not save space." */ + return 0; + + return err; +} + +/* + * This function is called when doing a "compact-mode" extraction and we just + * finished extracting a blob to one or more locations. For each location that + * was the unnamed data stream of a file, this function compresses the + * corresponding file using System Compression, if allowed. + * + * Note: we're doing the compression immediately after extracting the data + * rather than during a separate compression pass. This way should be faster + * since the operating system should still have the file's data cached. + * + * Note: we're having the operating system do the compression, which is not + * ideal because wimlib could create the compressed data faster and more + * efficiently (the compressed data format is identical to a WIM resource). But + * we seemingly don't have a choice because WOF prevents applications from + * creating its reparse points. + */ +static void +handle_system_compression(struct blob_descriptor *blob, struct win32_apply_ctx *ctx) +{ + const struct blob_extraction_target *targets = blob_extraction_targets(blob); + + const int format = get_system_compression_format(ctx->common.extract_flags); + + for (u32 i = 0; i < blob->out_refcnt; i++) { + struct wim_inode *inode = targets[i].inode; + struct wim_inode_stream *strm = targets[i].stream; + HANDLE h; + NTSTATUS status; + DWORD err; + + if (!stream_is_unnamed_data_stream(strm)) + continue; + + if (will_externally_back_inode(inode, ctx, NULL, false) != 0) + continue; + + status = create_file(&h, GENERIC_READ | GENERIC_WRITE, NULL, + 0, FILE_OPEN, 0, + inode_first_extraction_dentry(inode), ctx); + + if (NT_SUCCESS(status)) { + err = set_system_compression(h, format); + (*func_NtClose)(h); + } else { + err = (*func_RtlNtStatusToDosError)(status); + } + + if (err == ERROR_INVALID_FUNCTION) { + WARNING( + "The request to compress the extracted files using System Compression\n" +" will not be honored because the operating system or target volume\n" +" does not support it. System Compression is only supported on\n" +" Windows 10 and later, and only on NTFS volumes."); + ctx->common.extract_flags &= ~COMPACT_FLAGS; + return; + } + + if (err) { + ctx->num_system_compression_failures++; + if (ctx->num_system_compression_failures < 10) { + win32_warning(err, L"\"%ls\": Failed to compress " + "extracted file using System Compression", + current_path(ctx)); + } else if (ctx->num_system_compression_failures == 10) { + WARNING("Suppressing further warnings about " + "System Compression failures."); + } + } + } +} + +/* Called when a blob has been fully read for extraction on Windows */ +static int +end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx) { struct win32_apply_ctx *ctx = _ctx; int ret; @@ -2121,39 +2379,51 @@ end_extract_stream(struct wim_lookup_table_entry *stream, int status, void *_ctx if (status) return status; + if (unlikely(ctx->common.extract_flags & COMPACT_FLAGS)) + handle_system_compression(blob, ctx); + if (likely(!ctx->data_buffer_ptr)) return 0; if (!list_empty(&ctx->reparse_dentries)) { - if (stream->size > REPARSE_DATA_MAX_SIZE) { + if (blob->size > REPARSE_DATA_MAX_SIZE) { dentry = list_first_entry(&ctx->reparse_dentries, - struct wim_dentry, tmp_list); + struct wim_dentry, d_tmp_list); build_extraction_path(dentry, ctx); ERROR("Reparse data of \"%ls\" has size " "%"PRIu64" bytes (exceeds %u bytes)", - current_path(ctx), stream->size, + current_path(ctx), blob->size, REPARSE_DATA_MAX_SIZE); - return WIMLIB_ERR_INVALID_REPARSE_DATA; + ret = WIMLIB_ERR_INVALID_REPARSE_DATA; + return check_apply_error(dentry, ctx, ret); } - /* In the WIM format, reparse streams are just the reparse data - * and omit the header. But we can reconstruct the header. */ - memcpy(ctx->rpbuf.rpdata, ctx->data_buffer, stream->size); - ctx->rpbuf.rpdatalen = stream->size; - ctx->rpbuf.rpreserved = 0; - list_for_each_entry(dentry, &ctx->reparse_dentries, tmp_list) { - ctx->rpbuf.rptag = dentry->d_inode->i_reparse_tag; - ret = set_reparse_data(dentry, &ctx->rpbuf, - stream->size + REPARSE_DATA_OFFSET, - ctx); + /* Reparse data */ + memcpy(ctx->rpbuf.rpdata, ctx->data_buffer, blob->size); + + list_for_each_entry(dentry, &ctx->reparse_dentries, d_tmp_list) { + + /* Reparse point header */ + complete_reparse_point(&ctx->rpbuf, dentry->d_inode, + blob->size); + + ret = set_reparse_point(dentry, &ctx->rpbuf, + REPARSE_DATA_OFFSET + blob->size, + ctx); + ret = check_apply_error(dentry, ctx, ret); if (ret) return ret; } } if (!list_empty(&ctx->encrypted_dentries)) { - ctx->encrypted_size = stream->size; - list_for_each_entry(dentry, &ctx->encrypted_dentries, tmp_list) { + ctx->encrypted_size = blob->size; + list_for_each_entry(dentry, &ctx->encrypted_dentries, d_tmp_list) { ret = extract_encrypted_file(dentry, ctx); + ret = check_apply_error(dentry, ctx, ret); + if (ret) + return ret; + /* Re-open the target directory if needed. */ + ret = open_target_directory(ctx); if (ret) return ret; } @@ -2315,7 +2585,7 @@ do_apply_metadata_to_file(HANDLE h, const struct wim_inode *inode, NTSTATUS status; /* Set security descriptor if present and not in NO_ACLS mode */ - if (inode->i_security_id >= 0 && + if (inode_has_security_descriptor(inode) && !(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS)) { const struct wim_security_data *sd; @@ -2330,10 +2600,9 @@ do_apply_metadata_to_file(HANDLE h, const struct wim_inode *inode, if (!NT_SUCCESS(status) && (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS)) { - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't set security descriptor " - "on \"%ls\" (status=0x%08"PRIx32")", - current_path(ctx), (u32)status); + winnt_error(status, + L"Can't set security descriptor on \"%ls\"", + current_path(ctx)); return WIMLIB_ERR_SET_SECURITY; } } @@ -2343,10 +2612,13 @@ do_apply_metadata_to_file(HANDLE h, const struct wim_inode *inode, info.LastAccessTime.QuadPart = inode->i_last_access_time; info.LastWriteTime.QuadPart = inode->i_last_write_time; info.ChangeTime.QuadPart = 0; - if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES) - info.FileAttributes = 0; - else + if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES) { + info.FileAttributes = FILE_ATTRIBUTE_NORMAL; + } else { info.FileAttributes = inode->i_attributes & ~SPECIAL_ATTRIBUTES; + if (info.FileAttributes == 0) + info.FileAttributes = FILE_ATTRIBUTE_NORMAL; + } status = (*func_NtSetInformationFile)(h, &ctx->iosb, &info, sizeof(info), @@ -2358,10 +2630,8 @@ do_apply_metadata_to_file(HANDLE h, const struct wim_inode *inode, && !(status == STATUS_INVALID_PARAMETER && dentry_is_root(inode_first_extraction_dentry(inode)))) { - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't set basic metadata on \"%ls\" " - "(status=0x%08"PRIx32")", - current_path(ctx), (u32)status); + winnt_error(status, L"Can't set basic metadata on \"%ls\"", + current_path(ctx)); return WIMLIB_ERR_SET_ATTRIBUTES; } @@ -2403,10 +2673,8 @@ apply_metadata_to_file(const struct wim_dentry *dentry, continue; } } - set_errno_from_nt_status(status); - ERROR_WITH_ERRNO("Can't open \"%ls\" to set metadata " - "(status=0x%08"PRIx32")", - current_path(ctx), (u32)status); + winnt_error(status, L"Can't open \"%ls\" to set metadata", + current_path(ctx)); return WIMLIB_ERR_OPEN; } @@ -2429,6 +2697,7 @@ apply_metadata(struct list_head *dentry_list, struct win32_apply_ctx *ctx) list_for_each_entry_reverse(dentry, dentry_list, d_extraction_list_node) { ret = apply_metadata_to_file(dentry, ctx); + ret = check_apply_error(dentry, ctx, ret); if (ret) return ret; ret = report_file_metadata_applied(&ctx->common); @@ -2482,11 +2751,11 @@ do_warnings(const struct win32_apply_ctx *ctx) } } -static uint64_t +static u64 count_dentries(const struct list_head *dentry_list) { const struct list_head *cur; - uint64_t count = 0; + u64 count = 0; list_for_each(cur, dentry_list) count++; @@ -2500,14 +2769,14 @@ win32_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) { int ret; struct win32_apply_ctx *ctx = (struct win32_apply_ctx *)_ctx; - uint64_t dentry_count; + u64 dentry_count; ret = prepare_target(dentry_list, ctx); if (ret) goto out; if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) { - ret = start_wimboot_extraction(ctx); + ret = start_wimboot_extraction(dentry_list, ctx); if (ret) goto out; } @@ -2530,15 +2799,13 @@ win32_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) if (ret) goto out; - struct read_stream_list_callbacks cbs = { - .begin_stream = begin_extract_stream, - .begin_stream_ctx = ctx, - .consume_chunk = extract_chunk, - .consume_chunk_ctx = ctx, - .end_stream = end_extract_stream, - .end_stream_ctx = ctx, + struct read_blob_callbacks cbs = { + .begin_blob = begin_extract_blob, + .consume_chunk = extract_chunk, + .end_blob = end_extract_blob, + .ctx = ctx, }; - ret = extract_stream_list(&ctx->common, &cbs); + ret = extract_blob_list(&ctx->common, &cbs); if (ret) goto out; @@ -2562,17 +2829,17 @@ win32_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) do_warnings(ctx); out: - if (ctx->h_target) - (*func_NtClose)(ctx->h_target); + close_target_directory(ctx); if (ctx->target_ntpath.Buffer) HeapFree(GetProcessHeap(), 0, ctx->target_ntpath.Buffer); FREE(ctx->pathbuf.Buffer); FREE(ctx->print_buffer); - if (ctx->wimboot.prepopulate_pats) { - FREE(ctx->wimboot.prepopulate_pats->strings); - FREE(ctx->wimboot.prepopulate_pats); + FREE(ctx->wimboot.wims); + if (ctx->prepopulate_pats) { + FREE(ctx->prepopulate_pats->strings); + FREE(ctx->prepopulate_pats); } - FREE(ctx->wimboot.mem_prepopulate_pats); + FREE(ctx->mem_prepopulate_pats); FREE(ctx->data_buffer); return ret; } @@ -2581,7 +2848,7 @@ const struct apply_operations win32_apply_ops = { .name = "Windows", .get_supported_features = win32_get_supported_features, .extract = win32_extract, - .will_externally_back = win32_will_externally_back, + .will_back_from_wim = win32_will_back_from_wim, .context_size = sizeof(struct win32_apply_ctx), };