X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwin32.c;h=0fd7508a66b406d62981a1268176331872505113;hp=06fd74d6371fc1ffe1ad94c4ddb1f42bed1c7cab;hb=8c2fbf8ae771c66c20e664155f0a34fb44cbe6ee;hpb=4d09d61542de5f16137192b6d0a9cac1bbf4f468 diff --git a/src/win32.c b/src/win32.c index 06fd74d6..0fd7508a 100644 --- a/src/win32.c +++ b/src/win32.c @@ -599,9 +599,11 @@ win32_get_file_and_vol_ids(const wchar_t *path, u64 *ino_ret, u64 *dev_ret) hFile = win32_open_existing_file(path, FILE_READ_ATTRIBUTES); if (hFile == INVALID_HANDLE_VALUE) { err = GetLastError(); - WARNING("Failed to open \"%ls\" to get file and volume IDs", - path); - win32_error(err); + if (err != ERROR_FILE_NOT_FOUND) { + WARNING("Failed to open \"%ls\" to get file " + "and volume IDs", path); + win32_error(err); + } return WIMLIB_ERR_OPEN; } @@ -660,155 +662,137 @@ enum rp_status { * be reached via multiple destinations due to other symbolic links). This may * not work properly on FAT, which doesn't seem to supply proper inode numbers * or file IDs. However, FAT doesn't support reparse points so this function - * wouldn't even be called anyway. */ + * wouldn't even be called anyway. + */ static enum rp_status -win32_maybe_rpfix_target(wchar_t *target, size_t *target_nchars_p, - u64 capture_root_ino, u64 capture_root_dev) +win32_capture_maybe_rpfix_target(wchar_t *target, u16 *target_nbytes_p, + u64 capture_root_ino, u64 capture_root_dev, + u32 rptag) { - size_t target_nchars= *target_nchars_p; + u16 target_nchars = *target_nbytes_p / 2; size_t stripped_chars; wchar_t *orig_target; + int ret; - if (target_nchars == 0) - /* Invalid reparse point (empty target) */ + ret = parse_substitute_name(target, *target_nbytes_p, rptag); + if (ret < 0) return RP_NOT_FIXED; - - if (target[0] == L'\\') { - if (target_nchars >= 2 && target[1] == L'\\') { - /* Probably a volume. Can't do anything with it. */ - DEBUG("Not fixing target (probably a volume)"); - return RP_NOT_FIXED; - } else if (target_nchars >= 7 && - target[1] == '?' && - target[2] == '?' && - target[3] == '\\' && - target[4] != '\0' && - target[5] == ':' && - target[6] == '\\') - { - DEBUG("Full style path"); - /* Full \??\x:\ style path (may be junction or symlink) - * */ - stripped_chars = 6; - } else { - DEBUG("Absolute target without drive letter"); - /* Absolute target, without drive letter */ - stripped_chars = 0; - } - } else if (target_nchars >= 3 && - target[0] != L'\0' && - target[1] == L':' && - target[2] == L'\\') - { - DEBUG("Absolute target with drive letter"); - /* Absolute target, with drive letter */ - stripped_chars = 2; - } else { - DEBUG("Relative symlink or other link"); - /* Relative symlink or other unexpected format */ - return RP_NOT_FIXED; - } + stripped_chars = ret; + if (stripped_chars) + stripped_chars -= 2; target[target_nchars] = L'\0'; orig_target = target; - target = fixup_symlink(target + stripped_chars, capture_root_ino, capture_root_dev); + target = capture_fixup_absolute_symlink(target + stripped_chars, + capture_root_ino, capture_root_dev); if (!target) return RP_EXCLUDED; target_nchars = wcslen(target); wmemmove(orig_target + stripped_chars, target, target_nchars + 1); - *target_nchars_p = target_nchars + stripped_chars; + *target_nbytes_p = (target_nchars + stripped_chars) * sizeof(wchar_t); DEBUG("Fixed reparse point (new target: \"%ls\")", orig_target); - if (stripped_chars == 6) + if (stripped_chars) return RP_FIXED_FULLPATH; else return RP_FIXED_ABSPATH; } -static enum rp_status -win32_try_capture_rpfix(char *rpbuf, DWORD *rpbuflen_p, - u64 capture_root_ino, u64 capture_root_dev) +/* Returns: `enum rp_status' value on success; negative WIMLIB_ERR_* value on + * failure. */ +static int +win32_capture_try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, + u64 capture_root_ino, u64 capture_root_dev, + const wchar_t *path) { - const char *p_get; - char *p_put; - u16 substitute_name_offset; - u16 substitute_name_len; - wchar_t *target; - size_t target_nchars; - enum rp_status status; - u32 rptag; - DWORD rpbuflen = *rpbuflen_p; - - if (rpbuflen < 16) /* Invalid reparse point (length too small) */ - return RP_NOT_FIXED; - p_get = get_u32(rpbuf, &rptag); - p_get += 4; - p_get = get_u16(p_get, &substitute_name_offset); - p_get = get_u16(p_get, &substitute_name_len); - p_get += 4; - if (rptag == WIM_IO_REPARSE_TAG_SYMLINK) { - if (rpbuflen < 20) /* Invalid reparse point (length too small) */ - return RP_NOT_FIXED; - p_get += 4; - } - if ((DWORD)substitute_name_offset + - substitute_name_len + (p_get - rpbuf) > rpbuflen) - /* Invalid reparse point (length too small) */ - return RP_NOT_FIXED; - - target = (wchar_t*)&p_get[substitute_name_offset]; - target_nchars = substitute_name_len / 2; - /* Note: target is not necessarily null-terminated */ - - status = win32_maybe_rpfix_target(target, &target_nchars, - capture_root_ino, capture_root_dev); - if (status & RP_FIXED) { - size_t target_nbytes = target_nchars * 2; - size_t print_nbytes = target_nbytes; - wchar_t target_copy[target_nchars]; - wchar_t *print_name = target_copy; + struct reparse_data rpdata; + DWORD rpbuflen; + int ret; + enum rp_status rp_status; - if (status == RP_FIXED_FULLPATH) { + rpbuflen = *rpbuflen_p; + ret = parse_reparse_data(rpbuf, rpbuflen, &rpdata); + if (ret) + return -ret; + + rp_status = win32_capture_maybe_rpfix_target(rpdata.substitute_name, + &rpdata.substitute_name_nbytes, + capture_root_ino, + capture_root_dev, + le32_to_cpu(*(u32*)rpbuf)); + if (rp_status & RP_FIXED) { + wimlib_assert(rpdata.substitute_name_nbytes % 2 == 0); + utf16lechar substitute_name_copy[rpdata.substitute_name_nbytes / 2]; + wmemcpy(substitute_name_copy, rpdata.substitute_name, + rpdata.substitute_name_nbytes / 2); + rpdata.substitute_name = substitute_name_copy; + rpdata.print_name = substitute_name_copy; + rpdata.print_name_nbytes = rpdata.substitute_name_nbytes; + if (rp_status == RP_FIXED_FULLPATH) { /* "full path", meaning \??\ prefixed. We should not * include this prefix in the print name, as it is * apparently meant for the filesystem driver only. */ - print_nbytes -= 8; - print_name += 4; + rpdata.print_name += 4; + rpdata.print_name_nbytes -= 8; } - wmemcpy(target_copy, target, target_nchars); - p_put = rpbuf + 8; - p_put = put_u16(p_put, 0); /* Substitute name offset */ - p_put = put_u16(p_put, target_nbytes); /* Substitute name length */ - p_put = put_u16(p_put, target_nbytes + 2); /* Print name offset */ - p_put = put_u16(p_put, print_nbytes); /* Print name length */ - if (rptag == WIM_IO_REPARSE_TAG_SYMLINK) - p_put = put_u32(p_put, 1); - p_put = put_bytes(p_put, target_nbytes, target_copy); - p_put = put_u16(p_put, 0); - p_put = put_bytes(p_put, print_nbytes, print_name); - p_put = put_u16(p_put, 0); - - /* Wrote the end of the reparse data. Recalculate the length, - * set the length field correctly, and return it. */ - rpbuflen = p_put - rpbuf; - put_u16(rpbuf + 4, rpbuflen - 8); - *rpbuflen_p = rpbuflen; - } - return status; + ret = make_reparse_buffer(&rpdata, rpbuf); + if (ret == 0) + ret = rp_status; + else + ret = -ret; + } else { + if (ret == RP_EXCLUDED) { + size_t print_name_nchars = rpdata.print_name_nbytes / 2; + wchar_t print_name0[print_name_nchars + 1]; + print_name0[print_name_nchars] = L'\0'; + wmemcpy(print_name0, rpdata.print_name, print_name_nchars); + WARNING("Ignoring %ls pointing out of capture directory:\n" + " \"%ls\" -> \"%ls\"\n" + " (Use --norpfix to capture all symbolic links " + "and junction points as-is)", + (rpdata.rptag == WIM_IO_REPARSE_TAG_SYMLINK) ? + L"absolute symbolic link" : L"junction point", + path, print_name0); + } + ret = rp_status; + } + return ret; } +/* + * Loads the reparse point data from a reparse point into memory, optionally + * fixing the targets of absolute symbolic links and junction points to be + * relative to the root of capture. + * + * @hFile: Open handle to the reparse point. + * @path: Path to the reparse point. Used for error messages only. + * @params: Additional parameters, including whether to do reparse point fixups + * or not. + * @rpbuf: Buffer of length at least REPARSE_POINT_MAX_SIZE bytes into which + * the reparse point buffer will be loaded. + * @rpbuflen_ret: On success, the length of the reparse point buffer in bytes + * is written to this location. + * + * Returns: + * On success, returns an `enum rp_status' value that indicates if and/or + * how the reparse point fixup was done. + * + * On failure, returns a negative value that is a negated WIMLIB_ERR_* + * code. + */ static int win32_get_reparse_data(HANDLE hFile, const wchar_t *path, struct add_image_params *params, - void *reparse_data, size_t *reparse_data_len_ret) + u8 *rpbuf, u16 *rpbuflen_ret) { DWORD bytesReturned; u32 reparse_tag; - enum rp_status status; + int ret; + u16 rpbuflen; DEBUG("Loading reparse data from \"%ls\"", path); if (!DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT, NULL, /* "Not used with this operation; set to NULL" */ 0, /* "Not used with this operation; set to 0" */ - reparse_data, /* "A pointer to a buffer that + rpbuf, /* "A pointer to a buffer that receives the reparse point data */ REPARSE_POINT_MAX_SIZE, /* "The size of the output buffer, in bytes */ @@ -820,26 +804,28 @@ win32_get_reparse_data(HANDLE hFile, const wchar_t *path, win32_error(err); return -WIMLIB_ERR_READ; } - if (bytesReturned < 8) { + if (bytesReturned < 8 || bytesReturned > REPARSE_POINT_MAX_SIZE) { ERROR("Reparse data on \"%ls\" is invalid", path); - return -WIMLIB_ERR_READ; + return -WIMLIB_ERR_INVALID_REPARSE_DATA; } - reparse_tag = le32_to_cpu(*(u32*)reparse_data); + rpbuflen = bytesReturned; + reparse_tag = le32_to_cpu(*(u32*)rpbuf); if (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_RPFIX && (reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK || reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT)) { /* Try doing reparse point fixup */ - status = win32_try_capture_rpfix(reparse_data, - &bytesReturned, - params->capture_root_ino, - params->capture_root_dev); + ret = win32_capture_try_rpfix(rpbuf, + &rpbuflen, + params->capture_root_ino, + params->capture_root_dev, + path); } else { - status = RP_NOT_FIXED; + ret = RP_NOT_FIXED; } - *reparse_data_len_ret = bytesReturned; - return status; + *rpbuflen_ret = rpbuflen; + return ret; } static DWORD WINAPI @@ -1076,10 +1062,10 @@ win32_capture_streams(const wchar_t *path, return 0; } else { if (err == ERROR_ACCESS_DENIED) { - ERROR("Failed to look up data streams " - "of \"%ls\": Access denied!\n%ls", - path, capture_access_denied_msg); - return WIMLIB_ERR_READ; + WARNING("Failed to look up data streams " + "of \"%ls\": Access denied!\n%ls", + path, capture_access_denied_msg); + return 0; } else { ERROR("Failed to look up data streams " "of \"%ls\"", path); @@ -1140,8 +1126,8 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret, DWORD err; u64 file_size; int ret; - void *reparse_data; - size_t reparse_data_len; + u8 *rpbuf; + u16 rpbuflen; u16 not_rpfixed; if (exclude_path(path, path_num_chars, params->config, true)) { @@ -1192,9 +1178,9 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret, } if (file_info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { - reparse_data = alloca(REPARSE_POINT_MAX_SIZE); + rpbuf = alloca(REPARSE_POINT_MAX_SIZE); ret = win32_get_reparse_data(hFile, path, params, - reparse_data, &reparse_data_len); + rpbuf, &rpbuflen); if (ret < 0) { /* WIMLIB_ERR_* (inverted) */ ret = -ret; @@ -1273,9 +1259,8 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret, /* Reparse point: set the reparse data (which we read already) * */ inode->i_not_rpfixed = not_rpfixed; - inode->i_reparse_tag = le32_to_cpu(*(u32*)reparse_data); - ret = inode_set_unnamed_stream(inode, reparse_data + 8, - reparse_data_len - 8, + inode->i_reparse_tag = le32_to_cpu(*(u32*)rpbuf); + ret = inode_set_unnamed_stream(inode, rpbuf + 8, rpbuflen - 8, params->lookup_table); } else if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) { /* Directory (not a reparse point) --- recurse to children */ @@ -1346,6 +1331,14 @@ win32_build_dentry_tree(struct wim_dentry **root_ret, if (path_nchars > 32767) return WIMLIB_ERR_INVALID_PARAM; + if (GetFileAttributesW(root_disk_path) == INVALID_FILE_ATTRIBUTES && + GetLastError() == ERROR_FILE_NOT_FOUND) + { + ERROR("Capture directory \"%ls\" does not exist!", + root_disk_path); + return WIMLIB_ERR_OPENDIR; + } + ret = win32_get_file_and_vol_ids(root_disk_path, ¶ms->capture_root_ino, ¶ms->capture_root_dev); @@ -1374,39 +1367,122 @@ win32_build_dentry_tree(struct wim_dentry **root_ret, return ret; } +static int +win32_extract_try_rpfix(u8 *rpbuf, + const wchar_t *extract_root_realpath, + unsigned extract_root_realpath_nchars) +{ + struct reparse_data rpdata; + wchar_t *target; + size_t target_nchars; + size_t stripped_nchars; + wchar_t *stripped_target; + wchar_t stripped_target_nchars; + int ret; + + utf16lechar *new_target; + utf16lechar *new_print_name; + size_t new_target_nchars; + size_t new_print_name_nchars; + utf16lechar *p; + + ret = parse_reparse_data(rpbuf, 8 + le16_to_cpu(*(u16*)(rpbuf + 4)), + &rpdata); + if (ret) + return ret; + + if (extract_root_realpath[0] == L'\0' || + extract_root_realpath[1] != L':' || + extract_root_realpath[2] != L'\\') + { + ERROR("Can't understand full path format \"%ls\". " + "Try turning reparse point fixups off...", + extract_root_realpath); + return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED; + } + + ret = parse_substitute_name(rpdata.substitute_name, + rpdata.substitute_name_nbytes, + rpdata.rptag); + if (ret < 0) + return 0; + stripped_nchars = ret; + target = rpdata.substitute_name; + target_nchars = rpdata.substitute_name_nbytes / sizeof(utf16lechar); + stripped_target = target + 6; + stripped_target_nchars = target_nchars - stripped_nchars; + + new_target = alloca((6 + extract_root_realpath_nchars + + stripped_target_nchars) * sizeof(utf16lechar)); + + p = new_target; + if (stripped_nchars == 6) { + /* Include \??\ prefix if it was present before */ + wmemcpy(p, L"\\??\\", 4); + p += 4; + } + + /* Print name excludes the \??\ if present. */ + new_print_name = p; + if (stripped_nchars != 0) { + /* Get drive letter from real path to extract root, if a drive + * letter was present before. */ + *p++ = extract_root_realpath[0]; + *p++ = extract_root_realpath[1]; + } + /* Copy the rest of the extract root */ + wmemcpy(p, extract_root_realpath + 2, extract_root_realpath_nchars - 2); + p += extract_root_realpath_nchars - 2; + + /* Append the stripped target */ + wmemcpy(p, stripped_target, stripped_target_nchars); + p += stripped_target_nchars; + new_target_nchars = p - new_target; + new_print_name_nchars = p - new_print_name; + + if (new_target_nchars * sizeof(utf16lechar) >= REPARSE_POINT_MAX_SIZE || + new_print_name_nchars * sizeof(utf16lechar) >= REPARSE_POINT_MAX_SIZE) + { + ERROR("Path names too long to do reparse point fixup!"); + return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED; + } + rpdata.substitute_name = new_target; + rpdata.substitute_name_nbytes = new_target_nchars * sizeof(utf16lechar); + rpdata.print_name = new_print_name; + rpdata.print_name_nbytes = new_print_name_nchars * sizeof(utf16lechar); + return make_reparse_buffer(&rpdata, rpbuf); +} + /* Wrapper around the FSCTL_SET_REPARSE_POINT ioctl to set the reparse data on * an extracted reparse point. */ static int win32_set_reparse_data(HANDLE h, - u32 reparse_tag, + const struct wim_inode *inode, const struct wim_lookup_table_entry *lte, - const wchar_t *path) + const wchar_t *path, + const struct apply_args *args) { int ret; - u8 *buf; - size_t len; + u8 rpbuf[REPARSE_POINT_MAX_SIZE]; + DWORD bytesReturned; - if (!lte) { - WARNING("\"%ls\" is marked as a reparse point but had no reparse data", - path); - return 0; - } - len = wim_resource_size(lte); - if (len > 16 * 1024 - 8) { - WARNING("\"%ls\": reparse data too long!", path); - return 0; - } + DEBUG("Setting reparse data on \"%ls\"", path); - /* The WIM stream omits the ReparseTag and ReparseDataLength fields, so - * leave 8 bytes of space for them at the beginning of the buffer, then - * set them manually. */ - buf = alloca(len + 8); - ret = read_full_resource_into_buf(lte, buf + 8, false); + ret = wim_inode_get_reparse_data(inode, rpbuf); if (ret) return ret; - *(u32*)(buf + 0) = cpu_to_le32(reparse_tag); - *(u16*)(buf + 4) = cpu_to_le16(len); - *(u16*)(buf + 6) = 0; + + if (args->extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX && + (inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK || + inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT) && + !inode->i_not_rpfixed) + { + ret = win32_extract_try_rpfix(rpbuf, + args->target_realpath, + args->target_realpath_len); + if (ret) + return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED; + } /* Set the reparse data on the open file using the * FSCTL_SET_REPARSE_POINT ioctl. @@ -1429,8 +1505,8 @@ win32_set_reparse_data(HANDLE h, * * "Not used with this operation; set to NULL." */ - DWORD bytesReturned; - if (!DeviceIoControl(h, FSCTL_SET_REPARSE_POINT, buf, len + 8, + if (!DeviceIoControl(h, FSCTL_SET_REPARSE_POINT, rpbuf, + 8 + le16_to_cpu(*(u16*)(rpbuf + 4)), NULL, 0, &bytesReturned /* lpBytesReturned */, NULL /* lpOverlapped */)) @@ -1440,8 +1516,8 @@ win32_set_reparse_data(HANDLE h, win32_error(err); if (err == ERROR_ACCESS_DENIED || err == ERROR_PRIVILEGE_NOT_HELD) return WIMLIB_ERR_INSUFFICIENT_PRIVILEGES_TO_EXTRACT; - else if (reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK || - reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT) + else if (inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK || + inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT) return WIMLIB_ERR_LINK; else return WIMLIB_ERR_WRITE; @@ -1634,13 +1710,8 @@ do_win32_extract_stream(HANDLE hStream, const struct wim_lookup_table_entry *lte } struct win32_encrypted_extract_ctx { - void *file_ctx; - int wimlib_err_code; - bool done; - pthread_cond_t cond; - pthread_mutex_t mutex; - u8 buf[WIM_CHUNK_SIZE]; - size_t buf_filled; + const struct wim_lookup_table_entry *lte; + u64 offset; }; static DWORD WINAPI @@ -1649,78 +1720,16 @@ win32_encrypted_import_cb(unsigned char *data, void *_ctx, { struct win32_encrypted_extract_ctx *ctx = _ctx; unsigned long len = *len_p; + const struct wim_lookup_table_entry *lte = ctx->lte; - pthread_mutex_lock(&ctx->mutex); - while (len) { - size_t bytes_to_copy; + len = min(len, wim_resource_size(lte) - ctx->offset); - DEBUG("Importing up to %lu more bytes of raw encrypted data", len); - while (ctx->buf_filled == 0) { - if (ctx->done) - goto out; - pthread_cond_wait(&ctx->cond, &ctx->mutex); - } - bytes_to_copy = min(len, ctx->buf_filled); - memcpy(data, ctx->buf, bytes_to_copy); - len -= bytes_to_copy; - data += bytes_to_copy; - ctx->buf_filled -= bytes_to_copy; - memmove(ctx->buf, ctx->buf + bytes_to_copy, ctx->buf_filled); - pthread_cond_signal(&ctx->cond); - } -out: - *len_p -= len; - pthread_mutex_unlock(&ctx->mutex); - return ERROR_SUCCESS; -} + if (read_partial_wim_resource_into_buf(lte, len, ctx->offset, data, false)) + return ERROR_READ_FAULT; -/* Extract ("Import") an encrypted file in a different thread. */ -static void * -win32_encrypted_import_proc(void *arg) -{ - struct win32_encrypted_extract_ctx *ctx = arg; - DWORD ret; - ret = WriteEncryptedFileRaw(win32_encrypted_import_cb, ctx, - ctx->file_ctx); - pthread_mutex_lock(&ctx->mutex); - if (ret == ERROR_SUCCESS) { - ctx->wimlib_err_code = 0; - } else { - win32_error(ret); - ctx->wimlib_err_code = WIMLIB_ERR_WRITE; - } - ctx->done = true; - pthread_cond_signal(&ctx->cond); - pthread_mutex_unlock(&ctx->mutex); - return NULL; -} - - -static int -win32_extract_raw_encrypted_chunk(const void *buf, size_t len, void *arg) -{ - struct win32_encrypted_extract_ctx *ctx = arg; - size_t bytes_to_copy; - - while (len) { - DEBUG("Extracting up to %zu more bytes of encrypted data", len); - pthread_mutex_lock(&ctx->mutex); - while (ctx->buf_filled == WIM_CHUNK_SIZE) { - if (ctx->done) { - pthread_mutex_unlock(&ctx->mutex); - return ctx->wimlib_err_code; - } - pthread_cond_wait(&ctx->cond, &ctx->mutex); - } - bytes_to_copy = min(len, WIM_CHUNK_SIZE - ctx->buf_filled); - memcpy(&ctx->buf[ctx->buf_filled], buf, bytes_to_copy); - len -= bytes_to_copy; - buf += bytes_to_copy; - ctx->buf_filled += bytes_to_copy; - pthread_cond_signal(&ctx->cond); - pthread_mutex_unlock(&ctx->mutex); - } - return 0; + ctx->offset += len; + *len_p = len; + return ERROR_SUCCESS; } /* Create an encrypted file and extract the raw encrypted data to it. @@ -1739,11 +1748,8 @@ static int do_win32_extract_encrypted_stream(const wchar_t *path, const struct wim_lookup_table_entry *lte) { - struct win32_encrypted_extract_ctx ctx; void *file_ctx; - pthread_t import_thread; int ret; - int ret2; DEBUG("Opening file \"%ls\" to extract raw encrypted data", path); @@ -1754,61 +1760,20 @@ do_win32_extract_encrypted_stream(const wchar_t *path, return WIMLIB_ERR_OPEN; } - if (!lte) - goto out_close; - - /* Hack alert: WriteEncryptedFileRaw() requires the callback function - * to work with a buffer whose size we cannot control. This doesn't - * play well with our read_resource_prefix() function, which itself uses - * a callback function to extract WIM_CHUNK_SIZE chunks of data. We - * work around this problem by calling WriteEncryptedFileRaw() in a - * different thread and feeding it the data as needed. */ - ctx.file_ctx = file_ctx; - ctx.buf_filled = 0; - ctx.done = false; - ctx.wimlib_err_code = 0; - if (pthread_mutex_init(&ctx.mutex, NULL)) { - ERROR_WITH_ERRNO("Can't create mutex"); - ret = WIMLIB_ERR_NOMEM; - goto out_close; - } - if (pthread_cond_init(&ctx.cond, NULL)) { - ERROR_WITH_ERRNO("Can't create condition variable"); - ret = WIMLIB_ERR_NOMEM; - goto out_pthread_mutex_destroy; - } - ret = pthread_create(&import_thread, NULL, - win32_encrypted_import_proc, &ctx); - if (ret) { - errno = ret; - ERROR_WITH_ERRNO("Failed to create thread"); - ret = WIMLIB_ERR_FORK; - goto out_pthread_cond_destroy; - } - - ret = extract_wim_resource(lte, wim_resource_size(lte), - win32_extract_raw_encrypted_chunk, &ctx); - pthread_mutex_lock(&ctx.mutex); - ctx.done = true; - pthread_cond_signal(&ctx.cond); - pthread_mutex_unlock(&ctx.mutex); - ret2 = pthread_join(import_thread, NULL); - if (ret2) { - errno = ret2; - ERROR_WITH_ERRNO("Failed to join encrypted import thread"); - if (ret == 0) + if (lte) { + struct win32_encrypted_extract_ctx ctx; + + ctx.lte = lte; + ctx.offset = 0; + ret = WriteEncryptedFileRaw(win32_encrypted_import_cb, &ctx, file_ctx); + if (ret == ERROR_SUCCESS) { + ret = 0; + } else { ret = WIMLIB_ERR_WRITE; + ERROR("Failed to extract encrypted file \"%ls\"", path); + } } - if (ret == 0) - ret = ctx.wimlib_err_code; -out_pthread_cond_destroy: - pthread_cond_destroy(&ctx.cond); -out_pthread_mutex_destroy: - pthread_mutex_destroy(&ctx.mutex); -out_close: CloseEncryptedFileRaw(file_ctx); - if (ret) - ERROR("Failed to extract encrypted file \"%ls\"", path); return ret; } @@ -1931,17 +1896,11 @@ win32_begin_extract_unnamed_stream(const struct wim_inode *inode, /* Directories must be created with CreateDirectoryW(). Then the call * to CreateFileW() will merely open the directory that was already * created rather than creating a new file. */ - if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) { + if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY && + !path_is_root_of_drive(path)) { if (!CreateDirectoryW(path, NULL)) { err = GetLastError(); - switch (err) { - case ERROR_ALREADY_EXISTS: - break; - case ERROR_ACCESS_DENIED: - if (path_is_root_of_drive(path)) - break; - /* Fall through */ - default: + if (err != ERROR_ALREADY_EXISTS) { ERROR("Failed to create directory \"%ls\"", path); win32_error(err); @@ -1955,12 +1914,23 @@ win32_begin_extract_unnamed_stream(const struct wim_inode *inode, vol_flags & FILE_SUPPORTS_ENCRYPTION) { if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) { - if (!EncryptFile(path)) { - err = GetLastError(); - ERROR("Failed to encrypt directory \"%ls\"", - path); - win32_error(err); - return WIMLIB_ERR_WRITE; + unsigned remaining_sharing_violations = 100; + while (!EncryptFile(path)) { + if (remaining_sharing_violations && + err == ERROR_SHARING_VIOLATION) + { + WARNING("Couldn't encrypt directory \"%ls\" " + "due to sharing violation; re-trying " + "after 100 ms", path); + Sleep(100); + remaining_sharing_violations--; + } else { + err = GetLastError(); + ERROR("Failed to encrypt directory \"%ls\"", + path); + win32_error(err); + return WIMLIB_ERR_WRITE; + } } } else { ret = do_win32_extract_encrypted_stream(path, lte); @@ -1996,13 +1966,15 @@ win32_begin_extract_unnamed_stream(const struct wim_inode *inode, /* Set security descriptor and extract stream data or reparse data (skip the * unnamed data stream of encrypted files, which was already extracted). */ static int -win32_finish_extract_stream(HANDLE h, const struct wim_inode *inode, +win32_finish_extract_stream(HANDLE h, const struct wim_dentry *dentry, const struct wim_lookup_table_entry *lte, const wchar_t *stream_path, const wchar_t *stream_name_utf16, struct apply_args *args) { int ret = 0; + const struct wim_inode *inode = dentry->d_inode; + const wchar_t *short_name; if (stream_name_utf16 == NULL) { /* Unnamed stream. */ @@ -2034,11 +2006,9 @@ win32_finish_extract_stream(HANDLE h, const struct wim_inode *inode, * entirely on such volumes.) */ if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) { if (args->vol_flags & FILE_SUPPORTS_REPARSE_POINTS) { - DEBUG("Setting reparse data on \"%ls\"", - stream_path); - ret = win32_set_reparse_data(h, - inode->i_reparse_tag, - lte, stream_path); + ret = win32_set_reparse_data(h, inode, + lte, stream_path, + args); if (ret) return ret; } else { @@ -2055,6 +2025,21 @@ win32_finish_extract_stream(HANDLE h, const struct wim_inode *inode, * the stream is encrypted and therefore was already * extracted as a special case. */ ret = do_win32_extract_stream(h, lte); + if (ret) + return ret; + } + + if (dentry_has_short_name(dentry)) + short_name = dentry->short_name; + else + short_name = L""; + /* Set short name */ + if (!SetFileShortNameW(h, short_name)) { + #if 0 + DWORD err = GetLastError(); + ERROR("Could not set short name on \"%ls\"", stream_path); + win32_error(err); + #endif } } else { /* Extract the data for a named data stream. */ @@ -2095,7 +2080,7 @@ win32_decrypt_file(HANDLE open_handle, const wchar_t *path) * This handles reparse points, directories, alternate data streams, encrypted * files, compressed files, etc. * - * @inode: WIM inode containing the stream. + * @dentry: WIM dentry for the file or directory being extracted. * * @path: Path to extract the file to. * @@ -2113,7 +2098,7 @@ win32_decrypt_file(HANDLE open_handle, const wchar_t *path) * Returns 0 on success; nonzero on failure. */ static int -win32_extract_stream(const struct wim_inode *inode, +win32_extract_stream(const struct wim_dentry *dentry, const wchar_t *path, const wchar_t *stream_name_utf16, struct wim_lookup_table_entry *lte, @@ -2126,6 +2111,8 @@ win32_extract_stream(const struct wim_inode *inode, DWORD creationDisposition = CREATE_ALWAYS; DWORD requestedAccess; BY_HANDLE_FILE_INFORMATION file_info; + unsigned remaining_sharing_violations = 1000; + const struct wim_inode *inode = dentry->d_inode; if (stream_name_utf16) { /* Named stream. Create a buffer that contains the UTF-16LE @@ -2169,7 +2156,8 @@ win32_extract_stream(const struct wim_inode *inode, } DEBUG("Opening \"%ls\"", stream_path); - requestedAccess = GENERIC_READ | GENERIC_WRITE | + /* DELETE access is needed for SetFileShortNameW(), for some reason. */ + requestedAccess = GENERIC_READ | GENERIC_WRITE | DELETE | ACCESS_SYSTEM_SECURITY; try_open_again: /* Open the stream to be extracted. Depending on what we have set @@ -2178,14 +2166,21 @@ try_open_again: * CreateDirectoryW() or OpenEncryptedFileRawW(). */ h = CreateFileW(stream_path, requestedAccess, - 0, + FILE_SHARE_READ, NULL, creationDisposition, win32_get_create_flags_and_attributes(inode->i_attributes), NULL); if (h == INVALID_HANDLE_VALUE) { err = GetLastError(); - if (err == ERROR_PRIVILEGE_NOT_HELD && + if (err == ERROR_ACCESS_DENIED && + path_is_root_of_drive(stream_path)) + { + ret = 0; + goto out; + } + if ((err == ERROR_PRIVILEGE_NOT_HELD || + err == ERROR_ACCESS_DENIED) && (requestedAccess & ACCESS_SYSTEM_SECURITY)) { /* Try opening the file again without privilege to @@ -2193,8 +2188,25 @@ try_open_again: requestedAccess &= ~ACCESS_SYSTEM_SECURITY; goto try_open_again; } - ERROR("Failed to create \"%ls\"", stream_path); - win32_error(err); + if (err == ERROR_SHARING_VIOLATION) { + if (remaining_sharing_violations) { + --remaining_sharing_violations; + /* This can happen when restoring encrypted directories + * for some reason. Probably a bug in EncryptFile(). */ + WARNING("Couldn't open \"%ls\" due to sharing violation; " + "re-trying after 100ms", stream_path); + Sleep(100); + goto try_open_again; + } else { + ERROR("Too many sharing violations; giving up..."); + } + } else { + if (creationDisposition == OPEN_EXISTING) + ERROR("Failed to open \"%ls\"", stream_path); + else + ERROR("Failed to create \"%ls\"", stream_path); + win32_error(err); + } ret = WIMLIB_ERR_OPEN; goto fail; } @@ -2253,7 +2265,7 @@ try_open_again: * descriptor and actually extract the stream data (other than for * extracted files, which were already extracted). * win32_finish_extract_stream() handles these additional steps. */ - ret = win32_finish_extract_stream(h, inode, lte, stream_path, + ret = win32_finish_extract_stream(h, dentry, lte, stream_path, stream_name_utf16, args); if (ret) goto fail_close_handle; @@ -2282,23 +2294,24 @@ out: * (unnamed data stream and/or reparse point stream, plus any alternate data * streams). Handles sparse, compressed, and/or encrypted files. * - * @inode: WIM inode for this file or directory. + * @dentry: WIM dentry for this file or directory. * @path: UTF-16LE external path to extract the inode to. * @args: Additional extraction context. * * Returns 0 on success; nonzero on failure. */ static int -win32_extract_streams(const struct wim_inode *inode, +win32_extract_streams(const struct wim_dentry *dentry, const wchar_t *path, struct apply_args *args) { struct wim_lookup_table_entry *unnamed_lte; int ret; + const struct wim_inode *inode = dentry->d_inode; /* First extract the unnamed stream. */ unnamed_lte = inode_unnamed_lte_resolved(inode); - ret = win32_extract_stream(inode, path, NULL, unnamed_lte, args); + ret = win32_extract_stream(dentry, path, NULL, unnamed_lte, args); if (ret) goto out; @@ -2323,7 +2336,7 @@ win32_extract_streams(const struct wim_inode *inode, continue; /* Extract the named stream */ - ret = win32_extract_stream(inode, + ret = win32_extract_stream(dentry, path, ads_entry->stream_name, ads_entry->lte, @@ -2470,7 +2483,7 @@ win32_do_apply_dentry(const wchar_t *output_path, } else { /* Create the file, directory, or reparse point, and extract the * data streams. */ - ret = win32_extract_streams(inode, output_path, args); + ret = win32_extract_streams(dentry, output_path, args); if (ret) return ret; }