X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwin32_apply.c;h=9ebc161e504cb85e808f568f5149f7847097d53b;hp=421db26b0d9a6e6f3321d8ccccd19711dacb5ffa;hb=944ca027b829261f33af8577fd8fe2afdc4d02b7;hpb=f62ed8ae0312228f797398e462a132a7cfa319d7 diff --git a/src/win32_apply.c b/src/win32_apply.c index 421db26b..9ebc161e 100644 --- a/src/win32_apply.c +++ b/src/win32_apply.c @@ -5,22 +5,22 @@ /* * Copyright (C) 2013, 2014 Eric Biggers * - * This file is part of wimlib, a library for working with WIM files. + * 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 + * Software Foundation; either version 3 of the License, or (at your option) any + * later version. * - * wimlib is free software; you can redistribute it and/or modify it under the - * terms of the GNU General Public License as published by the Free - * Software Foundation; either version 3 of the License, or (at your option) - * any later version. - * - * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY - * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU General Public License for more + * This file is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * - * You should have received a copy of the GNU General Public License - * along with wimlib; if not, see http://www.gnu.org/licenses/. + * You should have received a copy of the GNU Lesser General Public License + * along with this file; if not, see http://www.gnu.org/licenses/. */ +#ifdef __WIN32__ + #ifdef HAVE_CONFIG_H # include "config.h" #endif @@ -36,12 +36,9 @@ #include "wimlib/reparse.h" #include "wimlib/textfile.h" #include "wimlib/xml.h" +#include "wimlib/wildcard.h" #include "wimlib/wimboot.h" -/* TODO: Add workaround for when a stream needs to be extracted to more places - * than this */ -#define MAX_OPEN_HANDLES 32768 - struct win32_apply_ctx { /* Extract flags, the pointer to the WIMStruct, etc. */ @@ -55,6 +52,7 @@ struct win32_apply_ctx { void *mem_prepopulate_pats; u8 wim_lookup_table_hash[SHA1_HASH_SIZE]; bool wof_running; + bool tried_to_load_prepopulate_list; } wimboot; /* Open handle to the target directory */ @@ -98,12 +96,12 @@ struct win32_apply_ctx { struct reparse_buffer_disk rpbuf; /* Temporary buffer for reparse data of "fixed" absolute symbolic links - * and junction */ + * and junctions */ struct reparse_buffer_disk rpfixbuf; /* Array of open handles to filesystem streams currently being written */ - HANDLE open_handles[MAX_OPEN_HANDLES]; + HANDLE open_handles[MAX_OPEN_STREAMS]; /* Number of handles in @open_handles currently open (filled in from the * beginning of the array) */ @@ -126,6 +124,16 @@ struct win32_apply_ctx { /* Number of files for which we didn't have permission to set any part * of the security descriptor. */ unsigned long no_security_descriptors; + + /* Number of files for which we couldn't set the short name. */ + unsigned long num_set_short_name_failures; + + /* Number of files for which we couldn't remove the short name. */ + unsigned long num_remove_short_name_failures; + + /* Have we tried to enable short name support on the target volume yet? + */ + bool tried_to_enable_short_names; }; /* Get the drive letter from a Windows path, or return the null character if the @@ -187,6 +195,30 @@ get_vol_flags(const wchar_t *target, DWORD *vol_flags_ret, } } +static const wchar_t * +current_path(struct win32_apply_ctx *ctx); + +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) @@ -237,7 +269,7 @@ win32_get_supported_features(const wchar_t *target, return 0; } -/* Load the patterns from [PrepopulateList] of WimBootCompresse.ini in the WIM +/* Load the patterns from [PrepopulateList] of WimBootCompress.ini in the WIM * image being extracted. */ static int load_prepopulate_pats(struct win32_apply_ctx *ctx) @@ -251,6 +283,8 @@ load_prepopulate_pats(struct win32_apply_ctx *ctx) void *mem; struct text_file_section sec; + ctx->wimboot.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 | @@ -290,12 +324,11 @@ load_prepopulate_pats(struct win32_apply_ctx *ctx) return 0; } -/* Returns %true if the path to @dentry matches a pattern in [PrepopulateList] - * of WimBootCompress.ini. Otherwise returns %false. - * - * @dentry must have had its full path calculated. */ +/* 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(struct wim_dentry *dentry, +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; @@ -303,8 +336,158 @@ in_prepopulate_list(struct wim_dentry *dentry, if (!pats || !pats->num_strings) return false; - return match_pattern_list(dentry->_full_path, - wcslen(dentry->_full_path), pats); + 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) +{ + if (in_prepopulate_list(path, path_nchars, ctx)) + return false; + + /* Since we attempt to modify the SYSTEM registry after it's extracted + * (see end_wimboot_extraction()), it can't be extracted as externally + * backed. This extends to associated files such as SYSTEM.LOG that + * also must be writable in order to write to the registry. Normally, + * SYSTEM is in [PrepopulateList], and the SYSTEM.* files match patterns + * in [ExclusionList] and therefore are not captured in the WIM at all. + * 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)) + return false; + + return true; +} + +#define WIM_BACKING_NOT_ENABLED -1 +#define WIM_BACKING_NOT_POSSIBLE -2 +#define WIM_BACKING_EXCLUDED -3 + +static int +will_externally_back_inode(struct wim_inode *inode, struct win32_apply_ctx *ctx, + const struct wim_dentry **excluded_dentry_ret) +{ + struct list_head *next; + struct wim_dentry *dentry; + struct wim_lookup_table_entry *stream; + int ret; + + if (inode->i_can_externally_back) + return 0; + + /* This may do redundant checks because the cached value + * i_can_externally_back is 2-state (as opposed to 3-state: + * unknown/no/yes). But most files can be externally backed, so this + * way is fine. */ + + if (inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY | + FILE_ATTRIBUTE_REPARSE_POINT | + FILE_ATTRIBUTE_ENCRYPTED)) + return WIM_BACKING_NOT_POSSIBLE; + + stream = inode_unnamed_lte_resolved(inode); + + 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; + + /* + * 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); + + ret = calculate_dentry_full_path(dentry); + if (ret) + return ret; + + if (!can_externally_back_path(dentry->_full_path, + wcslen(dentry->_full_path), ctx)) + { + if (excluded_dentry_ret) + *excluded_dentry_ret = dentry; + return WIM_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. + */ +static int +win32_will_externally_back(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; + + 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); +} + +static int +set_external_backing(HANDLE h, struct wim_inode *inode, struct win32_apply_ctx *ctx) +{ + int ret; + const struct wim_dentry *excluded_dentry; + + ret = will_externally_back_inode(inode, ctx, &excluded_dentry); + if (ret > 0) /* Error. */ + return ret; + + if (ret < 0 && ret != WIM_BACKING_EXCLUDED) + return 0; /* Not externally backing, other than due to exclusion. */ + + if (unlikely(ret == WIM_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.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; + } } /* Calculates the SHA-1 message digest of the WIM's lookup table. */ @@ -323,12 +506,11 @@ start_wimboot_extraction(struct win32_apply_ctx *ctx) int ret; WIMStruct *wim = ctx->common.wim; - ret = load_prepopulate_pats(ctx); - if (ret == WIMLIB_ERR_NOMEM) - return ret; + if (!ctx->wimboot.tried_to_load_prepopulate_list) + if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM) + return WIMLIB_ERR_NOMEM; - if (!wim_info_get_wimboot(wim->wim_info, - wim->current_image)) + if (!wim_info_get_wimboot(wim->wim_info, wim->current_image)) WARNING("Image is not marked as WIMBoot compatible!"); ret = hash_lookup_table(ctx->common.wim, @@ -344,6 +526,80 @@ start_wimboot_extraction(struct win32_apply_ctx *ctx) &ctx->wimboot.wof_running); } +static void +build_win32_extraction_path(const struct wim_dentry *dentry, + struct win32_apply_ctx *ctx); + +/* Sets WimBoot=1 in the extracted SYSTEM registry hive. + * + * WIMGAPI does this, and it's possible that it's important. + * But I don't know exactly what this value means to Windows. */ +static int +end_wimboot_extraction(struct win32_apply_ctx *ctx) +{ + struct wim_dentry *dentry; + wchar_t subkeyname[32]; + LONG res; + LONG res2; + HKEY key; + DWORD value; + + dentry = get_dentry(ctx->common.wim, L"\\Windows\\System32\\config\\SYSTEM", + WIMLIB_CASE_INSENSITIVE); + + if (!dentry || !will_extract_dentry(dentry)) + goto out; + + if (!will_extract_dentry(wim_get_current_root_dentry(ctx->common.wim))) + goto out; + + /* Not bothering to use the native routines (e.g. NtLoadKey()) for this. + * If this doesn't work, you probably also have many other problems. */ + + build_win32_extraction_path(dentry, ctx); + + randomize_char_array_with_alnum(subkeyname, 20); + subkeyname[20] = L'\0'; + + res = RegLoadKey(HKEY_LOCAL_MACHINE, subkeyname, ctx->pathbuf.Buffer); + if (res) + goto out_check_res; + + wcscpy(&subkeyname[20], L"\\Setup"); + + res = RegCreateKeyEx(HKEY_LOCAL_MACHINE, subkeyname, 0, NULL, + REG_OPTION_BACKUP_RESTORE, 0, NULL, &key, NULL); + if (res) + goto out_unload_key; + + value = 1; + + res = RegSetValueEx(key, L"WimBoot", 0, REG_DWORD, + (const BYTE *)&value, sizeof(DWORD)); + if (res) + goto out_close_key; + + res = RegFlushKey(key); + +out_close_key: + res2 = RegCloseKey(key); + if (!res) + res = res2; +out_unload_key: + subkeyname[20] = L'\0'; + RegUnLoadKey(HKEY_LOCAL_MACHINE, subkeyname); +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); + } +out: + return 0; +} + /* Returns the number of wide characters needed to represent the path to the * specified @dentry, relative to the target directory, when extracted. * @@ -357,7 +613,7 @@ dentry_extraction_path_length(const struct wim_dentry *dentry) d = dentry; do { len += d->d_extraction_name_nchars + 1; - d = d->parent; + d = d->d_parent; } while (!dentry_is_root(d) && will_extract_dentry(d)); return --len; /* No leading slash */ @@ -368,7 +624,7 @@ dentry_extraction_path_length(const struct wim_dentry *dentry) * * If the inode has no named data streams, this will be 0. Otherwise, this will * be 1 plus the length of the longest-named data stream, since the data stream - * name must be separated form the path by the ':' character. */ + * name must be separated from the path by the ':' character. */ static size_t inode_longest_named_data_stream_spec(const struct wim_inode *inode) { @@ -426,8 +682,8 @@ build_extraction_path(const struct wim_dentry *dentry, ctx->pathbuf.Length = len * sizeof(wchar_t); p = ctx->pathbuf.Buffer + len; for (d = dentry; - !dentry_is_root(d->parent) && will_extract_dentry(d->parent); - d = d->parent) + !dentry_is_root(d->d_parent) && will_extract_dentry(d->d_parent); + d = d->d_parent) { p -= d->d_extraction_name_nchars; wmemcpy(p, d->d_extraction_name, d->d_extraction_name_nchars); @@ -464,7 +720,7 @@ build_extraction_path_with_ads(const struct wim_dentry *dentry, * The path is saved in ctx->pathbuf and will be null terminated. * * XXX: We could get rid of this if it wasn't needed for the file encryption - * APIs. */ + * APIs, and the registry manipulation in WIMBoot mode. */ static void build_win32_extraction_path(const struct wim_dentry *dentry, struct win32_apply_ctx *ctx) @@ -512,33 +768,15 @@ current_path(struct win32_apply_ctx *ctx) static int prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx) { + int ret; NTSTATUS status; size_t path_max; /* Open handle to the target directory (possibly creating it). */ - if (func_RtlDosPathNameToNtPathName_U_WithStatus) { - status = (*func_RtlDosPathNameToNtPathName_U_WithStatus)(ctx->common.target, - &ctx->target_ntpath, - NULL, NULL); - } else { - if ((*func_RtlDosPathNameToNtPathName_U)(ctx->common.target, - &ctx->target_ntpath, - NULL, NULL)) - status = STATUS_SUCCESS; - else - status = STATUS_NO_MEMORY; - } - if (!NT_SUCCESS(status)) { - if (status == STATUS_NO_MEMORY) { - return WIMLIB_ERR_NOMEM; - } else { - ERROR("\"%ls\": invalid path name " - "(status=0x%08"PRIx32")", - ctx->common.target, (u32)status); - return WIMLIB_ERR_INVALID_PARAM; - } - } + ret = win32_path_to_nt_path(ctx->common.target, &ctx->target_ntpath); + if (ret) + return ret; ctx->attr.Length = sizeof(ctx->attr); ctx->attr.ObjectName = &ctx->target_ntpath; @@ -567,9 +805,11 @@ prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx) path_max = compute_path_max(dentry_list); - /* Add some extra for building Win32 paths for the file encryption APIs - * ... */ - path_max += 2 + (ctx->target_ntpath.Length / sizeof(wchar_t)); + /* 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. */ + path_max += max(2 + (ctx->target_ntpath.Length / sizeof(wchar_t)), + 8 + 1 + 3); ctx->pathbuf.MaximumLength = path_max * sizeof(wchar_t); ctx->pathbuf.Buffer = MALLOC(ctx->pathbuf.MaximumLength); @@ -590,11 +830,11 @@ prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx) /* When creating an inode that will have a short (DOS) name, we create it using * the long name associated with the short name. This ensures that the short * name gets associated with the correct long name. */ -static const struct wim_dentry * +static struct wim_dentry * first_extraction_alias(const struct wim_inode *inode) { - const struct list_head *next = inode->i_extraction_aliases.next; - const struct wim_dentry *dentry; + struct list_head *next = inode->i_extraction_aliases.next; + struct wim_dentry *dentry; do { dentry = list_entry(next, struct wim_dentry, @@ -683,7 +923,7 @@ adjust_compression_attribute(HANDLE h, const struct wim_dentry *dentry, * handle to the file. If it does, it sets it to NULL. */ static int -maybe_clear_encryption_attribute(HANDLE *h_ret, const struct wim_dentry *dentry, +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) @@ -700,7 +940,7 @@ maybe_clear_encryption_attribute(HANDLE *h_ret, const struct wim_dentry *dentry, BOOL bret; /* Get current attributes */ - status = (*func_NtQueryInformationFile)(*h_ret, &ctx->iosb, + status = (*func_NtQueryInformationFile)(*h_ptr, &ctx->iosb, &info, sizeof(info), FileBasicInformation); if (NT_SUCCESS(status) && @@ -716,8 +956,8 @@ maybe_clear_encryption_attribute(HANDLE *h_ret, const struct wim_dentry *dentry, * 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_ret); - *h_ret = NULL; + (*func_NtClose)(*h_ptr); + *h_ptr = NULL; build_win32_extraction_path(dentry, ctx); @@ -736,6 +976,109 @@ maybe_clear_encryption_attribute(HANDLE *h_ret, const struct wim_dentry *dentry, 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 +try_to_enable_short_names(const wchar_t *volume) +{ + HANDLE h; + FILE_FS_PERSISTENT_VOLUME_INFORMATION info; + BOOL bret; + DWORD bytesReturned; + + h = CreateFile(volume, GENERIC_WRITE, + FILE_SHARE_VALID_FLAGS, NULL, OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS, NULL); + if (h == INVALID_HANDLE_VALUE) + goto fail; + + info.VolumeFlags = 0; + info.FlagMask = PERSISTENT_VOLUME_STATE_SHORT_NAME_CREATION_DISABLED; + info.Version = 1; + info.Reserved = 0; + + bret = DeviceIoControl(h, FSCTL_SET_PERSISTENT_VOLUME_STATE, + &info, sizeof(info), NULL, 0, + &bytesReturned, NULL); + + CloseHandle(h); + + if (!bret) + goto fail; + return true; + +fail: + WARNING("Failed to enable short name support on %ls " + "(err=%"PRIu32")", volume + 4, (u32)GetLastError()); + return false; +} + +static NTSTATUS +remove_conflicting_short_name(const struct wim_dentry *dentry, struct win32_apply_ctx *ctx) +{ + wchar_t *name; + wchar_t *end; + NTSTATUS status; + HANDLE h; + size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) + + (13 * sizeof(wchar_t)); + u8 buf[bufsize] _aligned_attribute(8); + bool retried = false; + FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf; + + memset(buf, 0, bufsize); + + /* Build the path with the short name. */ + 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); + ctx->pathbuf.Length = ((u8 *)end - (u8 *)ctx->pathbuf.Buffer); + + /* Open the conflicting file (by short name). */ + status = (*func_NtOpenFile)(&h, GENERIC_WRITE | DELETE, + &ctx->attr, &ctx->iosb, + 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); + goto out; + } + +#if 0 + WARNING("Overriding conflicting short name; path=\"%ls\"", + current_path(ctx)); +#endif + + /* Try to remove the short name on the conflicting file. */ + +retry: + status = (*func_NtSetInformationFile)(h, &ctx->iosb, info, bufsize, + FileShortNameInformation); + + if (status == STATUS_INVALID_PARAMETER && !retried) { + + /* Microsoft forgot to make it possible to remove short names + * until Windows 7. Oops. Use a random short name instead. */ + + info->FileNameLength = 12 * sizeof(wchar_t); + for (int i = 0; i < 8; i++) + info->FileName[i] = 'A' + (rand() % 26); + info->FileName[8] = L'.'; + info->FileName[9] = L'W'; + info->FileName[10] = L'L'; + info->FileName[11] = L'B'; + info->FileName[12] = L'\0'; + retried = true; + goto retry; + } + (*func_NtClose)(h); +out: + build_extraction_path(dentry, ctx); + return status; +} + /* Set the short name on the open file @h which has been created at the location * indicated by @dentry. * @@ -750,29 +1093,96 @@ static int set_short_name(HANDLE h, const struct wim_dentry *dentry, struct win32_apply_ctx *ctx) { + + if (!ctx->common.supported_features.short_names) + return 0; + + /* + * Note: The size of the FILE_NAME_INFORMATION buffer must be such that + * FileName contains at least 2 wide characters (4 bytes). Otherwise, + * NtSetInformationFile() will return STATUS_INFO_LENGTH_MISMATCH. This + * is despite the fact that FileNameLength can validly be 0 or 2 bytes, + * with the former case being removing the existing short name if + * present, rather than setting one. + * + * The null terminator is seemingly optional, but to be safe we include + * space for it and zero all unused space. + */ + size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) + - dentry->short_name_nbytes; + max(dentry->short_name_nbytes, sizeof(wchar_t)) + + sizeof(wchar_t); u8 buf[bufsize] _aligned_attribute(8); FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf; NTSTATUS status; + bool tried_to_remove_existing = false; + + memset(buf, 0, bufsize); info->FileNameLength = dentry->short_name_nbytes; memcpy(info->FileName, dentry->short_name, dentry->short_name_nbytes); +retry: status = (*func_NtSetInformationFile)(h, &ctx->iosb, info, bufsize, FileShortNameInformation); if (NT_SUCCESS(status)) return 0; + if (status == STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME) { + if (dentry->short_name_nbytes == 0) + return 0; + if (!ctx->tried_to_enable_short_names) { + wchar_t volume[7]; + int ret; + + ctx->tried_to_enable_short_names = true; + + ret = win32_get_drive_path(ctx->common.target, + volume); + if (ret) + return ret; + if (try_to_enable_short_names(volume)) + goto retry; + } + } + + /* + * Short names can conflict in several cases: + * + * - a file being extracted has a short name conflicting with an + * existing file + * + * - a file being extracted has a short name conflicting with another + * file being extracted (possible, but shouldn't happen) + * + * - a file being extracted has a short name that conflicts with the + * automatically generated short name of a file we previously + * extracted, but failed to set the short name for. Sounds unlikely, + * but this actually does happen fairly often on versions of Windows + * prior to Windows 7 because they do not support removing short names + * from files. + */ + if (unlikely(status == STATUS_OBJECT_NAME_COLLISION) && + dentry->short_name_nbytes && !tried_to_remove_existing) + { + tried_to_remove_existing = true; + status = remove_conflicting_short_name(dentry, ctx); + if (NT_SUCCESS(status)) + goto 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 (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SHORT_NAMES)) { + if (dentry->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) { - if (dentry->short_name_nbytes == 0) - return 0; - ERROR("Can't extract short name when short " + 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")", @@ -970,15 +1380,20 @@ create_directories(struct list_head *dentry_list, * wait until later to actually set the reparse data. */ /* If the root dentry is being extracted, it was already done so - * it prepare_target(). */ - if (dentry_is_root(dentry)) - continue; + * in prepare_target(). */ + if (!dentry_is_root(dentry)) { + ret = create_directory(dentry, ctx); + ret = check_apply_error(dentry, ctx, ret); + if (ret) + return ret; - ret = create_directory(dentry, ctx); - if (ret) - return ret; + ret = create_any_empty_ads(dentry, ctx); + ret = check_apply_error(dentry, ctx, ret); + if (ret) + return ret; + } - ret = create_any_empty_ads(dentry, ctx); + ret = report_file_created(&ctx->common); if (ret) return ret; } @@ -1184,9 +1599,9 @@ create_links(HANDLE h, const struct wim_dentry *first_dentry, /* Create a nondirectory file, including all links. */ static int -create_nondirectory(const struct wim_inode *inode, struct win32_apply_ctx *ctx) +create_nondirectory(struct wim_inode *inode, struct win32_apply_ctx *ctx) { - const struct wim_dentry *first_dentry; + struct wim_dentry *first_dentry; HANDLE h; int ret; @@ -1205,6 +1620,10 @@ create_nondirectory(const struct wim_inode *inode, struct win32_apply_ctx *ctx) if (!ret) ret = create_links(h, first_dentry, 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); + (*func_NtClose)(h); return ret; } @@ -1214,8 +1633,8 @@ create_nondirectory(const struct wim_inode *inode, struct win32_apply_ctx *ctx) static int create_nondirectories(struct list_head *dentry_list, struct win32_apply_ctx *ctx) { - const struct wim_dentry *dentry; - const struct wim_inode *inode; + struct wim_dentry *dentry; + struct wim_inode *inode; int ret; list_for_each_entry(dentry, dentry_list, d_extraction_list_node) { @@ -1223,9 +1642,13 @@ create_nondirectories(struct list_head *dentry_list, struct win32_apply_ctx *ctx if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) continue; /* Call create_nondirectory() only once per inode */ - if (dentry != inode_first_extraction_dentry(inode)) - continue; - ret = create_nondirectory(inode, ctx); + if (dentry == inode_first_extraction_dentry(inode)) { + ret = create_nondirectory(inode, ctx); + ret = check_apply_error(dentry, ctx, ret); + if (ret) + return ret; + } + ret = report_file_created(&ctx->common); if (ret) return ret; } @@ -1241,17 +1664,17 @@ close_handles(struct win32_apply_ctx *ctx) /* Prepare to read the next stream, which has size @stream_size, into an * in-memory buffer. */ -static int +static bool prepare_data_buffer(struct win32_apply_ctx *ctx, u64 stream_size) { if (stream_size > ctx->data_buffer_size) { /* Larger buffer needed. */ void *new_buffer; if ((size_t)stream_size != stream_size) - return WIMLIB_ERR_NOMEM; + return false; new_buffer = REALLOC(ctx->data_buffer, stream_size); if (!new_buffer) - return WIMLIB_ERR_NOMEM; + return false; ctx->data_buffer = new_buffer; ctx->data_buffer_size = stream_size; } @@ -1259,7 +1682,7 @@ prepare_data_buffer(struct win32_apply_ctx *ctx, u64 stream_size) * 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 @@ -1295,8 +1718,10 @@ begin_extract_stream_instance(const struct wim_lookup_table_entry *stream, * with FSCTL_SET_REPARSE_POINT, which requires that all the * data be available. So, stage the data in a buffer. */ + if (!prepare_data_buffer(ctx, stream->size)) + return WIMLIB_ERR_NOMEM; list_add_tail(&dentry->tmp_list, &ctx->reparse_dentries); - return prepare_data_buffer(ctx, stream->size); + return 0; } /* Encrypted file? */ @@ -1317,47 +1742,17 @@ begin_extract_stream_instance(const struct wim_lookup_table_entry *stream, * TODO: This isn't sufficient for extremely large encrypted * files. Perhaps we should create an extra thread to write * such files... */ + if (!prepare_data_buffer(ctx, stream->size)) + return WIMLIB_ERR_NOMEM; list_add_tail(&dentry->tmp_list, &ctx->encrypted_dentries); - return prepare_data_buffer(ctx, stream->size); - } - - /* Extracting unnamed data stream in WIMBoot mode? */ - if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT) - && (stream_name_nchars == 0) - && (stream->resource_location == RESOURCE_IN_WIM) - && (stream->rspec->wim == ctx->common.wim) - && (stream->size == stream->rspec->uncompressed_size)) - { - int ret = calculate_dentry_full_path(dentry); - if (ret) - return ret; - if (in_prepopulate_list(dentry, ctx)) { - union wimlib_progress_info info; - - info.wimboot_exclude.path_in_wim = dentry->_full_path; - info.wimboot_exclude.extraction_path = current_path(ctx); - - ret = call_progress(ctx->common.progfunc, - WIMLIB_PROGRESS_MSG_WIMBOOT_EXCLUDE, - &info, ctx->common.progctx); - FREE(dentry->_full_path); - dentry->_full_path = NULL; - return ret; - } else { - FREE(dentry->_full_path); - dentry->_full_path = NULL; - return wimboot_set_pointer(&ctx->attr, - current_path(ctx), - stream, - ctx->wimboot.data_source_id, - ctx->wimboot.wim_lookup_table_hash, - ctx->wimboot.wof_running); - } + return 0; } - /* Too many open handles? */ - if (ctx->num_open_handles == MAX_OPEN_HANDLES) { - ERROR("Too many open handles!"); + if (ctx->num_open_handles == MAX_OPEN_STREAMS) { + /* 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. */ + ERROR("Can't extract data: too many open files!"); return WIMLIB_ERR_UNSUPPORTED; } @@ -1467,7 +1862,13 @@ skip_nt_toplevel_component(const wchar_t *path, size_t path_nchars) /* 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. */ + * 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) { @@ -1480,7 +1881,7 @@ get_device_relative_path(const wchar_t *path, size_t path_nchars) path = wmemchr(path, L'\\', (end - path)); if (!path) - return orig_path; + return end; do { path++; } while (path != end && *path == L'\\'); @@ -1529,14 +1930,18 @@ try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx) target_ntpath_nchars = ctx->target_ntpath.Length / sizeof(wchar_t); - fixed_subst_name_nchars = target_ntpath_nchars + 1 + relpath_nchars; + fixed_subst_name_nchars = target_ntpath_nchars; + if (relpath_nchars) + fixed_subst_name_nchars += 1 + relpath_nchars; wchar_t fixed_subst_name[fixed_subst_name_nchars]; wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer, target_ntpath_nchars); - fixed_subst_name[target_ntpath_nchars] = L'\\'; - wmemcpy(&fixed_subst_name[target_ntpath_nchars + 1], - relpath, relpath_nchars); + if (relpath_nchars) { + fixed_subst_name[target_ntpath_nchars] = L'\\'; + wmemcpy(&fixed_subst_name[target_ntpath_nchars + 1], + relpath, relpath_nchars); + } /* Doesn't need to be null-terminated. */ /* Print name should be Win32, but not all NT names can even be @@ -1638,8 +2043,7 @@ extract_encrypted_file(const struct wim_dentry *dentry, /* Called when starting to read a stream for extraction on Windows */ static int -begin_extract_stream(struct wim_lookup_table_entry *stream, - u32 flags, void *_ctx) +begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx) { struct win32_apply_ctx *ctx = _ctx; const struct stream_owner *owners = stream_owners(stream); @@ -1661,6 +2065,7 @@ begin_extract_stream(struct wim_lookup_table_entry *stream, dentry = inode_first_extraction_dentry(inode); ret = begin_extract_stream_instance(stream, dentry, stream_name, ctx); + ret = check_apply_error(dentry, ctx, ret); if (ret) goto fail; } else { @@ -1676,6 +2081,7 @@ begin_extract_stream(struct wim_lookup_table_entry *stream, dentry, stream_name, ctx); + ret = check_apply_error(dentry, ctx, ret); if (ret) goto fail; next = next->next; @@ -1683,11 +2089,6 @@ begin_extract_stream(struct wim_lookup_table_entry *stream, } } - if (unlikely(ctx->num_open_handles == 0 && ctx->data_buffer_ptr == NULL)) { - /* The data of this stream isn't actually needed! - * (This can happen in WIMBoot mode.) */ - return BEGIN_STREAM_STATUS_SKIP_STREAM; - } return 0; fail: @@ -1758,7 +2159,8 @@ end_extract_stream(struct wim_lookup_table_entry *stream, int status, void *_ctx "%"PRIu64" bytes (exceeds %u bytes)", current_path(ctx), stream->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. */ @@ -1770,6 +2172,7 @@ end_extract_stream(struct wim_lookup_table_entry *stream, int status, void *_ctx ret = set_reparse_data(dentry, &ctx->rpbuf, stream->size + REPARSE_DATA_OFFSET, ctx); + ret = check_apply_error(dentry, ctx, ret); if (ret) return ret; } @@ -1779,6 +2182,7 @@ end_extract_stream(struct wim_lookup_table_entry *stream, int status, void *_ctx ctx->encrypted_size = stream->size; list_for_each_entry(dentry, &ctx->encrypted_dentries, tmp_list) { ret = extract_encrypted_file(dentry, ctx); + ret = check_apply_error(dentry, ctx, ret); if (ret) return ret; } @@ -1798,33 +2202,100 @@ end_extract_stream(struct wim_lookup_table_entry *stream, int status, void *_ctx /* Set the security descriptor @desc, of @desc_size bytes, on the file with open * handle @h. */ static NTSTATUS -set_security_descriptor(HANDLE h, const void *desc, +set_security_descriptor(HANDLE h, const void *_desc, size_t desc_size, struct win32_apply_ctx *ctx) { SECURITY_INFORMATION info; NTSTATUS status; + SECURITY_DESCRIPTOR_RELATIVE *desc; + + /* + * Ideally, we would just pass in the security descriptor buffer as-is. + * But it turns out that Windows can mess up the security descriptor + * even when using the low-level NtSetSecurityObject() function: + * + * - Windows will clear SE_DACL_AUTO_INHERITED if it is set in the + * passed buffer. To actually get Windows to set + * SE_DACL_AUTO_INHERITED, the application must set the non-persistent + * flag SE_DACL_AUTO_INHERIT_REQ. As usual, Microsoft didn't bother + * to properly document either of these flags. It's unclear how + * important SE_DACL_AUTO_INHERITED actually is, but to be safe we use + * the SE_DACL_AUTO_INHERIT_REQ workaround to set it if needed. + * + * - The above also applies to the equivalent SACL flags, + * SE_SACL_AUTO_INHERITED and SE_SACL_AUTO_INHERIT_REQ. + * + * - If the application says that it's setting + * DACL_SECURITY_INFORMATION, then Windows sets SE_DACL_PRESENT in the + * resulting security descriptor, even if the security descriptor the + * application provided did not have a DACL. This seems to be + * unavoidable, since omitting DACL_SECURITY_INFORMATION would cause a + * default DACL to remain. Fortunately, this behavior seems harmless, + * since the resulting DACL will still be "null" --- but it will be + * "the other representation of null". + * + * - The above also applies to SACL_SECURITY_INFORMATION and + * SE_SACL_PRESENT. Again, it's seemingly unavoidable but "harmless" + * that Windows changes the representation of a "null SACL". + */ + if (likely(desc_size <= STACK_MAX)) { + desc = alloca(desc_size); + } else { + desc = MALLOC(desc_size); + if (!desc) + return STATUS_NO_MEMORY; + } + + memcpy(desc, _desc, desc_size); + + if (likely(desc_size >= 4)) { + + if (desc->Control & SE_DACL_AUTO_INHERITED) + desc->Control |= SE_DACL_AUTO_INHERIT_REQ; + + if (desc->Control & SE_SACL_AUTO_INHERITED) + desc->Control |= SE_SACL_AUTO_INHERIT_REQ; + } + + /* + * More API insanity. We want to set the entire security descriptor + * as-is. But all available APIs require specifying the specific parts + * of the security descriptor being set. Especially annoying is that + * mandatory integrity labels are part of the SACL, but they aren't set + * with SACL_SECURITY_INFORMATION. Instead, applications must also + * specify LABEL_SECURITY_INFORMATION (Windows Vista, Windows 7) or + * BACKUP_SECURITY_INFORMATION (Windows 8). But at least older versions + * of Windows don't error out if you provide these newer flags... + * + * Also, if the process isn't running as Administrator, then it probably + * doesn't have SE_RESTORE_PRIVILEGE. In this case, it will always get + * the STATUS_PRIVILEGE_NOT_HELD error by trying to set the SACL, even + * if the security descriptor it provided did not have a SACL. By + * default, in this case we try to recover and set as much of the + * security descriptor as possible --- potentially excluding the DACL, and + * even the owner, as well as the SACL. + */ - /* We really just want to set entire the security descriptor as-is, but - * all available APIs require specifying the specific parts of the - * descriptor being set. Start out by requesting all parts be set. If - * permissions problems are encountered, fall back to omitting some - * parts (first the SACL, then the DACL, then the owner), unless the - * WIMLIB_EXTRACT_FLAG_STRICT_ACLS flag has been enabled. */ info = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | - DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION; - - /* Prefer NtSetSecurityObject() to SetFileSecurity(). SetFileSecurity() - * itself necessarily uses NtSetSecurityObject() as the latter is the - * underlying system call for setting security information, but - * SetFileSecurity() opens the handle with NtCreateFile() without - * FILE_OPEN_FILE_BACKUP_INTENT. Hence, access checks are done and due - * to the Windows security model, even a process running as the - * Administrator can have access denied. (Of course, this not mentioned - * in the MS "documentation".) */ + DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION | + LABEL_SECURITY_INFORMATION | BACKUP_SECURITY_INFORMATION; + + + /* + * It's also worth noting that SetFileSecurity() is unusable because it + * doesn't request "backup semantics" when it opens the file internally. + * NtSetSecurityObject() seems to be the best function to use in backup + * applications. (SetSecurityInfo() should also work, but it's harder + * to use and must call NtSetSecurityObject() internally anyway. + * BackupWrite() is theoretically usable as well, but it's inflexible + * and poorly documented.) + */ + retry: - status = (*func_NtSetSecurityObject)(h, info, (PSECURITY_DESCRIPTOR)desc); + status = (*func_NtSetSecurityObject)(h, info, desc); if (NT_SUCCESS(status)) - return status; + goto out_maybe_free_desc; + /* Failed to set the requested parts of the security descriptor. If the * error was permissions-related, try to set fewer parts of the security * descriptor, unless WIMLIB_EXTRACT_FLAG_STRICT_ACLS is enabled. */ @@ -1833,7 +2304,9 @@ retry: !(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS)) { if (info & SACL_SECURITY_INFORMATION) { - info &= ~SACL_SECURITY_INFORMATION; + info &= ~(SACL_SECURITY_INFORMATION | + LABEL_SECURITY_INFORMATION | + BACKUP_SECURITY_INFORMATION); ctx->partial_security_descriptors++; goto retry; } @@ -1855,6 +2328,10 @@ retry: if (!(info & SACL_SECURITY_INFORMATION)) ctx->partial_security_descriptors--; ctx->no_security_descriptors++; + +out_maybe_free_desc: + if (unlikely(desc_size > STACK_MAX)) + FREE(desc); return status; } @@ -1981,6 +2458,10 @@ 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); if (ret) return ret; } @@ -1993,24 +2474,54 @@ apply_metadata(struct list_head *dentry_list, struct win32_apply_ctx *ctx) static void do_warnings(const struct win32_apply_ctx *ctx) { - if (ctx->partial_security_descriptors == 0 && - ctx->no_security_descriptors == 0) + if (ctx->partial_security_descriptors == 0 + && ctx->no_security_descriptors == 0 + && ctx->num_set_short_name_failures == 0 + #if 0 + && ctx->num_remove_short_name_failures == 0 + #endif + ) return; WARNING("Extraction to \"%ls\" complete, but with one or more warnings:", ctx->common.target); - if (ctx->partial_security_descriptors != 0) { + if (ctx->num_set_short_name_failures) { + WARNING("- Could not set short names on %lu files or directories", + ctx->num_set_short_name_failures); + } +#if 0 + if (ctx->num_remove_short_name_failures) { + WARNING("- Could not remove short names on %lu files or directories" + " (This is expected on Vista and earlier)", + ctx->num_remove_short_name_failures); + } +#endif + if (ctx->partial_security_descriptors) { WARNING("- Could only partially set the security descriptor\n" " on %lu files or directories.", ctx->partial_security_descriptors); } - if (ctx->no_security_descriptors != 0) { + if (ctx->no_security_descriptors) { WARNING("- Could not set security descriptor at all\n" " on %lu files or directories.", ctx->no_security_descriptors); } - WARNING("To fully restore all security descriptors, run the program\n" - " with Administrator rights."); + if (ctx->partial_security_descriptors || ctx->no_security_descriptors) { + WARNING("To fully restore all security descriptors, run the program\n" + " with Administrator rights."); + } +} + +static uint64_t +count_dentries(const struct list_head *dentry_list) +{ + const struct list_head *cur; + uint64_t count = 0; + + list_for_each(cur, dentry_list) + count++; + + return count; } /* Extract files from a WIM image to a directory on Windows */ @@ -2019,17 +2530,24 @@ 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; ret = prepare_target(dentry_list, ctx); if (ret) goto out; - if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT) { + if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) { ret = start_wimboot_extraction(ctx); if (ret) goto out; } + dentry_count = count_dentries(dentry_list); + + ret = start_file_structure_phase(&ctx->common, dentry_count); + if (ret) + goto out; + ret = create_directories(dentry_list, ctx); if (ret) goto out; @@ -2038,6 +2556,10 @@ win32_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) if (ret) goto out; + ret = end_file_structure_phase(&ctx->common); + if (ret) + goto out; + struct read_stream_list_callbacks cbs = { .begin_stream = begin_extract_stream, .begin_stream_ctx = ctx, @@ -2050,10 +2572,24 @@ win32_extract(struct list_head *dentry_list, struct apply_ctx *_ctx) if (ret) goto out; + ret = start_file_metadata_phase(&ctx->common, dentry_count); + if (ret) + goto out; + ret = apply_metadata(dentry_list, ctx); if (ret) goto out; + ret = end_file_metadata_phase(&ctx->common); + if (ret) + goto out; + + if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) { + ret = end_wimboot_extraction(ctx); + if (ret) + goto out; + } + do_warnings(ctx); out: if (ctx->h_target) @@ -2075,5 +2611,8 @@ 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, .context_size = sizeof(struct win32_apply_ctx), }; + +#endif /* __WIN32__ */