X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwin32_apply.c;h=ac0bed0163a882542b38ba6890795ba8d77adb6a;hp=af8a4ef9b9a9bcfa4e09b00efb721ed6ec4f744b;hb=b2efb3c11ba10e2fc08dcf5ca7dab0ab9f51363e;hpb=913e96c7a1c138973912eb4b133a27796fd59e2e diff --git a/src/win32_apply.c b/src/win32_apply.c index af8a4ef9..ac0bed01 100644 --- a/src/win32_apply.c +++ b/src/win32_apply.c @@ -3,7 +3,7 @@ */ /* - * Copyright (C) 2013 Eric Biggers + * Copyright (C) 2013, 2014 Eric Biggers * * This file is part of wimlib, a library for working with WIM files. * @@ -30,8 +30,131 @@ #include "wimlib/win32_common.h" #include "wimlib/apply.h" +#include "wimlib/capture.h" /* for mangle_pat() */ +#include "wimlib/dentry.h" #include "wimlib/error.h" #include "wimlib/lookup_table.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" + +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 win32_apply_private_data * +get_private_data(struct apply_ctx *ctx) +{ + 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 win32_apply_private_data *dat) +{ + if (dat->prepopulate_pats) { + FREE(dat->prepopulate_pats->strings); + FREE(dat->prepopulate_pats); + dat->prepopulate_pats = NULL; + } + + if (dat->mem_prepopulate_pats) { + FREE(dat->mem_prepopulate_pats); + dat->mem_prepopulate_pats = NULL; + } +} + +static int +load_prepopulate_pats(struct apply_ctx *ctx) +{ + int ret; + struct wim_dentry *dentry; + struct wim_lookup_table_entry *lte; + struct string_set *s; + const tchar *path = WIMLIB_WIM_PATH_SEPARATOR_STRING T("Windows") + WIMLIB_WIM_PATH_SEPARATOR_STRING T("System32") + WIMLIB_WIM_PATH_SEPARATOR_STRING T("WimBootCompress.ini"); + 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 || + (dentry->d_inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY | + FILE_ATTRIBUTE_REPARSE_POINT | + FILE_ATTRIBUTE_ENCRYPTED)) || + !(lte = inode_unnamed_lte(dentry->d_inode, ctx->wim->lookup_table))) + { + WARNING("%"TS" does not exist in WIM image!", path); + return WIMLIB_ERR_PATH_DOES_NOT_EXIST; + } + + ret = read_full_stream_into_alloc_buf(lte, &buf); + if (ret) + return ret; + + s = CALLOC(1, sizeof(struct string_set)); + if (!s) { + FREE(buf); + return WIMLIB_ERR_NOMEM; + } + + sec.name = T("PrepopulateList"); + sec.strings = s; + + ret = do_load_text_file(path, buf, lte->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); + FREE(buf); + if (ret) { + FREE(s); + return ret; + } + dat->prepopulate_pats = s; + dat->mem_prepopulate_pats = mem; + return 0; +} + +static bool +in_prepopulate_list(struct wim_dentry *dentry, struct apply_ctx *ctx) +{ + struct string_set *pats; + const tchar *path; + size_t path_nchars; + + pats = get_private_data(ctx)->prepopulate_pats; + if (!pats || !pats->num_strings) + return false; + + path = dentry_full_path(dentry); + if (!path) + return false; + + 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 win32_start_extract(const wchar_t *path, struct apply_ctx *ctx) @@ -39,10 +162,11 @@ win32_start_extract(const wchar_t *path, struct apply_ctx *ctx) 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; @@ -78,6 +202,43 @@ win32_start_extract(const wchar_t *path, struct apply_ctx *ctx) if (supports_SetFileShortName) ctx->supported_features.short_names = 1; + + if (ctx->extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT) { + + ret = load_prepopulate_pats(ctx); + if (ret == WIMLIB_ERR_NOMEM) + 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, + &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(get_private_data(ctx)); return 0; } @@ -241,30 +402,83 @@ win32_extract_stream(const wchar_t *path, const wchar_t *stream_name, 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 win32_extract_unnamed_stream(file_spec_t file, struct wim_lookup_table_entry *lte, - struct apply_ctx *ctx) + struct apply_ctx *ctx, + struct wim_dentry *dentry) { + if (ctx->extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT + && lte + && lte->resource_location == RESOURCE_IN_WIM + && lte->rspec->wim == ctx->wim + && lte->size == lte->rspec->uncompressed_size) + { + 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); } @@ -516,23 +730,6 @@ error: 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. @@ -547,7 +744,9 @@ win32_set_security_descriptor(const wchar_t *path, const u8 *desc, 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 @@ -559,8 +758,6 @@ win32_set_security_descriptor(const wchar_t *path, const u8 *desc, 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 @@ -570,83 +767,69 @@ win32_set_security_descriptor(const wchar_t *path, const u8 *desc, * 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) { @@ -670,16 +853,13 @@ win32_set_security_descriptor(const wchar_t *path, const u8 *desc, * 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; } @@ -723,6 +903,8 @@ const struct apply_operations win32_apply_ops = { .target_is_root = win32_path_is_root_of_drive, .start_extract = win32_start_extract, + .finish_extract = win32_finish_extract, + .abort_extract = win32_finish_extract, .create_file = win32_create_file, .create_directory = win32_create_directory, .create_hardlink = win32_create_hardlink,