X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwin32.c;h=aec728fe17e4f319b6ee50daf945a5f137f588d8;hp=a591dd6012f0b7cbd077a0a3a395c60f7f9c02db;hb=db9a61d62db87df4228ad3e6f3fcef1f5a4e14bc;hpb=985a3a9191a07b8def58315afa5a88e71cf9f1d4 diff --git a/src/win32.c b/src/win32.c index a591dd60..aec728fe 100644 --- a/src/win32.c +++ b/src/win32.c @@ -307,6 +307,7 @@ read_win32_encrypted_file_prefix(const struct wim_lookup_table_entry *lte, } else { export_ctx.buf = NULL; } + export_ctx.buf_filled = 0; export_ctx.bytes_remaining = size; err = OpenEncryptedFileRawW(lte->file_on_disk, 0, &file_ctx); @@ -598,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; } @@ -659,62 +662,31 @@ 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) */ - 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 */ + ret = parse_substitute_name(target, *target_nbytes_p, rptag); + if (ret < 0) return RP_NOT_FIXED; - } + stripped_chars = ret; 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) return RP_FIXED_FULLPATH; @@ -722,92 +694,89 @@ win32_maybe_rpfix_target(wchar_t *target, size_t *target_nchars_p, return RP_FIXED_ABSPATH; } -static enum rp_status -win32_try_capture_rpfix(char *rpbuf, DWORD *rpbuflen_p, +/* 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 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 { + 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 */ @@ -819,26 +788,62 @@ 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); } else { - status = RP_NOT_FIXED; + ret = RP_NOT_FIXED; } - *reparse_data_len_ret = bytesReturned; - return status; + *rpbuflen_ret = rpbuflen; + return ret; +} + +static DWORD WINAPI +win32_tally_encrypted_size_cb(unsigned char *_data, void *_ctx, + unsigned long len) +{ + *(u64*)_ctx += len; + return ERROR_SUCCESS; +} + +static int +win32_get_encrypted_file_size(const wchar_t *path, u64 *size_ret) +{ + DWORD err; + void *file_ctx; + int ret; + + *size_ret = 0; + err = OpenEncryptedFileRawW(path, 0, &file_ctx); + if (err != ERROR_SUCCESS) { + ERROR("Failed to open encrypted file \"%ls\" for raw read", path); + win32_error(err); + return WIMLIB_ERR_OPEN; + } + err = ReadEncryptedFileRaw(win32_tally_encrypted_size_cb, + size_ret, file_ctx); + if (err != ERROR_SUCCESS) { + ERROR("Failed to read raw encrypted data from \"%ls\"", path); + win32_error(err); + ret = WIMLIB_ERR_READ; + } else { + ret = 0; + } + CloseEncryptedFileRaw(file_ctx); + return ret; } /* Scans an unnamed or named stream of a Win32 file (not a reparse point @@ -954,11 +959,17 @@ win32_capture_stream(const wchar_t *path, } lte->file_on_disk = spath; spath = NULL; - if (inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED && !is_named_stream) + if (inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED && !is_named_stream) { + u64 encrypted_size; lte->resource_location = RESOURCE_WIN32_ENCRYPTED; - else + ret = win32_get_encrypted_file_size(path, &encrypted_size); + if (ret) + goto out_free_spath; + lte->resource_entry.original_size = encrypted_size; + } else { lte->resource_location = RESOURCE_WIN32; - lte->resource_entry.original_size = (u64)dat->StreamSize.QuadPart; + lte->resource_entry.original_size = (u64)dat->StreamSize.QuadPart; + } u32 stream_id; if (is_named_stream) { @@ -1034,10 +1045,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); @@ -1098,8 +1109,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)) { @@ -1150,9 +1161,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; @@ -1214,6 +1225,8 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret, file_size = ((u64)file_info.nFileSizeHigh << 32) | (u64)file_info.nFileSizeLow; + CloseHandle(hFile); + /* Capture the unnamed data stream (only should be present for regular * files) and any alternate data streams. */ ret = win32_capture_streams(path, @@ -1223,15 +1236,14 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret, file_size, vol_flags); if (ret) - goto out_close_handle; + goto out; if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) { /* 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 */ @@ -1242,6 +1254,7 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret, state, vol_flags); } + goto out; out_close_handle: CloseHandle(hFile); out: @@ -1330,36 +1343,121 @@ win32_build_dentry_tree(struct wim_dentry **root_ret, } static int -win32_set_reparse_data(HANDLE h, - u32 reparse_tag, - const struct wim_lookup_table_entry *lte, - const wchar_t *path) +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; - u8 *buf; - size_t len; - if (!lte) { - WARNING("\"%ls\" is marked as a reparse point but had no reparse data", - path); - return 0; + 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; } - len = wim_resource_size(lte); - if (len > 16 * 1024 - 8) { - WARNING("\"%ls\": reparse data too long!", path); + + 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 (target_nchars - stripped_target_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, + const struct wim_inode *inode, + const struct wim_lookup_table_entry *lte, + const wchar_t *path, + const struct apply_args *args) +{ + int ret; + u8 rpbuf[REPARSE_POINT_MAX_SIZE]; + DWORD bytesReturned; + + 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. @@ -1382,8 +1480,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 */)) @@ -1393,8 +1491,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; @@ -1402,10 +1500,12 @@ win32_set_reparse_data(HANDLE h, return 0; } +/* Wrapper around the FSCTL_SET_COMPRESSION ioctl to change the + * FILE_ATTRIBUTE_COMPRESSED flag of a file or directory. */ static int win32_set_compression_state(HANDLE hFile, USHORT format, const wchar_t *path) { - DWORD bytesReturned = 0; + DWORD bytesReturned; if (!DeviceIoControl(hFile, FSCTL_SET_COMPRESSION, &format, sizeof(USHORT), NULL, 0, @@ -1424,10 +1524,11 @@ win32_set_compression_state(HANDLE hFile, USHORT format, const wchar_t *path) return 0; } +/* Wrapper around FSCTL_SET_SPARSE ioctl to set a file as sparse. */ static int win32_set_sparse(HANDLE hFile, const wchar_t *path) { - DWORD bytesReturned = 0; + DWORD bytesReturned; if (!DeviceIoControl(hFile, FSCTL_SET_SPARSE, NULL, 0, NULL, 0, @@ -1577,18 +1678,189 @@ win32_extract_chunk(const void *buf, size_t len, void *arg) } static int -do_win32_extract_stream(HANDLE hStream, struct wim_lookup_table_entry *lte) +do_win32_extract_stream(HANDLE hStream, const struct wim_lookup_table_entry *lte) { return extract_wim_resource(lte, wim_resource_size(lte), win32_extract_chunk, hStream); } +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; +}; + +static DWORD WINAPI +win32_encrypted_import_cb(unsigned char *data, void *_ctx, + unsigned long *len_p) +{ + struct win32_encrypted_extract_ctx *ctx = _ctx; + unsigned long len = *len_p; + + pthread_mutex_lock(&ctx->mutex); + while (len) { + size_t bytes_to_copy; + + 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; +} + +/* 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; +} + +/* Create an encrypted file and extract the raw encrypted data to it. + * + * @path: Path to encrypted file to create. + * @lte: WIM lookup_table entry for the raw encrypted data. + * + * This is separate from do_win32_extract_stream() because the WIM is supposed + * to contain the *raw* encrypted data, which needs to be extracted ("imported") + * using the special APIs OpenEncryptedFileRawW(), WriteEncryptedFileRaw(), and + * CloseEncryptedFileRaw(). + * + * Returns 0 on success; nonzero on failure. + */ static int do_win32_extract_encrypted_stream(const wchar_t *path, const struct wim_lookup_table_entry *lte) { - ERROR("Extracting encryted streams not implemented"); - return WIMLIB_ERR_INVALID_PARAM; + 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); + + ret = OpenEncryptedFileRawW(path, CREATE_FOR_IMPORT, &file_ctx); + if (ret) { + ERROR("Failed to open \"%ls\" to write raw encrypted data", path); + win32_error(ret); + 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) + ret = WIMLIB_ERR_WRITE; + } + 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; } static bool @@ -1608,11 +1880,27 @@ path_is_root_of_drive(const wchar_t *path) return (*path == L'\0'); } -static DWORD -win32_get_create_flags_and_attributes(DWORD i_attributes) +static inline DWORD +win32_mask_attributes(DWORD i_attributes) { - DWORD attributes; + return i_attributes & ~(FILE_ATTRIBUTE_SPARSE_FILE | + FILE_ATTRIBUTE_COMPRESSED | + FILE_ATTRIBUTE_REPARSE_POINT | + FILE_ATTRIBUTE_DIRECTORY | + FILE_ATTRIBUTE_ENCRYPTED | + FILE_FLAG_DELETE_ON_CLOSE | + FILE_FLAG_NO_BUFFERING | + FILE_FLAG_OPEN_NO_RECALL | + FILE_FLAG_OVERLAPPED | + FILE_FLAG_RANDOM_ACCESS | + /*FILE_FLAG_SESSION_AWARE |*/ + FILE_FLAG_SEQUENTIAL_SCAN | + FILE_FLAG_WRITE_THROUGH); +} +static inline DWORD +win32_get_create_flags_and_attributes(DWORD i_attributes) +{ /* * Some attributes cannot be set by passing them to CreateFile(). In * particular: @@ -1637,52 +1925,31 @@ win32_get_create_flags_and_attributes(DWORD i_attributes) * want, but also specify FILE_FLAG_OPEN_REPARSE_POINT and * FILE_FLAG_BACKUP_SEMANTICS as we are a backup application. */ - attributes = i_attributes & ~(FILE_ATTRIBUTE_SPARSE_FILE | - FILE_ATTRIBUTE_COMPRESSED | - FILE_ATTRIBUTE_REPARSE_POINT | - FILE_ATTRIBUTE_DIRECTORY | - FILE_FLAG_DELETE_ON_CLOSE | - FILE_FLAG_NO_BUFFERING | - FILE_FLAG_OPEN_NO_RECALL | - FILE_FLAG_OVERLAPPED | - FILE_FLAG_RANDOM_ACCESS | - /*FILE_FLAG_SESSION_AWARE |*/ - FILE_FLAG_SEQUENTIAL_SCAN | - FILE_FLAG_WRITE_THROUGH); - return attributes | - FILE_FLAG_OPEN_REPARSE_POINT | - FILE_FLAG_BACKUP_SEMANTICS; + return win32_mask_attributes(i_attributes) | + FILE_FLAG_OPEN_REPARSE_POINT | + FILE_FLAG_BACKUP_SEMANTICS; } -/* Set compression or sparse attributes, and reparse data, if supported by the +/* Set compression and/or sparse attributes on a stream, if supported by the * volume. */ static int -win32_set_special_attributes(HANDLE hFile, const struct wim_inode *inode, - struct wim_lookup_table_entry *unnamed_stream_lte, - const wchar_t *path, unsigned vol_flags) +win32_set_special_stream_attributes(HANDLE hFile, const struct wim_inode *inode, + struct wim_lookup_table_entry *unnamed_stream_lte, + const wchar_t *path, unsigned vol_flags) { int ret; - /* Encrypted files cannot be [de]compressed. */ - if (!(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED)) { + if (inode->i_attributes & FILE_ATTRIBUTE_COMPRESSED) { if (vol_flags & FILE_FILE_COMPRESSION) { - USHORT format; - if (inode->i_attributes & FILE_ATTRIBUTE_COMPRESSED) { - format = COMPRESSION_FORMAT_DEFAULT; - DEBUG("Setting compression flag on \"%ls\"", path); - } else { - format = COMPRESSION_FORMAT_NONE; - DEBUG("Clearing compression flag on \"%ls\"", path); - } - ret = win32_set_compression_state(hFile, format, path); + ret = win32_set_compression_state(hFile, + COMPRESSION_FORMAT_DEFAULT, + path); if (ret) return ret; } else { - if (inode->i_attributes & FILE_ATTRIBUTE_COMPRESSED) { - DEBUG("Cannot set compression attribute on \"%ls\": " - "volume does not support transparent compression", - path); - } + DEBUG("Cannot set compression attribute on \"%ls\": " + "volume does not support transparent compression", + path); } } @@ -1698,22 +1965,196 @@ win32_set_special_attributes(HANDLE hFile, const struct wim_inode *inode, path); } } + return 0; +} - if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) { - if (vol_flags & FILE_SUPPORTS_REPARSE_POINTS) { - DEBUG("Setting reparse data on \"%ls\"", path); - ret = win32_set_reparse_data(hFile, inode->i_reparse_tag, - unnamed_stream_lte, path); +/* Pre-create directories; extract encrypted streams */ +static int +win32_begin_extract_unnamed_stream(const struct wim_inode *inode, + const struct wim_lookup_table_entry *lte, + const wchar_t *path, + DWORD *creationDisposition_ret, + unsigned int vol_flags) +{ + DWORD err; + int ret; + + /* 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 && + !path_is_root_of_drive(path)) { + if (!CreateDirectoryW(path, NULL)) { + err = GetLastError(); + if (err != ERROR_ALREADY_EXISTS) { + ERROR("Failed to create directory \"%ls\"", + path); + win32_error(err); + return WIMLIB_ERR_MKDIR; + } + } + DEBUG("Created directory \"%ls\"", path); + *creationDisposition_ret = OPEN_EXISTING; + } + if (inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED && + 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; + } + } else { + ret = do_win32_extract_encrypted_stream(path, lte); if (ret) return ret; - } else { - DEBUG("Cannot set reparse data on \"%ls\": volume " - "does not support reparse points", path); + DEBUG("Extracted encrypted file \"%ls\"", path); + } + *creationDisposition_ret = OPEN_EXISTING; + } + + /* Set file attributes if we created the file. Otherwise, we haven't + * created the file set and we will set the attributes in the call to + * CreateFileW(). + * + * The FAT filesystem does not let you change the attributes of the root + * directory, so treat that as a special case and do not set attributes. + * */ + if (*creationDisposition_ret == OPEN_EXISTING && + !path_is_root_of_drive(path)) + { + if (!SetFileAttributesW(path, + win32_mask_attributes(inode->i_attributes))) + { + err = GetLastError(); + ERROR("Failed to set attributes on \"%ls\"", path); + win32_error(err); + return WIMLIB_ERR_WRITE; } } return 0; } +/* 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, + 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; + if (stream_name_utf16 == NULL) { + /* Unnamed stream. */ + + /* Set security descriptor, unless the extract_flags indicate + * not to or the volume does not supported it. Note that this + * is only done when the unnamed stream is being extracted, as + * security descriptors are per-file and not per-stream. */ + if (inode->i_security_id >= 0 && + !(args->extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS) + && (args->vol_flags & FILE_PERSISTENT_ACLS)) + { + ret = win32_set_security_data(inode, h, stream_path, args); + if (ret) + return ret; + } + + /* Handle reparse points. The data for them needs to be set + * using a special ioctl. Note that the reparse point may have + * been created using CreateFileW() in the case of + * non-directories or CreateDirectoryW() in the case of + * directories; but the ioctl works either way. Also, it is + * only this step that actually sets the + * FILE_ATTRIBUTE_REPARSE_POINT, as it is not valid to set it + * using SetFileAttributesW() or CreateFileW(). + * + * If the volume does not support reparse points we simply + * ignore the reparse data. (N.B. the code currently doesn't + * actually reach this case because reparse points are skipped + * entirely on such volumes.) */ + if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) { + if (args->vol_flags & FILE_SUPPORTS_REPARSE_POINTS) { + ret = win32_set_reparse_data(h, inode, + lte, stream_path, + args); + if (ret) + return ret; + } else { + DEBUG("Cannot set reparse data on \"%ls\": volume " + "does not support reparse points", stream_path); + } + } else if (lte != NULL && + !(args->vol_flags & FILE_SUPPORTS_ENCRYPTION && + inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED)) + { + /* Extract the data of the unnamed stream, unless the + * lookup table entry is NULL (indicating an empty + * stream for which no data needs to be extracted), or + * the stream is encrypted and therefore was already + * extracted as a special case. */ + ret = do_win32_extract_stream(h, lte); + } + } else { + /* Extract the data for a named data stream. */ + if (lte != NULL) { + DEBUG("Extracting named data stream \"%ls\" (len = %"PRIu64")", + stream_path, wim_resource_size(lte)); + ret = do_win32_extract_stream(h, lte); + } + } + return ret; +} + +static int +win32_decrypt_file(HANDLE open_handle, const wchar_t *path) +{ + DWORD err; + /* We cannot call DecryptFileW() while there is an open handle to the + * file. So close it first. */ + if (!CloseHandle(open_handle)) { + err = GetLastError(); + ERROR("Failed to close handle for \"%ls\"", path); + win32_error(err); + return WIMLIB_ERR_WRITE; + } + if (!DecryptFileW(path, 0 /* reserved parameter; set to 0 */)) { + err = GetLastError(); + ERROR("Failed to decrypt file \"%ls\"", path); + win32_error(err); + return WIMLIB_ERR_WRITE; + } + return 0; +} + +/* + * Create and extract a stream to a file, or create a directory, using the + * Windows API. + * + * This handles reparse points, directories, alternate data streams, encrypted + * files, compressed files, etc. + * + * @inode: WIM inode containing the stream. + * + * @path: Path to extract the file to. + * + * @stream_name_utf16: + * Name of the stream, or NULL if the stream is unnamed. This will + * be called with a NULL stream_name_utf16 before any non-NULL + * stream_name_utf16's. + * + * @lte: WIM lookup table entry for the stream. May be NULL to indicate + * a stream of length 0. + * + * @args: Additional apply context, including flags indicating supported + * volume features. + * + * Returns 0 on success; nonzero on failure. + */ static int win32_extract_stream(const struct wim_inode *inode, const wchar_t *path, @@ -1727,6 +2168,7 @@ win32_extract_stream(const struct wim_inode *inode, DWORD err; DWORD creationDisposition = CREATE_ALWAYS; DWORD requestedAccess; + BY_HANDLE_FILE_INFORMATION file_info; if (stream_name_utf16) { /* Named stream. Create a buffer that contains the UTF-16LE @@ -1762,36 +2204,21 @@ win32_extract_stream(const struct wim_inode *inode, * */ stream_path = (wchar_t*)path; - /* 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 (!CreateDirectoryW(stream_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: - ERROR("Failed to create directory \"%ls\"", - stream_path); - win32_error(err); - ret = WIMLIB_ERR_MKDIR; - goto fail; - } - } - DEBUG("Created directory \"%ls\"", stream_path); - creationDisposition = OPEN_EXISTING; - } + ret = win32_begin_extract_unnamed_stream(inode, lte, path, + &creationDisposition, + args->vol_flags); + if (ret) + goto fail; } DEBUG("Opening \"%ls\"", stream_path); requestedAccess = GENERIC_READ | GENERIC_WRITE | ACCESS_SYSTEM_SECURITY; try_open_again: + /* Open the stream to be extracted. Depending on what we have set + * creationDisposition to, we may be creating this for the first time, + * or we may be opening on existing stream we already created using + * CreateDirectoryW() or OpenEncryptedFileRawW(). */ h = CreateFileW(stream_path, requestedAccess, 0, @@ -1801,9 +2228,18 @@ try_open_again: 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 + * modify SACL. */ requestedAccess &= ~ACCESS_SYSTEM_SECURITY; goto try_open_again; } @@ -1813,40 +2249,66 @@ try_open_again: goto fail; } - if (stream_name_utf16 == NULL) { - if (inode->i_security_id >= 0 && - !(args->extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS) - && (args->vol_flags & FILE_PERSISTENT_ACLS)) - { - ret = win32_set_security_data(inode, h, path, args); - if (ret) - goto fail_close_handle; - } + /* Check the attributes of the file we just opened, and remove + * encryption or compression if either was set by default but is not + * supposed to be set based on the WIM inode attributes. */ + if (!GetFileInformationByHandle(h, &file_info)) { + err = GetLastError(); + ERROR("Failed to get attributes of \"%ls\"", stream_path); + win32_error(err); + ret = WIMLIB_ERR_STAT; + goto fail_close_handle; + } - ret = win32_set_special_attributes(h, inode, lte, path, - args->vol_flags); + /* Remove encryption? */ + if (file_info.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED && + !(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED)) + { + /* File defaulted to encrypted due to being in an encrypted + * directory, but is not actually supposed to be encrypted. + * + * This is a workaround, because I'm not aware of any way to + * directly (e.g. with CreateFileW()) create an unencrypted file + * in a directory with FILE_ATTRIBUTE_ENCRYPTED set. */ + ret = win32_decrypt_file(h, stream_path); if (ret) - goto fail_close_handle; + goto fail; /* win32_decrypt_file() closed the handle. */ + creationDisposition = OPEN_EXISTING; + goto try_open_again; } - if (!(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT)) { - if (lte) { - DEBUG("Extracting \"%ls\" (len = %"PRIu64")", - stream_path, wim_resource_size(lte)); - if (inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED - && stream_name_utf16 == NULL - && (args->vol_flags & FILE_SUPPORTS_ENCRYPTION)) - { - ret = do_win32_extract_encrypted_stream(stream_path, - lte); - } else { - ret = do_win32_extract_stream(h, lte); - } - if (ret) - goto fail_close_handle; - } + /* Remove compression? */ + if (file_info.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED && + !(inode->i_attributes & FILE_ATTRIBUTE_COMPRESSED)) + { + /* Similar to the encrypted case, above, if the file defaulted + * to compressed due to being in an compressed directory, but is + * not actually supposed to be compressed, explicitly set the + * compression format to COMPRESSION_FORMAT_NONE. */ + ret = win32_set_compression_state(h, COMPRESSION_FORMAT_NONE, + stream_path); + if (ret) + goto fail_close_handle; } + /* Set compression and/or sparse attributes if needed */ + ret = win32_set_special_stream_attributes(h, inode, lte, path, + args->vol_flags); + + if (ret) + goto fail_close_handle; + + /* At this point we have at least created the needed stream with the + * appropriate attributes. We have yet to set the appropriate security + * 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, + stream_name_utf16, args); + if (ret) + goto fail_close_handle; + + /* Done extracting the stream. Close the handle and return. */ DEBUG("Closing \"%ls\"", stream_path); if (!CloseHandle(h)) { err = GetLastError(); @@ -1860,7 +2322,7 @@ try_open_again: fail_close_handle: CloseHandle(h); fail: - ERROR("Error extracting %ls", stream_path); + ERROR("Error extracting \"%ls\"", stream_path); out: return ret; } @@ -1868,7 +2330,7 @@ out: /* * Creates a file, directory, or reparse point and extracts all streams to it * (unnamed data stream and/or reparse point stream, plus any alternate data - * streams). + * streams). Handles sparse, compressed, and/or encrypted files. * * @inode: WIM inode for this file or directory. * @path: UTF-16LE external path to extract the inode to. @@ -1883,17 +2345,12 @@ win32_extract_streams(const struct wim_inode *inode, struct wim_lookup_table_entry *unnamed_lte; int ret; - /* Extract the unnamed stream. */ + /* First extract the unnamed stream. */ unnamed_lte = inode_unnamed_lte_resolved(inode); ret = win32_extract_stream(inode, path, NULL, unnamed_lte, args); if (ret) goto out; - if (unnamed_lte && inode->i_extracted_file == NULL) - { - args->progress.extract.completed_bytes += - wim_resource_size(unnamed_lte); - } /* Extract any named streams, if supported by the volume. */ @@ -1923,20 +2380,14 @@ win32_extract_streams(const struct wim_inode *inode, args); if (ret) break; - - /* Tally the bytes extracted, unless this was supposed to be a - * hard link and we are extracting the data again only as a - * fallback. */ - if (ads_entry->lte && inode->i_extracted_file == NULL) - { - args->progress.extract.completed_bytes += - wim_resource_size(ads_entry->lte); - } } out: return ret; } +/* If not done already, load the supported feature flags for the volume onto + * which the image is being extracted, and warn the user about any missing + * features that could be important. */ static int win32_check_vol_flags(const wchar_t *output_path, struct apply_args *args) { @@ -1977,6 +2428,26 @@ win32_check_vol_flags(const wchar_t *output_path, struct apply_args *args) return 0; } +/* + * Try extracting a hard link. + * + * @output_path: Path to link to be extracted. + * + * @inode: WIM inode that the link is to; inode->i_extracted_file + * the path to a name of the file that has already been + * extracted (we use this to create the hard link). + * + * @args: Additional apply context, used here to keep track of + * the number of times creating a hard link failed due to + * ERROR_INVALID_FUNCTION. This error should indicate that hard + * links are not supported by the volume, and we would like to + * warn the user a few times, but not too many times. + * + * Returns 0 if the hard link was successfully extracted. Returns + * WIMLIB_ERR_LINK (> 0) if an error occurred, other than hard links possibly + * being unsupported by the volume. Returns a negative value if creating the + * hard link failed due to ERROR_INVALID_FUNCTION. + */ static int win32_try_hard_link(const wchar_t *output_path, const struct wim_inode *inode, struct apply_args *args) @@ -2033,37 +2504,48 @@ win32_do_apply_dentry(const wchar_t *output_path, ret = win32_try_hard_link(output_path, inode, args); if (ret >= 0) return ret; - /* Falling back to extracting copy of file */ + /* Negative return value from win32_try_hard_link() indicates + * that hard links are probably not supported by the volume. + * Fall back to extracting a copy of the file. */ } + /* If this is a reparse point and the volume does not support reparse + * points, just skip it completely. */ if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT && !(args->vol_flags & FILE_SUPPORTS_REPARSE_POINTS)) { WARNING("Skipping extraction of reparse point \"%ls\":\n" " Not supported by destination filesystem", output_path); - struct wim_lookup_table_entry *lte; - lte = inode_unnamed_lte_resolved(inode); - if (lte) - args->progress.extract.completed_bytes += wim_resource_size(lte); - return 0; + } else { + /* Create the file, directory, or reparse point, and extract the + * data streams. */ + ret = win32_extract_streams(inode, output_path, args); + if (ret) + return ret; } - - /* Create the file, directory, or reparse point, and extract the - * data streams. */ - ret = win32_extract_streams(inode, output_path, args); - if (ret) - return ret; - - if (inode->i_nlink > 1) { - /* Save extracted path for a later call to - * CreateHardLinkW() if this inode has multiple links. - * */ - inode->i_extracted_file = WSTRDUP(output_path); - if (!inode->i_extracted_file) - ret = WIMLIB_ERR_NOMEM; + if (inode->i_extracted_file == NULL) { + const struct wim_lookup_table_entry *lte; + + /* Tally bytes extracted, including all alternate data streams, + * unless we extracted a hard link (or, at least extracted a + * name that was supposed to be a hard link) */ + for (unsigned i = 0; i <= inode->i_num_ads; i++) { + lte = inode_stream_lte_resolved(inode, i); + if (lte) + args->progress.extract.completed_bytes += + wim_resource_size(lte); + } + if (inode->i_nlink > 1) { + /* Save extracted path for a later call to + * CreateHardLinkW() if this inode has multiple links. + * */ + inode->i_extracted_file = WSTRDUP(output_path); + if (!inode->i_extracted_file) + return WIMLIB_ERR_NOMEM; + } } - return ret; + return 0; } /* Set timestamps on an extracted file using the Win32 API */