*/
/*
- * Copyright (C) 2013 Eric Biggers
+ * Copyright (C) 2013, 2014 Eric Biggers
*
* This file is part of wimlib, a library for working with WIM files.
*
#include "wimlib/win32_common.h"
#include "wimlib/apply.h"
-#include "wimlib/capture.h"
+#include "wimlib/capture.h" /* for mangle_pat() */
#include "wimlib/dentry.h"
#include "wimlib/error.h"
#include "wimlib/lookup_table.h"
-#include "wimlib/paths.h"
+#include "wimlib/resource.h"
#include "wimlib/textfile.h"
#include "wimlib/xml.h"
+#include "wimlib/wildcard.h"
#include "wimlib/wim.h"
#include "wimlib/wimboot.h"
-static void
-ctx_save_data_source_id(struct apply_ctx *ctx, u64 data_source_id)
-{
- ctx->private[0] = data_source_id & 0xFFFFFFFF;
- ctx->private[1] = data_source_id >> 32;
-}
-
-static u64
-ctx_get_data_source_id(const struct apply_ctx *ctx)
-{
- return (u32)ctx->private[0] | ((u64)(u32)ctx->private[1] << 32);
-}
-
-static void
-set_prepopulate_pats(struct apply_ctx *ctx, struct string_set *s)
-{
- ctx->private[2] = (intptr_t)s;
-}
-
-static struct string_set *
-alloc_prepopulate_pats(struct apply_ctx *ctx)
-{
- struct string_set *s = CALLOC(1, sizeof(*s));
- set_prepopulate_pats(ctx, s);
- return s;
-}
+struct win32_apply_private_data {
+ u64 data_source_id;
+ struct string_set *prepopulate_pats;
+ void *mem_prepopulate_pats;
+ u8 wim_lookup_table_hash[SHA1_HASH_SIZE];
+ bool wof_running;
+};
-static struct string_set *
-get_prepopulate_pats(struct apply_ctx *ctx)
+static struct win32_apply_private_data *
+get_private_data(struct apply_ctx *ctx)
{
- return (struct string_set *)(ctx->private[2]);
+ BUILD_BUG_ON(sizeof(ctx->private) < sizeof(struct win32_apply_private_data));
+ return (struct win32_apply_private_data *)(ctx->private);
}
static void
-free_prepopulate_pats(struct apply_ctx *ctx)
+free_prepopulate_pats(struct win32_apply_private_data *dat)
{
- struct string_set *s;
-
- s = get_prepopulate_pats(ctx);
- if (s) {
- FREE(s->strings);
- FREE(s);
+ if (dat->prepopulate_pats) {
+ FREE(dat->prepopulate_pats->strings);
+ FREE(dat->prepopulate_pats);
+ dat->prepopulate_pats = NULL;
}
- set_prepopulate_pats(ctx, NULL);
- FREE((void *)ctx->private[3]);
- ctx->private[3] = (intptr_t)NULL;
+ if (dat->mem_prepopulate_pats) {
+ FREE(dat->mem_prepopulate_pats);
+ dat->mem_prepopulate_pats = NULL;
+ }
}
static int
void *buf;
void *mem;
struct text_file_section sec;
+ struct win32_apply_private_data *dat = get_private_data(ctx);
dentry = get_dentry(ctx->wim, path, WIMLIB_CASE_INSENSITIVE);
if (!dentry ||
if (ret)
return ret;
- s = alloc_prepopulate_pats(ctx);
+ s = CALLOC(1, sizeof(struct string_set));
if (!s) {
FREE(buf);
return WIMLIB_ERR_NOMEM;
LOAD_TEXT_FILE_REMOVE_QUOTES |
LOAD_TEXT_FILE_NO_WARNINGS,
mangle_pat);
+ BUILD_BUG_ON(OS_PREFERRED_PATH_SEPARATOR != WIM_PATH_SEPARATOR);
FREE(buf);
if (ret) {
- free_prepopulate_pats(ctx);
+ FREE(s);
return ret;
}
- ctx->private[3] = (intptr_t)mem;
+ dat->prepopulate_pats = s;
+ dat->mem_prepopulate_pats = mem;
return 0;
}
static bool
-in_prepopulate_list(struct wim_dentry *dentry,
- struct apply_ctx *ctx)
+in_prepopulate_list(struct wim_dentry *dentry, struct apply_ctx *ctx)
{
struct string_set *pats;
const tchar *path;
+ size_t path_nchars;
- pats = get_prepopulate_pats(ctx);
- if (!pats)
+ pats = get_private_data(ctx)->prepopulate_pats;
+ if (!pats || !pats->num_strings)
return false;
+
path = dentry_full_path(dentry);
if (!path)
return false;
- return match_pattern(path, path_basename(path), pats);
+ path_nchars = tstrlen(path);
+
+ for (size_t i = 0; i < pats->num_strings; i++)
+ if (match_path(path, path_nchars, pats->strings[i],
+ OS_PREFERRED_PATH_SEPARATOR, true))
+ return true;
+
+ return false;
+}
+
+static int
+hash_lookup_table(WIMStruct *wim, u8 hash[SHA1_HASH_SIZE])
+{
+ return wim_reshdr_to_hash(&wim->hdr.lookup_table_reshdr, wim, hash);
}
static int
int ret;
unsigned vol_flags;
bool supports_SetFileShortName;
+ struct win32_apply_private_data *dat = get_private_data(ctx);
ret = win32_get_vol_flags(path, &vol_flags, &supports_SetFileShortName);
if (ret)
- return ret;
+ goto err;
ctx->supported_features.archive_files = 1;
ctx->supported_features.hidden_files = 1;
ret = load_prepopulate_pats(ctx);
if (ret == WIMLIB_ERR_NOMEM)
- return ret;
-
- u64 data_source_id;
+ goto err;
if (!wim_info_get_wimboot(ctx->wim->wim_info,
ctx->wim->current_image))
WARNING("Image is not marked as WIMBoot compatible!");
+
+ ret = hash_lookup_table(ctx->wim, dat->wim_lookup_table_hash);
+ if (ret)
+ goto err;
+
ret = wimboot_alloc_data_source_id(ctx->wim->filename,
+ ctx->wim->hdr.guid,
ctx->wim->current_image,
- path, &data_source_id);
- if (ret) {
- free_prepopulate_pats(ctx);
- return ret;
- }
-
- ctx_save_data_source_id(ctx, data_source_id);
+ path,
+ &dat->data_source_id,
+ &dat->wof_running);
+ if (ret)
+ goto err;
}
return 0;
+
+err:
+ free_prepopulate_pats(dat);
+ return ret;
}
static int
win32_finish_extract(struct apply_ctx *ctx)
{
- free_prepopulate_pats(ctx);
+ free_prepopulate_pats(get_private_data(ctx));
return 0;
}
creationDisposition, FILE_FLAG_BACKUP_SEMANTICS |
FILE_FLAG_OPEN_REPARSE_POINT,
NULL);
- if (h == INVALID_HANDLE_VALUE)
- goto error;
+ if (h == INVALID_HANDLE_VALUE) {
+ set_errno_from_GetLastError();
+ ret = WIMLIB_ERR_OPEN;
+ goto out;
+ }
- ret = 0;
- if (!lte)
+ if (!lte) {
+ ret = 0;
goto out_close_handle;
+ }
+
+ if (!SetFilePointerEx(h,
+ (LARGE_INTEGER) { .QuadPart = lte->size},
+ NULL,
+ FILE_BEGIN))
+ goto write_error;
+
+ if (!SetEndOfFile(h))
+ goto write_error;
+
+ if (!SetFilePointerEx(h,
+ (LARGE_INTEGER) { .QuadPart = 0},
+ NULL,
+ FILE_BEGIN))
+ goto write_error;
+
ret = extract_stream(lte, lte->size, win32_extract_wim_chunk, h);
-out_close_handle:
- if (!CloseHandle(h))
- goto error;
- if (ret && !errno)
- errno = -1;
- return ret;
+ goto out_close_handle;
-error:
+write_error:
set_errno_from_GetLastError();
- return WIMLIB_ERR_WRITE;
+ ret = WIMLIB_ERR_WRITE;
+
+out_close_handle:
+ if (!CloseHandle(h)) {
+ if (!ret) {
+ set_errno_from_GetLastError();
+ ret = WIMLIB_ERR_WRITE;
+ }
+ }
+out:
+ return ret;
}
static int
&& lte
&& lte->resource_location == RESOURCE_IN_WIM
&& lte->rspec->wim == ctx->wim
- && !in_prepopulate_list(dentry, ctx))
+ && lte->size == lte->rspec->uncompressed_size)
{
- return wimboot_set_pointer(file.path,
- ctx_get_data_source_id(ctx),
- lte->hash);
+ if (in_prepopulate_list(dentry, ctx)) {
+ if (ctx->progress_func) {
+ union wimlib_progress_info info;
+
+ info.wimboot_exclude.path_in_wim = dentry->_full_path;
+ info.wimboot_exclude.extraction_path = file.path;
+
+ ctx->progress_func(WIMLIB_PROGRESS_MSG_WIMBOOT_EXCLUDE,
+ &info);
+ }
+ } else {
+ const struct win32_apply_private_data *dat;
+
+ dat = get_private_data(ctx);
+ return wimboot_set_pointer(file.path, lte,
+ dat->data_source_id,
+ dat->wim_lookup_table_hash,
+ dat->wof_running);
+ }
}
return win32_extract_stream(file.path, NULL, 0, lte, ctx);
return WIMLIB_ERR_WRITE; /* XXX: need better error code */
}
-static DWORD
-do_win32_set_security_descriptor(HANDLE h, const wchar_t *path,
- SECURITY_INFORMATION info,
- PSECURITY_DESCRIPTOR desc)
-{
-#ifdef WITH_NTDLL
- if (func_NtSetSecurityObject) {
- return (*func_RtlNtStatusToDosError)(
- (*func_NtSetSecurityObject)(h, info, desc));
- }
-#endif
- if (SetFileSecurity(path, info, desc))
- return ERROR_SUCCESS;
- else
- return GetLastError();
-}
-
/*
* Set an arbitrary security descriptor on an arbitrary file (or directory),
* working around bugs and design flaws in the Windows operating system.
size_t desc_size, struct apply_ctx *ctx)
{
SECURITY_INFORMATION info;
+ DWORD dwDesiredAccess;
HANDLE h;
+ DWORD status;
int ret;
/* We really just want to set entire the security descriptor as-is, but
info = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
- h = INVALID_HANDLE_VALUE;
-
/* Prefer NtSetSecurityObject() to SetFileSecurity(). SetFileSecurity()
* itself necessarily uses NtSetSecurityObject() as the latter is the
* underlying system call for setting security information, but
* Administrator can have access denied. (Of course, this not mentioned
* in the MS "documentation".) */
-#ifdef WITH_NTDLL
- if (func_NtSetSecurityObject) {
- DWORD dwDesiredAccess;
-
- /* Open a handle for NtSetSecurityObject() with as many relevant
- * access rights as possible.
- *
- * We don't know which rights will be actually granted. It
- * could be less than what is needed to actually assign the full
- * security descriptor, especially if the process is running as
- * a non-Administrator. However, by default we just do the best
- * we can, unless WIMLIB_EXTRACT_FLAG_STRICT_ACLS has been
- * enabled. The MAXIMUM_ALLOWED access right is seemingly
- * designed for this use case; however, it does not work
- * properly in all cases: it can cause CreateFile() to fail with
- * ERROR_ACCESS_DENIED, even though by definition
- * MAXIMUM_ALLOWED access only requests access rights that are
- * *not* denied. (Needless to say, MS does not document this
- * bug.) */
-
- dwDesiredAccess = WRITE_DAC |
- WRITE_OWNER |
- ACCESS_SYSTEM_SECURITY;
- for (;;) {
- DWORD err;
-
- h = win32_open_existing_file(path, dwDesiredAccess);
- if (h != INVALID_HANDLE_VALUE)
- break;
- err = GetLastError();
- if (err == ERROR_ACCESS_DENIED ||
- err == ERROR_PRIVILEGE_NOT_HELD)
- {
- /* Don't increment partial_security_descriptors
- * here or check WIMLIB_EXTRACT_FLAG_STRICT_ACLS
- * here. It will be done later if needed; here
- * we are just trying to get as many relevant
- * access rights as possible. */
- if (dwDesiredAccess & ACCESS_SYSTEM_SECURITY) {
- dwDesiredAccess &= ~ACCESS_SYSTEM_SECURITY;
- continue;
- }
- if (dwDesiredAccess & WRITE_DAC) {
- dwDesiredAccess &= ~WRITE_DAC;
- continue;
- }
- if (dwDesiredAccess & WRITE_OWNER) {
- dwDesiredAccess &= ~WRITE_OWNER;
- continue;
- }
+ /* Open a handle for NtSetSecurityObject() with as many relevant
+ * access rights as possible.
+ *
+ * We don't know which rights will be actually granted. It
+ * could be less than what is needed to actually assign the full
+ * security descriptor, especially if the process is running as
+ * a non-Administrator. However, by default we just do the best
+ * we can, unless WIMLIB_EXTRACT_FLAG_STRICT_ACLS has been
+ * enabled. The MAXIMUM_ALLOWED access right is seemingly
+ * designed for this use case; however, it does not work
+ * properly in all cases: it can cause CreateFile() to fail with
+ * ERROR_ACCESS_DENIED, even though by definition
+ * MAXIMUM_ALLOWED access only requests access rights that are
+ * *not* denied. (Needless to say, MS does not document this
+ * bug.) */
+
+ dwDesiredAccess = WRITE_DAC | WRITE_OWNER | ACCESS_SYSTEM_SECURITY;
+ while ((h = win32_open_existing_file(path,
+ dwDesiredAccess)) == INVALID_HANDLE_VALUE)
+ {
+ DWORD err;
+
+ err = GetLastError();
+ if (err == ERROR_ACCESS_DENIED ||
+ err == ERROR_PRIVILEGE_NOT_HELD)
+ {
+ /* Don't increment partial_security_descriptors
+ * here or check WIMLIB_EXTRACT_FLAG_STRICT_ACLS
+ * here. It will be done later if needed; here
+ * we are just trying to get as many relevant
+ * access rights as possible. */
+ if (dwDesiredAccess & ACCESS_SYSTEM_SECURITY) {
+ dwDesiredAccess &= ~ACCESS_SYSTEM_SECURITY;
+ continue;
+ }
+ if (dwDesiredAccess & WRITE_DAC) {
+ dwDesiredAccess &= ~WRITE_DAC;
+ continue;
+ }
+ if (dwDesiredAccess & WRITE_OWNER) {
+ dwDesiredAccess &= ~WRITE_OWNER;
+ continue;
}
- /* Other error, or couldn't open the file even with no
- * access rights specified. Something else must be
- * wrong. */
- set_errno_from_win32_error(err);
- return WIMLIB_ERR_SET_SECURITY;
}
+ /* Other error, or couldn't open the file even with no
+ * access rights specified. Something else must be
+ * wrong. */
+ set_errno_from_win32_error(err);
+ return WIMLIB_ERR_SET_SECURITY;
}
-#endif
/* Try setting the security descriptor. */
- for (;;) {
- DWORD err;
-
- err = do_win32_set_security_descriptor(h, path, info,
- (PSECURITY_DESCRIPTOR)desc);
- if (err == ERROR_SUCCESS) {
- ret = 0;
- break;
- }
-
+ ret = 0;
+ while (!(NT_SUCCESS(status = (*func_NtSetSecurityObject)(h,
+ info,
+ (PSECURITY_DESCRIPTOR)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. */
- if ((err == ERROR_PRIVILEGE_NOT_HELD ||
- err == ERROR_ACCESS_DENIED) &&
+ if ((status == STATUS_PRIVILEGE_NOT_HELD ||
+ status == STATUS_ACCESS_DENIED) &&
!(ctx->extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS))
{
if (info & SACL_SECURITY_INFORMATION) {
* security descriptor could not be set. */
if (!(info & SACL_SECURITY_INFORMATION))
ctx->partial_security_descriptors--;
- set_errno_from_win32_error(err);
+ set_errno_from_nt_status(status);
ret = WIMLIB_ERR_SET_SECURITY;
break;
}
/* Close handle opened for NtSetSecurityObject(). */
-#ifdef WITH_NTDLL
- if (func_NtSetSecurityObject)
- CloseHandle(h);
-#endif
+ CloseHandle(h);
return ret;
}