*/
/*
- * Copyright (C) 2013, 2014, 2015 Eric Biggers
+ * Copyright (C) 2013-2016 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
#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/metadata.h"
+#include "wimlib/object_id.h"
#include "wimlib/paths.h"
+#include "wimlib/pattern.h"
#include "wimlib/reparse.h"
+#include "wimlib/scan.h" /* for mangle_pat() and match_pattern_list() */
#include "wimlib/textfile.h"
#include "wimlib/xml.h"
-#include "wimlib/wildcard.h"
#include "wimlib/wimboot.h"
+#include "wimlib/wof.h"
struct win32_apply_ctx {
u8 blob_table_hash[SHA1_HASH_SIZE];
} *wims;
size_t num_wims;
- struct string_set *prepopulate_pats;
- void *mem_prepopulate_pats;
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_list *prepopulate_pats;
+ void *mem_prepopulate_pats;
+ bool tried_to_load_prepopulate_list;
+
/* Open handle to the target directory */
HANDLE h_target;
* 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 blob has been read into @data_buffer.
- * */
+ /* For each currently open stream, whether we're writing to it in
+ * "sparse" mode or not. */
+ bool is_sparse_stream[MAX_OPEN_FILES];
+
+ /* Whether is_sparse_stream[] is true for any currently open stream */
+ bool any_sparse_streams;
+
+ /* 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
+ /* 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 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;
+
+ /* The number of files which, for compatibility with the Windows
+ * bootloader, were not compressed using the requested system
+ * compression format. This includes matches with the hardcoded pattern
+ * list only; it does not include matches with patterns in
+ * [PrepopulateList]. */
+ unsigned long num_system_compression_exclusions;
+
+ /* Number of files for which we couldn't set the object ID. */
+ unsigned long num_object_id_failures;
+
+ /* The Windows build number of the image being applied, or 0 if unknown.
+ */
+ u64 windows_build_number;
+
/* Have we tried to enable short name support on the target volume yet?
*/
bool tried_to_enable_short_names;
}
}
+/* Is the image being extracted an OS image for Windows 10 or later? */
+static bool
+is_image_windows_10_or_later(struct win32_apply_ctx *ctx)
+{
+ /* Note: if no build number is available, this returns false. */
+ return ctx->windows_build_number >= 10240;
+}
+
static const wchar_t *
current_path(struct win32_apply_ctx *ctx);
get_vol_flags(target, &vol_flags, &short_names_supported);
- supported_features->archive_files = 1;
+ supported_features->readonly_files = 1;
supported_features->hidden_files = 1;
supported_features->system_files = 1;
+ supported_features->archive_files = 1;
if (vol_flags & FILE_FILE_COMPRESSION)
supported_features->compressed_files = 1;
supported_features->not_context_indexed_files = 1;
- /* Don't do anything with FILE_SUPPORTS_SPARSE_FILES. */
+ if (vol_flags & FILE_SUPPORTS_SPARSE_FILES)
+ supported_features->sparse_files = 1;
if (vol_flags & FILE_NAMED_STREAMS)
supported_features->named_data_streams = 1;
if (short_names_supported)
supported_features->short_names = 1;
+ if (vol_flags & FILE_SUPPORTS_OBJECT_IDS)
+ supported_features->object_ids = 1;
+
supported_features->timestamps = 1;
- /* Note: Windows does not support case sensitive filenames! At least
- * not without changing the registry and rebooting... */
+ if (vol_flags & FILE_CASE_SENSITIVE_SEARCH) {
+ /*
+ * The filesystem supports case-sensitive filenames. But does
+ * the operating system as well? This normally requires the
+ * registry setting ObCaseInsensitive=0. We can test it
+ * indirectly by attempting to open the "\SystemRoot" symbolic
+ * link using a name with the wrong case. If we get
+ * STATUS_OBJECT_NAME_NOT_FOUND instead of STATUS_ACCESS_DENIED,
+ * then case-sensitive names must be enabled.
+ */
+ UNICODE_STRING path;
+ OBJECT_ATTRIBUTES attr;
+ HANDLE h;
+ NTSTATUS status;
+
+ RtlInitUnicodeString(&path, L"\\systemroot");
+ InitializeObjectAttributes(&attr, &path, 0, NULL, NULL);
+
+ status = NtOpenSymbolicLinkObject(&h, 0, &attr);
+ if (status == STATUS_OBJECT_NAME_NOT_FOUND)
+ supported_features->case_sensitive_filenames = 1;
+ }
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 struct blob_descriptor *blob;
int ret;
void *buf;
- struct string_set *s;
+ struct string_list *strings;
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 ||
if (ret)
return ret;
- s = CALLOC(1, sizeof(struct string_set));
- if (!s) {
+ strings = CALLOC(1, sizeof(struct string_list));
+ if (!strings) {
FREE(buf);
return WIMLIB_ERR_NOMEM;
}
sec.name = T("PrepopulateList");
- sec.strings = s;
+ sec.strings = strings;
ret = do_load_text_file(path, buf, blob->size, &mem, &sec, 1,
LOAD_TEXT_FILE_REMOVE_QUOTES |
LOAD_TEXT_FILE_NO_WARNINGS,
mangle_pat);
- BUILD_BUG_ON(OS_PREFERRED_PATH_SEPARATOR != WIM_PATH_SEPARATOR);
+ STATIC_ASSERT(OS_PREFERRED_PATH_SEPARATOR == WIM_PATH_SEPARATOR);
FREE(buf);
if (ret) {
- FREE(s);
+ FREE(strings);
return ret;
}
- ctx->wimboot.prepopulate_pats = s;
- ctx->wimboot.mem_prepopulate_pats = mem;
+ ctx->prepopulate_pats = strings;
+ 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
* 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)
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 wim_dentry *dentry;
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;
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);
- if (!blob || blob->blob_location != BLOB_IN_WIM ||
- !is_resource_valid_for_external_backing(blob->rdesc, ctx))
- return WIM_BACKING_NOT_POSSIBLE;
+ if (!blob)
+ return EXTERNAL_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
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;
}
}
}
/*
- * 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;
-
- if (!ctx->wimboot.tried_to_load_prepopulate_list)
- if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM)
- return WIMLIB_ERR_NOMEM;
+ return EXTERNAL_BACKING_NOT_ENABLED;
- return will_externally_back_inode(dentry->d_inode, ctx, NULL);
+ return will_externally_back_inode(dentry->d_inode, ctx, NULL, true);
}
/* Find the WOF registration information for the specified WIM file. */
}
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,
return 0;
}
-/* Prepare for doing a "WIMBoot" extraction by loading patterns from
- * [PrepopulateList] of WimBootCompress.ini and registering each source WIM file
+/* 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 (!ctx->wimboot.tried_to_load_prepopulate_list)
- if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM)
- return WIMLIB_ERR_NOMEM;
-
- if (!wim_info_get_wimboot(ctx->common.wim->wim_info,
- ctx->common.wim->current_image))
+ if (!xml_get_wimboot(ctx->common.wim->xml_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_externally_back(dentry, &ctx->common);
+ ret = win32_will_back_from_wim(dentry, &ctx->common);
if (ret > 0) /* Error */
return ret;
if (ret < 0) /* Won't externally back */
build_win32_extraction_path(dentry, ctx);
- randomize_char_array_with_alnum(subkeyname, 20);
+ get_random_alnum_chars(subkeyname, 20);
subkeyname[20] = L'\0';
res = RegLoadKey(HKEY_LOCAL_MACHINE, subkeyname, ctx->pathbuf.Buffer);
d = d->d_parent)
{
p -= d->d_extraction_name_nchars;
- wmemcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
+ if (d->d_extraction_name_nchars)
+ wmemcpy(p, d->d_extraction_name,
+ d->d_extraction_name_nchars);
*--p = '\\';
}
/* No leading slash */
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,
- &ctx->iosb,
- NULL,
- 0,
- FILE_SHARE_VALID_FLAGS,
- FILE_OPEN_IF,
- FILE_DIRECTORY_FILE |
- FILE_OPEN_REPARSE_POINT |
- FILE_OPEN_FOR_BACKUP_INTENT,
- NULL,
- 0);
+
+ /* Don't use FILE_OPEN_REPARSE_POINT here; we want the extraction to
+ * happen at the directory "pointed to" by the reparse point. */
+ status = NtCreateFile(&ctx->h_target,
+ FILE_TRAVERSE,
+ &ctx->attr,
+ &ctx->iosb,
+ NULL,
+ 0,
+ FILE_SHARE_VALID_FLAGS,
+ FILE_OPEN_IF,
+ FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT,
+ NULL,
+ 0);
if (!NT_SUCCESS(status)) {
winnt_error(status, L"Can't open or create directory \"%ls\"",
ctx->common.target);
close_target_directory(struct win32_apply_ctx *ctx)
{
if (ctx->h_target) {
- (*func_NtClose)(ctx->h_target);
+ NtClose(ctx->h_target);
ctx->h_target = NULL;
ctx->attr.RootDirectory = NULL;
}
{
const bool compressed = (dentry->d_inode->i_attributes &
FILE_ATTRIBUTE_COMPRESSED);
+ FILE_BASIC_INFORMATION info;
+ USHORT compression_state;
+ NTSTATUS status;
if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES)
return 0;
if (!ctx->common.supported_features.compressed_files)
return 0;
- FILE_BASIC_INFORMATION info;
- NTSTATUS status;
- USHORT compression_state;
/* Get current attributes */
- status = (*func_NtQueryInformationFile)(h, &ctx->iosb,
- &info, sizeof(info),
- FileBasicInformation);
+ status = NtQueryInformationFile(h, &ctx->iosb, &info, sizeof(info),
+ FileBasicInformation);
if (NT_SUCCESS(status) &&
compressed == !!(info.FileAttributes & FILE_ATTRIBUTE_COMPRESSED))
{
else
compression_state = COMPRESSION_FORMAT_NONE;
- status = (*func_NtFsControlFile)(h,
- NULL,
- NULL,
- NULL,
- &ctx->iosb,
- FSCTL_SET_COMPRESSION,
- &compression_state,
- sizeof(USHORT),
- NULL,
- 0);
+ status = winnt_fsctl(h, FSCTL_SET_COMPRESSION,
+ &compression_state, sizeof(USHORT), NULL, 0, NULL);
if (NT_SUCCESS(status))
return 0;
return WIMLIB_ERR_SET_ATTRIBUTES;
}
+static bool
+need_sparse_flag(const struct wim_inode *inode,
+ const struct win32_apply_ctx *ctx)
+{
+ return (inode->i_attributes & FILE_ATTRIBUTE_SPARSE_FILE) &&
+ ctx->common.supported_features.sparse_files;
+}
+
+static int
+set_sparse_flag(HANDLE h, struct win32_apply_ctx *ctx)
+{
+ NTSTATUS status;
+
+ status = winnt_fsctl(h, FSCTL_SET_SPARSE, NULL, 0, NULL, 0, NULL);
+ if (NT_SUCCESS(status))
+ return 0;
+
+ winnt_error(status, L"Can't set sparse flag on \"%ls\"",
+ current_path(ctx));
+ return WIMLIB_ERR_SET_ATTRIBUTES;
+}
+
/* Try to enable short name support on the target volume. If successful, return
* true. If unsuccessful, issue a warning and return false. */
static bool
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);
+ status = 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)) {
winnt_warning(status, L"Can't open \"%ls\"", current_path(ctx));
goto out;
/* Try to remove the short name on the conflicting file. */
retry:
- status = (*func_NtSetInformationFile)(h, &ctx->iosb, info, bufsize,
- FileShortNameInformation);
+ status = 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. */
-
+ get_random_alnum_chars(info->FileName, 8);
+ wcscpy(&info->FileName[8], L".WLB");
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);
+ NtClose(h);
out:
build_extraction_path(dentry, ctx);
return status;
memcpy(info->FileName, dentry->d_short_name, dentry->d_short_name_nbytes);
retry:
- status = (*func_NtSetInformationFile)(h, &ctx->iosb, info, bufsize,
- FileShortNameInformation);
+ status = NtSetInformationFile(h, &ctx->iosb, info, bufsize,
+ FileShortNameInformation);
if (NT_SUCCESS(status))
return 0;
* A wrapper around NtCreateFile() to make it slightly more usable...
* This uses the path currently constructed in ctx->pathbuf.
*
- * Also, we always specify FILE_OPEN_FOR_BACKUP_INTENT and
+ * Also, we always specify SYNCHRONIZE access, FILE_OPEN_FOR_BACKUP_INTENT, and
* FILE_OPEN_REPARSE_POINT.
*/
static NTSTATUS
ULONG CreateOptions,
struct win32_apply_ctx *ctx)
{
- return (*func_NtCreateFile)(FileHandle,
- DesiredAccess,
- &ctx->attr,
- &ctx->iosb,
- AllocationSize,
- FileAttributes,
- FILE_SHARE_VALID_FLAGS,
- CreateDisposition,
- CreateOptions |
- FILE_OPEN_FOR_BACKUP_INTENT |
- FILE_OPEN_REPARSE_POINT,
- NULL,
- 0);
+ return NtCreateFile(FileHandle,
+ DesiredAccess | SYNCHRONIZE,
+ &ctx->attr,
+ &ctx->iosb,
+ AllocationSize,
+ FileAttributes,
+ FILE_SHARE_VALID_FLAGS,
+ CreateDisposition,
+ CreateOptions |
+ FILE_OPEN_FOR_BACKUP_INTENT |
+ FILE_OPEN_REPARSE_POINT,
+ NULL,
+ 0);
}
/* Like do_create_file(), but builds the extraction path of the @dentry first.
{
NTSTATUS status;
HANDLE h;
- FILE_DISPOSITION_INFORMATION disposition_info;
- FILE_BASIC_INFORMATION basic_info;
- bool retried = false;
+ ULONG perms = DELETE;
+ ULONG flags = FILE_NON_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE;
+
+ /* First try opening the file with FILE_DELETE_ON_CLOSE. In most cases,
+ * all we have to do is that plus close the file handle. */
+retry:
+ status = do_create_file(&h, perms, NULL, 0, FILE_OPEN, flags, ctx);
+
+ if (unlikely(status == STATUS_CANNOT_DELETE)) {
+ /* This error occurs for files with FILE_ATTRIBUTE_READONLY set.
+ * Try an alternate approach: first open the file without
+ * FILE_DELETE_ON_CLOSE, then reset the file attributes, then
+ * set the "delete" disposition on the handle. */
+ if (flags & FILE_DELETE_ON_CLOSE) {
+ flags &= ~FILE_DELETE_ON_CLOSE;
+ perms |= FILE_WRITE_ATTRIBUTES;
+ goto retry;
+ }
+ }
- 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));
+ winnt_error(status, L"Can't open \"%ls\" for deletion "
+ "(perms=%x, flags=%x)",
+ current_path(ctx), perms, flags);
return WIMLIB_ERR_OPEN;
}
-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;
+ if (unlikely(!(flags & FILE_DELETE_ON_CLOSE))) {
+
+ FILE_BASIC_INFORMATION basic_info =
+ { .FileAttributes = FILE_ATTRIBUTE_NORMAL };
+ status = NtSetInformationFile(h, &ctx->iosb, &basic_info,
+ sizeof(basic_info),
+ FileBasicInformation);
- 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)) {
- winnt_error(status,
- L"Can't open \"%ls\" to reset attributes",
- current_path(ctx));
- return WIMLIB_ERR_OPEN;
+ winnt_error(status, L"Can't reset attributes of \"%ls\" "
+ "to prepare for deletion", current_path(ctx));
+ NtClose(h);
+ return WIMLIB_ERR_SET_ATTRIBUTES;
}
- 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);
+
+ FILE_DISPOSITION_INFORMATION disp_info =
+ { .DoDeleteFile = TRUE };
+ status = NtSetInformationFile(h, &ctx->iosb, &disp_info,
+ sizeof(disp_info),
+ FileDispositionInformation);
if (!NT_SUCCESS(status)) {
- winnt_error(status,
- L"Can't reset file attributes on \"%ls\"",
- current_path(ctx));
- (*func_NtClose)(h);
+ winnt_error(status, L"Can't set delete-on-close "
+ "disposition on \"%ls\"", current_path(ctx));
+ NtClose(h);
return WIMLIB_ERR_SET_ATTRIBUTES;
}
- retried = true;
- goto retry;
}
- winnt_error(status, L"Can't delete \"%ls\"", current_path(ctx));
- return WIMLIB_ERR_OPEN;
+
+ status = NtClose(h);
+ if (unlikely(!NT_SUCCESS(status))) {
+ winnt_error(status, L"Error closing \"%ls\" after setting "
+ "delete-on-close disposition", current_path(ctx));
+ return WIMLIB_ERR_OPEN;
+ }
+
+ return 0;
}
/*
* 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.
+ * open handle to the file or named data stream with the requested permissions.
*/
static int
-supersede_file_or_stream(struct win32_apply_ctx *ctx, HANDLE *h_ret)
+supersede_file_or_stream(struct win32_apply_ctx *ctx, DWORD perms,
+ HANDLE *h_ret)
{
NTSTATUS status;
bool retried = false;
* 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,
+ perms,
NULL,
FILE_ATTRIBUTE_SYSTEM,
FILE_CREATE,
return WIMLIB_ERR_OPEN;
}
+/* 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;
+
+ status = create_file(&h, GENERIC_WRITE, NULL,
+ 0, FILE_OPEN, 0, dentry, ctx);
+ if (!NT_SUCCESS(status))
+ goto fail;
+
+ status = winnt_fsctl(h, FSCTL_SET_REPARSE_POINT,
+ rpbuf, rpbuflen, NULL, 0, NULL);
+ 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 for the specified file, if there are any.
+ * 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_named_data_streams(const struct wim_dentry *dentry,
- struct win32_apply_ctx *ctx)
+create_empty_streams(const struct wim_dentry *dentry,
+ struct win32_apply_ctx *ctx)
{
const struct wim_inode *inode = dentry->d_inode;
- bool path_modified = false;
- int ret = 0;
-
- if (!ctx->common.supported_features.named_data_streams)
- return 0;
+ int ret;
for (unsigned i = 0; i < inode->i_num_streams; i++) {
const struct wim_inode_stream *strm = &inode->i_streams[i];
- HANDLE h;
- if (!stream_is_named_data_stream(strm) ||
- stream_blob_resolved(strm) != NULL)
+ if (stream_blob_resolved(strm) != NULL)
continue;
- build_extraction_path_with_ads(dentry, ctx,
- strm->stream_name,
- utf16le_len_chars(strm->stream_name));
- path_modified = true;
- ret = supersede_file_or_stream(ctx, &h);
- if (ret)
- break;
- (*func_NtClose)(h);
+ 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));
+ /*
+ * Note: do not request any permissions on the handle.
+ * Otherwise, we may encounter a Windows bug where the
+ * parent directory DACL denies read access to the new
+ * named data stream, even when using backup semantics!
+ */
+ ret = supersede_file_or_stream(ctx, 0, &h);
+
+ build_extraction_path(dentry, ctx);
+
+ if (ret)
+ return ret;
+ NtClose(h);
+ }
}
- /* Restore the path to the dentry itself */
- if (path_modified)
- build_extraction_path(dentry, ctx);
- return ret;
+
+ return 0;
}
/*
* 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));
+ if (unlikely(!NT_SUCCESS(status))) {
+ const wchar_t *path = current_path(ctx);
+ winnt_error(status, L"Can't create directory \"%ls\"", path);
+
+ /* Check for known issue with WindowsApps directory. */
+ if (status == STATUS_ACCESS_DENIED &&
+ (wcsstr(path, L"\\WindowsApps\\") ||
+ wcsstr(path, L"\\InfusedApps\\"))) {
+ ERROR(
+"You seem to be trying to extract files to the WindowsApps directory.\n"
+" Windows 8.1 and later use new file permissions in this directory that\n"
+" cannot be overridden, even by backup/restore programs. To extract your\n"
+" files anyway, you need to choose a different target directory, delete\n"
+" the WindowsApps directory entirely, reformat the volume, do the\n"
+" extraction from a non-broken operating system such as Windows 7 or\n"
+" Linux, or wait for Microsoft to fix the design flaw in their operating\n"
+" system. This is *not* a bug in wimlib. See this thread for more\n"
+" information: https://wimlib.net/forums/viewtopic.php?f=1&t=261");
+ }
return WIMLIB_ERR_MKDIR;
}
* 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 (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES)) {
+ FILE_BASIC_INFORMATION basic_info =
+ { .FileAttributes = FILE_ATTRIBUTE_NORMAL };
+ NtSetInformationFile(h, &ctx->iosb, &basic_info,
+ sizeof(basic_info),
+ FileBasicInformation);
+ }
}
if (!dentry_is_root(dentry)) {
ret = adjust_compression_attribute(h, dentry, ctx);
out:
- (*func_NtClose)(h);
+ NtClose(h);
return ret;
}
ret = create_directory(dentry, ctx);
if (!ret)
- ret = create_empty_named_data_streams(dentry, ctx);
+ ret = create_empty_streams(dentry, ctx);
ret = check_apply_error(dentry, ctx, ret);
if (ret)
build_extraction_path(dentry, ctx);
- ret = supersede_file_or_stream(ctx, &h);
+ ret = supersede_file_or_stream(ctx,
+ GENERIC_READ | GENERIC_WRITE | DELETE,
+ &h);
if (ret)
goto out;
if (ret)
goto out_close;
- ret = create_empty_named_data_streams(dentry, ctx);
+ if (need_sparse_flag(dentry->d_inode, ctx)) {
+ ret = set_sparse_flag(h, ctx);
+ if (ret)
+ goto out_close;
+ }
+
+ ret = create_empty_streams(dentry, ctx);
if (ret)
goto out_close;
return 0;
out_close:
- (*func_NtClose)(h);
+ NtClose(h);
out:
return ret;
}
* STATUS_INFO_LENGTH_MISMATCH when FileNameLength
* happens to be 2 */
- status = (*func_NtSetInformationFile)(h, &ctx->iosb,
- info, bufsize,
- FileLinkInformation);
+ status = NtSetInformationFile(h, &ctx->iosb, info, bufsize,
+ FileLinkInformation);
if (NT_SUCCESS(status))
return 0;
winnt_error(status, L"Failed to create link \"%ls\"",
if (ret)
return ret;
- (*func_NtClose)(h2);
+ NtClose(h2);
return 0;
}
}
/* "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);
+ NtClose(h);
return ret;
}
close_handles(struct win32_apply_ctx *ctx)
{
for (unsigned i = 0; i < ctx->num_open_handles; i++)
- (*func_NtClose)(ctx->open_handles[i]);
+ NtClose(ctx->open_handles[i]);
}
/* Prepare to read the next blob, which has size @blob_size, into an in-memory
const struct wim_inode_stream *strm,
struct win32_apply_ctx *ctx)
{
- FILE_ALLOCATION_INFORMATION alloc_info;
HANDLE h;
NTSTATUS status;
* data be available. So, stage the data in a buffer. */
if (!prepare_data_buffer(ctx, blob->size))
return WIMLIB_ERR_NOMEM;
- list_add_tail(&dentry->tmp_list, &ctx->reparse_dentries);
+ list_add_tail(&dentry->d_tmp_list, &ctx->reparse_dentries);
return 0;
}
* such files... */
if (!prepare_data_buffer(ctx, blob->size))
return WIMLIB_ERR_NOMEM;
- list_add_tail(&dentry->tmp_list, &ctx->encrypted_dentries);
+ list_add_tail(&dentry->d_tmp_list, &ctx->encrypted_dentries);
return 0;
}
return WIMLIB_ERR_OPEN;
}
- ctx->open_handles[ctx->num_open_handles++] = h;
-
- /* Allocate space for the data. */
- alloc_info.AllocationSize.QuadPart = blob->size;
- (*func_NtSetInformationFile)(h, &ctx->iosb,
- &alloc_info, sizeof(alloc_info),
+ ctx->is_sparse_stream[ctx->num_open_handles] = false;
+ if (need_sparse_flag(dentry->d_inode, ctx)) {
+ /* If the stream is unnamed, then the sparse flag was already
+ * set when the file was created. But if the stream is named,
+ * then we need to set the sparse flag here. */
+ if (unlikely(stream_is_named(strm))) {
+ int ret = set_sparse_flag(h, ctx);
+ if (ret) {
+ NtClose(h);
+ return ret;
+ }
+ }
+ ctx->is_sparse_stream[ctx->num_open_handles] = true;
+ ctx->any_sparse_streams = true;
+ } else {
+ /* Allocate space for the data. */
+ FILE_ALLOCATION_INFORMATION info =
+ { .AllocationSize = { .QuadPart = blob->size }};
+ NtSetInformationFile(h, &ctx->iosb, &info, sizeof(info),
FileAllocationInformation);
- return 0;
-}
-
-/* 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;
-
- 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:
- winnt_error(status, L"Can't set reparse data on \"%ls\"",
- current_path(ctx));
- return WIMLIB_ERR_SET_REPARSE_DATA;
+ ctx->open_handles[ctx->num_open_handles++] = h;
+ return 0;
}
/* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
target_ntpath_nchars = ctx->target_ntpath.Length / sizeof(wchar_t);
+ /* If the target directory is a filesystem root, such as \??\C:\, then
+ * it already will have a trailing slash. Don't include this slash if
+ * we are already adding slashes via 'relpath'. This prevents an extra
+ * slash from being generated each time the link is extracted. And
+ * unlike on UNIX, the number of slashes in paths on Windows can be
+ * significant; Windows won't understand the link target if it contains
+ * too many slashes. */
+ if (target_ntpath_nchars > 0 && relpath_nchars > 0 &&
+ ctx->target_ntpath.Buffer[target_ntpath_nchars - 1] == L'\\')
+ target_ntpath_nchars--;
+
+ /* Also remove extra slashes from the beginning of 'relpath'. Normally
+ * this isn't needed, but this is here to make the extra slash(es) added
+ * by wimlib pre-v1.9.1 get removed automatically. */
+ while (relpath_nchars >= 2 &&
+ relpath[0] == L'\\' && relpath[1] == L'\\') {
+ relpath++;
+ relpath_nchars--;
+ }
+
fixed_subst_name_nchars = target_ntpath_nchars + relpath_nchars;
wchar_t fixed_subst_name[fixed_subst_name_nchars];
return 0;
}
-/* Called when starting to read a blob for extraction on Windows */
+/* Called when starting to read a blob for extraction */
static int
-begin_extract_blob(struct blob_descriptor *blob, void *_ctx)
+win32_begin_extract_blob(struct blob_descriptor *blob, void *_ctx)
{
struct win32_apply_ctx *ctx = _ctx;
const struct blob_extraction_target *targets = blob_extraction_targets(blob);
ctx->num_open_handles = 0;
ctx->data_buffer_ptr = NULL;
+ ctx->any_sparse_streams = false;
INIT_LIST_HEAD(&ctx->reparse_dentries);
INIT_LIST_HEAD(&ctx->encrypted_dentries);
return ret;
}
-/* 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)
+pwrite_to_handle(HANDLE h, const void *data, size_t size, u64 offset)
+{
+ const void * const end = data + size;
+ const void *p;
+ IO_STATUS_BLOCK iosb;
+ NTSTATUS status;
+
+ for (p = data; p != end; p += iosb.Information,
+ offset += iosb.Information)
+ {
+ LARGE_INTEGER offs = { .QuadPart = offset };
+
+ status = NtWriteFile(h, NULL, NULL, NULL, &iosb,
+ (void *)p, min(INT32_MAX, end - p),
+ &offs, NULL);
+ if (!NT_SUCCESS(status)) {
+ winnt_error(status,
+ L"Error writing data to target volume");
+ return WIMLIB_ERR_WRITE;
+ }
+ }
+ return 0;
+}
+
+/* Called when the next chunk of a blob has been read for extraction */
+static int
+win32_extract_chunk(const struct blob_descriptor *blob, u64 offset,
+ const void *chunk, size_t size, void *_ctx)
{
struct win32_apply_ctx *ctx = _ctx;
+ const void * const end = chunk + size;
+ const void *p;
+ bool zeroes;
+ size_t len;
+ unsigned i;
+ int ret;
- /* Write the data chunk to each open handle */
- for (unsigned i = 0; i < ctx->num_open_handles; i++) {
- u8 *bufptr = (u8 *)chunk;
- size_t bytes_remaining = size;
- NTSTATUS status;
- while (bytes_remaining) {
- ULONG count = min(0xFFFFFFFF, bytes_remaining);
-
- status = (*func_NtWriteFile)(ctx->open_handles[i],
- NULL, NULL, NULL,
- &ctx->iosb, bufptr, count,
- NULL, NULL);
- if (!NT_SUCCESS(status)) {
- winnt_error(status, L"Error writing data to target volume");
- return WIMLIB_ERR_WRITE;
+ /*
+ * For sparse streams, only write nonzero regions. This lets the
+ * filesystem use holes to represent zero regions.
+ */
+ for (p = chunk; p != end; p += len, offset += len) {
+ zeroes = maybe_detect_sparse_region(p, end - p, &len,
+ ctx->any_sparse_streams);
+ for (i = 0; i < ctx->num_open_handles; i++) {
+ if (!zeroes || !ctx->is_sparse_stream[i]) {
+ ret = pwrite_to_handle(ctx->open_handles[i],
+ p, len, offset);
+ if (ret)
+ return ret;
}
- bufptr += ctx->iosb.Information;
- bytes_remaining -= ctx->iosb.Information;
}
}
return 0;
}
-/* 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)
+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 const wchar_t *
+get_system_compression_format_string(int format)
+{
+ switch (format) {
+ case FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS4K:
+ return L"XPRESS4K";
+ case FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS8K:
+ return L"XPRESS8K";
+ case FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS16K:
+ return L"XPRESS16K";
+ default:
+ return L"LZX";
+ }
+}
+
+static NTSTATUS
+set_system_compression(HANDLE h, int format)
+{
+ NTSTATUS status;
+ 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,
+ },
+ };
+
+ /* We intentionally use NtFsControlFile() rather than DeviceIoControl()
+ * here because the "compressing this object would not save space"
+ * status code does not map to a valid Win32 error code on older
+ * versions of Windows (before Windows 10?). This can be a problem if
+ * the WOFADK driver is being used rather than the regular WOF, since
+ * WOFADK can be used on older versions of Windows. */
+ status = winnt_fsctl(h, FSCTL_SET_EXTERNAL_BACKING,
+ &in, sizeof(in), NULL, 0, NULL);
+
+ if (status == 0xC000046F) /* "Compressing this object would not save space." */
+ return STATUS_SUCCESS;
+
+ return status;
+}
+
+/* Hard-coded list of files which the Windows bootloader may need to access
+ * before the WOF driver has been loaded. */
+static const wchar_t * const bootloader_pattern_strings[] = {
+ L"*winload.*",
+ L"*winresume.*",
+ L"\\Windows\\AppPatch\\drvmain.sdb",
+ L"\\Windows\\Boot\\DVD\\*",
+ L"\\Windows\\Boot\\EFI\\*",
+ L"\\Windows\\bootstat.dat",
+ L"\\Windows\\Fonts\\vgaoem.fon",
+ L"\\Windows\\Fonts\\vgasys.fon",
+ L"\\Windows\\INF\\errata.inf",
+ L"\\Windows\\System32\\config\\*",
+ L"\\Windows\\System32\\ntkrnlpa.exe",
+ L"\\Windows\\System32\\ntoskrnl.exe",
+ L"\\Windows\\System32\\bootvid.dll",
+ L"\\Windows\\System32\\ci.dll",
+ L"\\Windows\\System32\\hal*.dll",
+ L"\\Windows\\System32\\mcupdate_AuthenticAMD.dll",
+ L"\\Windows\\System32\\mcupdate_GenuineIntel.dll",
+ L"\\Windows\\System32\\pshed.dll",
+ L"\\Windows\\System32\\apisetschema.dll",
+ L"\\Windows\\System32\\api-ms-win*.dll",
+ L"\\Windows\\System32\\ext-ms-win*.dll",
+ L"\\Windows\\System32\\KernelBase.dll",
+ L"\\Windows\\System32\\drivers\\*.sys",
+ L"\\Windows\\System32\\*.nls",
+ L"\\Windows\\System32\\kbd*.dll",
+ L"\\Windows\\System32\\kd*.dll",
+ L"\\Windows\\System32\\clfs.sys",
+ L"\\Windows\\System32\\CodeIntegrity\\driver.stl",
+};
+
+static const struct string_list bootloader_patterns = {
+ .strings = (wchar_t **)bootloader_pattern_strings,
+ .num_strings = ARRAY_LEN(bootloader_pattern_strings),
+};
+
+static NTSTATUS
+set_system_compression_on_inode(struct wim_inode *inode, int format,
+ struct win32_apply_ctx *ctx)
+{
+ bool retried = false;
+ NTSTATUS status;
+ HANDLE h;
+
+ /* If it may be needed for compatibility with the Windows bootloader,
+ * force this file to XPRESS4K or uncompressed format. The bootloader
+ * of Windows 10 supports XPRESS4K only; older versions don't support
+ * system compression at all. */
+ if (!is_image_windows_10_or_later(ctx) ||
+ format != FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS4K)
+ {
+ /* We need to check the patterns against every name of the
+ * inode, in case any of them match. */
+ struct wim_dentry *dentry;
+ inode_for_each_extraction_alias(dentry, inode) {
+ bool incompatible;
+ bool warned;
+
+ if (calculate_dentry_full_path(dentry)) {
+ ERROR("Unable to compute file path!");
+ return STATUS_NO_MEMORY;
+ }
+
+ incompatible = match_pattern_list(dentry->d_full_path,
+ &bootloader_patterns);
+ FREE(dentry->d_full_path);
+ dentry->d_full_path = NULL;
+
+ if (!incompatible)
+ continue;
+
+ warned = (ctx->num_system_compression_exclusions++ > 0);
+
+ if (is_image_windows_10_or_later(ctx)) {
+ /* Force to XPRESS4K */
+ if (!warned) {
+ WARNING("For compatibility with the "
+ "Windows bootloader, some "
+ "files are being\n"
+ " compacted "
+ "using the XPRESS4K format "
+ "instead of the %"TS" format\n"
+ " you requested.",
+ get_system_compression_format_string(format));
+ }
+ format = FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS4K;
+ break;
+ } else {
+ /* Force to uncompressed */
+ if (!warned) {
+ WARNING("For compatibility with the "
+ "Windows bootloader, some "
+ "files will not\n"
+ " be compressed with"
+ " system compression "
+ "(\"compacted\").");
+ }
+ return STATUS_SUCCESS;
+ }
+
+ }
+ }
+
+ /* Open the extracted file. */
+ status = create_file(&h, GENERIC_READ | GENERIC_WRITE, NULL,
+ 0, FILE_OPEN, 0,
+ inode_first_extraction_dentry(inode), ctx);
+
+ if (!NT_SUCCESS(status))
+ return status;
+retry:
+ /* Compress the file. If the attempt fails with "invalid device
+ * request", then attach wof.sys (or wofadk.sys) and retry. */
+ status = set_system_compression(h, format);
+ if (unlikely(status == STATUS_INVALID_DEVICE_REQUEST && !retried)) {
+ wchar_t drive_path[7];
+ if (!win32_get_drive_path(ctx->common.target, drive_path) &&
+ win32_try_to_attach_wof(drive_path + 4)) {
+ retried = true;
+ goto retry;
+ }
+ }
+
+ NtClose(h);
+ return status;
+}
+
+/*
+ * 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;
+ NTSTATUS status;
+
+ if (!stream_is_unnamed_data_stream(strm))
+ continue;
+
+ if (will_externally_back_inode(inode, ctx, NULL, false) != 0)
+ continue;
+
+ status = set_system_compression_on_inode(inode, format, ctx);
+ if (likely(NT_SUCCESS(status)))
+ continue;
+
+ if (status == STATUS_INVALID_DEVICE_REQUEST) {
+ 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;
+ }
+
+ ctx->num_system_compression_failures++;
+ if (ctx->num_system_compression_failures < 10) {
+ winnt_warning(status, 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 */
+static int
+win32_end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx)
{
struct win32_apply_ctx *ctx = _ctx;
int ret;
const struct wim_dentry *dentry;
+ /* Extend sparse streams to their final size. */
+ if (ctx->any_sparse_streams && !status) {
+ for (unsigned i = 0; i < ctx->num_open_handles; i++) {
+ FILE_END_OF_FILE_INFORMATION info =
+ { .EndOfFile = { .QuadPart = blob->size } };
+ NTSTATUS ntstatus;
+
+ if (!ctx->is_sparse_stream[i])
+ continue;
+
+ ntstatus = NtSetInformationFile(ctx->open_handles[i],
+ &ctx->iosb,
+ &info, sizeof(info),
+ FileEndOfFileInformation);
+ if (!NT_SUCCESS(ntstatus)) {
+ winnt_error(ntstatus, L"Error writing data to "
+ "target volume (while extending)");
+ status = WIMLIB_ERR_WRITE;
+ break;
+ }
+ }
+ }
+
close_handles(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 (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)",
/* Reparse data */
memcpy(ctx->rpbuf.rpdata, ctx->data_buffer, blob->size);
- list_for_each_entry(dentry, &ctx->reparse_dentries, tmp_list) {
+ list_for_each_entry(dentry, &ctx->reparse_dentries, d_tmp_list) {
/* Reparse point header */
complete_reparse_point(&ctx->rpbuf, dentry->d_inode,
if (!list_empty(&ctx->encrypted_dentries)) {
ctx->encrypted_size = blob->size;
- list_for_each_entry(dentry, &ctx->encrypted_dentries, tmp_list) {
+ 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)
FILE_ATTRIBUTE_SPARSE_FILE | \
FILE_ATTRIBUTE_COMPRESSED)
+static void
+set_object_id(HANDLE h, const struct wim_inode *inode,
+ struct win32_apply_ctx *ctx)
+{
+ const void *object_id;
+ u32 len;
+ NTSTATUS status;
+
+ if (!ctx->common.supported_features.object_ids)
+ return;
+
+ object_id = inode_get_object_id(inode, &len);
+ if (likely(object_id == NULL)) /* No object ID? */
+ return;
+
+ status = winnt_fsctl(h, FSCTL_SET_OBJECT_ID,
+ object_id, len, NULL, 0, NULL);
+ if (NT_SUCCESS(status))
+ return;
+
+ /* Object IDs must be unique within the filesystem. A duplicate might
+ * occur if an image containing object IDs is applied twice to the same
+ * filesystem. Arguably, the user should be warned in this case; but
+ * the reality seems to be that nothing important cares about object IDs
+ * except the Distributed Link Tracking Service... so for now these
+ * failures are just ignored. */
+ if (status == STATUS_DUPLICATE_NAME ||
+ status == STATUS_OBJECT_NAME_COLLISION)
+ return;
+
+ ctx->num_object_id_failures++;
+ if (ctx->num_object_id_failures < 10) {
+ winnt_warning(status, L"Can't set object ID on \"%ls\"",
+ current_path(ctx));
+ } else if (ctx->num_object_id_failures == 10) {
+ WARNING("Suppressing further warnings about failure to set "
+ "object IDs.");
+ }
+}
+
/* Set the security descriptor @desc, of @desc_size bytes, on the file with open
* handle @h. */
static NTSTATUS
*/
retry:
- status = (*func_NtSetSecurityObject)(h, info, desc);
+ status = NtSetSecurityObject(h, info, desc);
if (NT_SUCCESS(status))
goto out_maybe_free_desc;
FILE_BASIC_INFORMATION info;
NTSTATUS status;
- /* Set security descriptor if present and not in NO_ACLS mode */
+ /* Set the file's object ID if present and object IDs are supported by
+ * the filesystem. */
+ set_object_id(h, inode, ctx);
+
+ /* Set the file's security descriptor if present and we're not in
+ * NO_ACLS mode */
if (inode_has_security_descriptor(inode) &&
!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS))
{
info.FileAttributes = FILE_ATTRIBUTE_NORMAL;
}
- status = (*func_NtSetInformationFile)(h, &ctx->iosb,
- &info, sizeof(info),
- FileBasicInformation);
+ status = NtSetInformationFile(h, &ctx->iosb, &info, sizeof(info),
+ FileBasicInformation);
/* On FAT volumes we get STATUS_INVALID_PARAMETER if we try to set
* attributes on the root directory. (Apparently because FAT doesn't
* actually have a place to store those attributes!) */
ret = do_apply_metadata_to_file(h, inode, ctx);
- (*func_NtClose)(h);
+ NtClose(h);
return ret;
}
goto out;
}
+ ctx->windows_build_number = xml_get_windows_build_number(ctx->common.wim->xml_info,
+ ctx->common.wim->current_image);
+
dentry_count = count_dentries(dentry_list);
ret = start_file_structure_phase(&ctx->common, dentry_count);
goto out;
struct read_blob_callbacks cbs = {
- .begin_blob = begin_extract_blob,
- .consume_chunk = extract_chunk,
- .end_blob = end_extract_blob,
+ .begin_blob = win32_begin_extract_blob,
+ .continue_blob = win32_extract_chunk,
+ .end_blob = win32_end_extract_blob,
.ctx = ctx,
};
ret = extract_blob_list(&ctx->common, &cbs);
FREE(ctx->pathbuf.Buffer);
FREE(ctx->print_buffer);
FREE(ctx->wimboot.wims);
- if (ctx->wimboot.prepopulate_pats) {
- FREE(ctx->wimboot.prepopulate_pats->strings);
- FREE(ctx->wimboot.prepopulate_pats);
+ 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;
}
.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),
};