X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fwin32_apply.c;h=48ff5d87e01efa609745090195cd0903546a75ca;hb=f303b46312f8d8be4210fba66082d5a7572dbd70;hp=9eb8bad005f9fa6b2ef23d4fcee6e5be835d2f25;hpb=06c208689d042c215bb9882232aabb0d98c01875;p=wimlib diff --git a/src/win32_apply.c b/src/win32_apply.c index 9eb8bad0..48ff5d87 100644 --- a/src/win32_apply.c +++ b/src/win32_apply.c @@ -30,8 +30,121 @@ #include "wimlib/win32_common.h" #include "wimlib/apply.h" +#include "wimlib/capture.h" +#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/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); + 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; + + pats = get_private_data(ctx)->prepopulate_pats; + if (!pats) + return false; + path = dentry_full_path(dentry); + if (!path) + return false; + + return match_pattern(path, path_basename(path), pats); +} + +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 +152,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,95 +192,61 @@ win32_start_extract(const wchar_t *path, struct apply_ctx *ctx) if (supports_SetFileShortName) ctx->supported_features.short_names = 1; - return 0; -} -/* Create a normal file, overwriting one already present. */ -static int -win32_create_file(const wchar_t *path, struct apply_ctx *ctx, u64 *cookie_ret) -{ - HANDLE h; - unsigned retry_count = 0; - DWORD dwFlagsAndAttributes = FILE_FLAG_BACKUP_SEMANTICS; + if (ctx->extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT) { -retry: - /* WRITE_OWNER and WRITE_DAC privileges are required for some reason, - * even through we're creating a new file. */ - h = CreateFile(path, WRITE_OWNER | WRITE_DAC, 0, NULL, - CREATE_ALWAYS, dwFlagsAndAttributes, NULL); - if (h == INVALID_HANDLE_VALUE) { - /* File couldn't be created. */ - DWORD err = GetLastError(); - if (err == ERROR_ACCESS_DENIED && retry_count == 0) { + ret = load_prepopulate_pats(ctx); + if (ret == WIMLIB_ERR_NOMEM) + goto err; - /* Access denied error for the first time. Try - * adjusting file attributes. */ + if (!wim_info_get_wimboot(ctx->wim->wim_info, + ctx->wim->current_image)) + WARNING("Image is not marked as WIMBoot compatible!"); - /* Get attributes of the existing file. */ - DWORD attribs = GetFileAttributes(path); - if (attribs != INVALID_FILE_ATTRIBUTES && - (attribs & (FILE_ATTRIBUTE_HIDDEN | - FILE_ATTRIBUTE_SYSTEM | - FILE_ATTRIBUTE_READONLY))) - { - /* If the existing file has - * FILE_ATTRIBUTE_HIDDEN and/or - * FILE_ATTRIBUTE_SYSTEM, they must be set in - * the call to CreateFile(). This is true even - * when FILE_ATTRIBUTE_NORMAL was not specified, - * contrary to the MS "documentation". */ - dwFlagsAndAttributes |= (attribs & - (FILE_ATTRIBUTE_HIDDEN | - FILE_ATTRIBUTE_SYSTEM)); - /* If the existing file has - * FILE_ATTRIBUTE_READONLY, it must be cleared - * before attempting to create a new file over - * it. This is true even when the process has - * the SE_RESTORE_NAME privilege and requested - * the FILE_FLAG_BACKUP_SEMANTICS flag to - * CreateFile(). */ - if (attribs & FILE_ATTRIBUTE_READONLY) { - SetFileAttributes(path, - attribs & ~FILE_ATTRIBUTE_READONLY); - } - retry_count++; - goto retry; - } - } - set_errno_from_win32_error(err); - return WIMLIB_ERR_OPEN; + + 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; } - CloseHandle(h); + return 0; + +err: + free_prepopulate_pats(dat); + return ret; } static int -win32_create_directory(const wchar_t *path, struct apply_ctx *ctx, - u64 *cookie_ret) +win32_finish_extract(struct apply_ctx *ctx) { - if (!CreateDirectory(path, NULL)) - if (GetLastError() != ERROR_ALREADY_EXISTS) - goto error; + free_prepopulate_pats(get_private_data(ctx)); return 0; - -error: - set_errno_from_GetLastError(); - return WIMLIB_ERR_MKDIR; } /* Delete a non-directory file, working around Windows quirks. */ static BOOL win32_delete_file_wrapper(const wchar_t *path) { - DWORD attrib; DWORD err; + DWORD attrib; if (DeleteFile(path)) return TRUE; err = GetLastError(); attrib = GetFileAttributes(path); - if (attrib & FILE_ATTRIBUTE_READONLY) { + if ((attrib != INVALID_FILE_ATTRIBUTES) && + (attrib & FILE_ATTRIBUTE_READONLY)) + { /* Try again with FILE_ATTRIBUTE_READONLY cleared. */ attrib &= ~FILE_ATTRIBUTE_READONLY; if (SetFileAttributes(path, attrib)) { @@ -181,6 +261,60 @@ win32_delete_file_wrapper(const wchar_t *path) return FALSE; } + +/* Create a normal file, overwriting one already present. */ +static int +win32_create_file(const wchar_t *path, struct apply_ctx *ctx, u64 *cookie_ret) +{ + HANDLE h; + + /* Notes: + * + * WRITE_OWNER and WRITE_DAC privileges are required for some reason, + * even through we're creating a new file. + * + * FILE_FLAG_OPEN_REPARSE_POINT is required to prevent an existing + * reparse point from redirecting the creation of the new file + * (potentially to an arbitrary location). + * + * CREATE_ALWAYS could be used instead of CREATE_NEW. However, there + * are quirks that would need to be handled (e.g. having to set + * FILE_ATTRIBUTE_HIDDEN and/or FILE_ATTRIBUTE_SYSTEM if the existing + * file had them specified, and/or having to clear + * FILE_ATTRIBUTE_READONLY on the existing file). It's simpler to just + * call win32_delete_file_wrapper() to delete the existing file in such + * a way that already handles the FILE_ATTRIBUTE_READONLY quirk. + */ +retry: + h = CreateFile(path, WRITE_OWNER | WRITE_DAC, 0, NULL, CREATE_NEW, + FILE_FLAG_BACKUP_SEMANTICS | + FILE_FLAG_OPEN_REPARSE_POINT, NULL); + if (h == INVALID_HANDLE_VALUE) { + DWORD err = GetLastError(); + + if (err == ERROR_FILE_EXISTS && win32_delete_file_wrapper(path)) + goto retry; + set_errno_from_win32_error(err); + return WIMLIB_ERR_OPEN; + } + CloseHandle(h); + return 0; +} + +static int +win32_create_directory(const wchar_t *path, struct apply_ctx *ctx, + u64 *cookie_ret) +{ + if (!CreateDirectory(path, NULL)) + if (GetLastError() != ERROR_ALREADY_EXISTS) + goto error; + return 0; + +error: + set_errno_from_GetLastError(); + return WIMLIB_ERR_MKDIR; +} + static int win32_create_hardlink(const wchar_t *oldpath, const wchar_t *newpath, struct apply_ctx *ctx) @@ -280,8 +414,25 @@ error: 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 + && !in_prepopulate_list(dentry, ctx)) + { + 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); } @@ -740,6 +891,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,