+ return ret;
+out_invalid_stream_name:
+ ERROR("Invalid stream name: \"%ls:%ls\"", path, dat->cStreamName);
+ ret = WIMLIB_ERR_READ;
+ goto out;
+}
+
+/* Scans a Win32 file for unnamed and named data streams (not reparse point
+ * streams).
+ *
+ * @path: Path to the file (UTF-16LE).
+ *
+ * @path_num_chars: Number of 2-byte characters in @path.
+ *
+ * @inode: WIM inode to save the stream into.
+ *
+ * @lookup_table: Stream lookup table for the WIM.
+ *
+ * @file_size: Size of unnamed data stream. (Used only if alternate
+ * data streams API appears to be unavailable.)
+ *
+ * @vol_flags: Flags that specify features of the volume being
+ * captured.
+ *
+ * Returns 0 on success; nonzero on failure.
+ */
+static int
+win32_capture_streams(const wchar_t *path,
+ size_t path_num_chars,
+ struct wim_inode *inode,
+ struct wim_lookup_table *lookup_table,
+ u64 file_size,
+ unsigned vol_flags)
+{
+ WIN32_FIND_STREAM_DATA dat;
+ int ret;
+ HANDLE hFind;
+ DWORD err;
+
+ DEBUG("Capturing streams from \"%ls\"", path);
+
+ if (win32func_FindFirstStreamW == NULL ||
+ !(vol_flags & FILE_NAMED_STREAMS))
+ goto unnamed_only;
+
+ hFind = win32func_FindFirstStreamW(path, FindStreamInfoStandard, &dat, 0);
+ if (hFind == INVALID_HANDLE_VALUE) {
+ err = GetLastError();
+ if (err == ERROR_CALL_NOT_IMPLEMENTED)
+ goto unnamed_only;
+
+ /* Seems legal for this to return ERROR_HANDLE_EOF on reparse
+ * points and directories */
+ if ((inode->i_attributes &
+ (FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_DIRECTORY))
+ && err == ERROR_HANDLE_EOF)
+ {
+ DEBUG("ERROR_HANDLE_EOF (ok)");
+ 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;
+ } else {
+ ERROR("Failed to look up data streams "
+ "of \"%ls\"", path);
+ win32_error(err);
+ return WIMLIB_ERR_READ;
+ }
+ }
+ }
+ do {
+ ret = win32_capture_stream(path,
+ path_num_chars,
+ inode, lookup_table,
+ &dat);
+ if (ret)
+ goto out_find_close;
+ } while (win32func_FindNextStreamW(hFind, &dat));
+ err = GetLastError();
+ if (err != ERROR_HANDLE_EOF) {
+ ERROR("Win32 API: Error reading data streams from \"%ls\"", path);
+ win32_error(err);
+ ret = WIMLIB_ERR_READ;
+ }
+out_find_close:
+ FindClose(hFind);
+ return ret;
+unnamed_only:
+ /* FindFirstStreamW() API is not available, or the volume does not
+ * support named streams. Only capture the unnamed data stream. */
+ DEBUG("Only capturing unnamed data stream");
+ if (inode->i_attributes &
+ (FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_DIRECTORY))
+ {
+ ret = 0;
+ } else {
+ /* Just create our own WIN32_FIND_STREAM_DATA for an unnamed
+ * stream to reduce the code to a call to the
+ * already-implemented win32_capture_stream() */
+ wcscpy(dat.cStreamName, L"::$DATA");
+ dat.StreamSize.QuadPart = file_size;
+ ret = win32_capture_stream(path,
+ path_num_chars,
+ inode, lookup_table,
+ &dat);
+ }
+ return ret;
+}
+
+static int
+win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
+ wchar_t *path,
+ size_t path_num_chars,
+ struct add_image_params *params,
+ struct win32_capture_state *state,
+ unsigned vol_flags)
+{
+ struct wim_dentry *root = NULL;
+ struct wim_inode *inode;
+ DWORD err;
+ u64 file_size;
+ int ret;
+ void *reparse_data;
+ size_t reparse_data_len;
+ u16 not_rpfixed;
+
+ if (exclude_path(path, path_num_chars, params->config, true)) {
+ if (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT) {
+ ERROR("Cannot exclude the root directory from capture");
+ ret = WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
+ goto out;
+ }
+ if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE)
+ && params->progress_func)
+ {
+ union wimlib_progress_info info;
+ info.scan.cur_path = path;
+ info.scan.excluded = true;
+ params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
+ }
+ ret = 0;
+ goto out;
+ }
+
+ if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE)
+ && params->progress_func)
+ {
+ union wimlib_progress_info info;
+ info.scan.cur_path = path;
+ info.scan.excluded = false;
+ params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
+ }
+
+ HANDLE hFile = win32_open_existing_file(path,
+ FILE_READ_DATA | FILE_READ_ATTRIBUTES);
+ if (hFile == INVALID_HANDLE_VALUE) {
+ err = GetLastError();
+ ERROR("Win32 API: Failed to open \"%ls\"", path);
+ win32_error(err);
+ ret = WIMLIB_ERR_OPEN;
+ goto out;
+ }
+
+ BY_HANDLE_FILE_INFORMATION file_info;
+ if (!GetFileInformationByHandle(hFile, &file_info)) {
+ err = GetLastError();
+ ERROR("Win32 API: Failed to get file information for \"%ls\"",
+ path);
+ win32_error(err);
+ ret = WIMLIB_ERR_STAT;
+ goto out_close_handle;
+ }
+
+ if (file_info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+ reparse_data = alloca(REPARSE_POINT_MAX_SIZE);
+ ret = win32_get_reparse_data(hFile, path, params,
+ reparse_data, &reparse_data_len);
+ if (ret < 0) {
+ /* WIMLIB_ERR_* (inverted) */
+ ret = -ret;
+ goto out_close_handle;
+ } else if (ret & RP_FIXED) {
+ not_rpfixed = 0;
+ } else if (ret == RP_EXCLUDED) {
+ ret = 0;
+ goto out_close_handle;
+ } else {
+ not_rpfixed = 1;
+ }
+ }
+
+ /* Create a WIM dentry with an associated inode, which may be shared.
+ *
+ * However, we need to explicitly check for directories and files with
+ * only 1 link and refuse to hard link them. This is because Windows
+ * has a bug where it can return duplicate File IDs for files and
+ * directories on the FAT filesystem. */
+ ret = inode_table_new_dentry(params->inode_table,
+ path_basename_with_len(path, path_num_chars),
+ ((u64)file_info.nFileIndexHigh << 32) |
+ (u64)file_info.nFileIndexLow,
+ file_info.dwVolumeSerialNumber,
+ (file_info.nNumberOfLinks <= 1 ||
+ (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)),
+ &root);
+ if (ret)
+ goto out_close_handle;
+
+ ret = win32_get_short_name(root, path);
+ if (ret)
+ goto out_close_handle;
+
+ inode = root->d_inode;
+
+ if (inode->i_nlink > 1) /* Shared inode; nothing more to do */
+ goto out_close_handle;
+
+ inode->i_attributes = file_info.dwFileAttributes;
+ inode->i_creation_time = FILETIME_to_u64(&file_info.ftCreationTime);
+ inode->i_last_write_time = FILETIME_to_u64(&file_info.ftLastWriteTime);
+ inode->i_last_access_time = FILETIME_to_u64(&file_info.ftLastAccessTime);
+ inode->i_resolved = 1;
+
+ params->add_image_flags &= ~(WIMLIB_ADD_IMAGE_FLAG_ROOT | WIMLIB_ADD_IMAGE_FLAG_SOURCE);
+
+ if (!(params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS)
+ && (vol_flags & FILE_PERSISTENT_ACLS))
+ {
+ ret = win32_get_security_descriptor(root, params->sd_set,
+ path, state,
+ params->add_image_flags);
+ if (ret)
+ goto out_close_handle;
+ }
+
+ file_size = ((u64)file_info.nFileSizeHigh << 32) |
+ (u64)file_info.nFileSizeLow;
+
+ /* Capture the unnamed data stream (only should be present for regular
+ * files) and any alternate data streams. */
+ ret = win32_capture_streams(path,
+ path_num_chars,
+ inode,
+ params->lookup_table,
+ file_size,
+ vol_flags);
+ if (ret)
+ goto out_close_handle;
+
+ 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,
+ params->lookup_table);
+ } else if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) {
+ /* Directory (not a reparse point) --- recurse to children */
+ ret = win32_recurse_directory(root,
+ path,
+ path_num_chars,
+ params,
+ state,
+ vol_flags);
+ }
+out_close_handle:
+ CloseHandle(hFile);
+out:
+ if (ret == 0)
+ *root_ret = root;
+ else
+ free_dentry_tree(root, params->lookup_table);
+ return ret;
+}
+
+static void
+win32_do_capture_warnings(const struct win32_capture_state *state,
+ int add_image_flags)
+{
+ if (state->num_get_sacl_priv_notheld == 0 &&
+ state->num_get_sd_access_denied == 0)
+ return;
+
+ WARNING("");
+ WARNING("Built dentry tree successfully, but with the following problem(s):");
+ if (state->num_get_sacl_priv_notheld != 0) {
+ WARNING("Could not capture SACL (System Access Control List)\n"
+ " on %lu files or directories.",
+ state->num_get_sacl_priv_notheld);
+ }
+ if (state->num_get_sd_access_denied != 0) {
+ WARNING("Could not capture security descriptor at all\n"
+ " on %lu files or directories.",
+ state->num_get_sd_access_denied);
+ }
+ WARNING(
+ "Try running the program as the Administrator to make sure all the\n"
+" desired metadata has been captured exactly. However, if you\n"
+" do not care about capturing security descriptors correctly, then\n"
+" nothing more needs to be done%ls\n",
+ (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS) ? L"." :
+ L", although you might consider\n"
+" passing the --no-acls flag to `wimlib-imagex capture' or\n"
+" `wimlib-imagex append' to explicitly capture no security\n"
+" descriptors.\n");
+}
+
+/* Win32 version of capturing a directory tree */
+int
+win32_build_dentry_tree(struct wim_dentry **root_ret,
+ const wchar_t *root_disk_path,
+ struct add_image_params *params)
+{
+ size_t path_nchars;
+ wchar_t *path;
+ int ret;
+ struct win32_capture_state state;
+ unsigned vol_flags;
+
+
+ path_nchars = wcslen(root_disk_path);
+ if (path_nchars > 32767)
+ return WIMLIB_ERR_INVALID_PARAM;
+
+ ret = win32_get_file_and_vol_ids(root_disk_path,
+ ¶ms->capture_root_ino,
+ ¶ms->capture_root_dev);
+ if (ret)
+ return ret;
+
+ win32_get_vol_flags(root_disk_path, &vol_flags);
+
+ /* There is no check for overflow later when this buffer is being used!
+ * But the max path length on NTFS is 32767 characters, and paths need
+ * to be written specially to even go past 260 characters, so we should
+ * be okay with 32770 characters. */
+ path = MALLOC(32770 * sizeof(wchar_t));
+ if (!path)
+ return WIMLIB_ERR_NOMEM;
+
+ wmemcpy(path, root_disk_path, path_nchars + 1);
+
+ memset(&state, 0, sizeof(state));
+ ret = win32_build_dentry_tree_recursive(root_ret, path,
+ path_nchars, params,
+ &state, vol_flags);
+ FREE(path);
+ if (ret == 0)
+ win32_do_capture_warnings(&state, params->add_image_flags);
+ return ret;
+}
+
+static int
+win32_set_reparse_data(HANDLE h,
+ u32 reparse_tag,
+ const struct wim_lookup_table_entry *lte,
+ const wchar_t *path)
+{
+ 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;
+ }
+ len = wim_resource_size(lte);
+ if (len > 16 * 1024 - 8) {
+ WARNING("\"%ls\": reparse data too long!", path);
+ return 0;
+ }
+
+ /* 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);
+ if (ret)
+ return ret;
+ *(u32*)(buf + 0) = cpu_to_le32(reparse_tag);
+ *(u16*)(buf + 4) = cpu_to_le16(len);
+ *(u16*)(buf + 6) = 0;
+
+ /* Set the reparse data on the open file using the
+ * FSCTL_SET_REPARSE_POINT ioctl.
+ *
+ * There are contradictions in Microsoft's documentation for this:
+ *
+ * "If hDevice was opened without specifying FILE_FLAG_OVERLAPPED,
+ * lpOverlapped is ignored."
+ *
+ * --- So setting lpOverlapped to NULL is okay since it's ignored.
+ *
+ * "If lpOverlapped is NULL, lpBytesReturned cannot be NULL. Even when an
+ * operation returns no output data and lpOutBuffer is NULL,
+ * DeviceIoControl makes use of lpBytesReturned. After such an
+ * operation, the value of lpBytesReturned is meaningless."
+ *
+ * --- So lpOverlapped not really ignored, as it affects another
+ * parameter. This is the actual behavior: lpBytesReturned must be
+ * specified, even though lpBytesReturned is documented as:
+ *
+ * "Not used with this operation; set to NULL."
+ */
+ DWORD bytesReturned;
+ if (!DeviceIoControl(h, FSCTL_SET_REPARSE_POINT, buf, len + 8,
+ NULL, 0,
+ &bytesReturned /* lpBytesReturned */,
+ NULL /* lpOverlapped */))
+ {
+ DWORD err = GetLastError();
+ ERROR("Failed to set reparse data on \"%ls\"", path);
+ 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)
+ return WIMLIB_ERR_LINK;
+ else
+ return WIMLIB_ERR_WRITE;
+ }
+ return 0;
+}
+
+static int
+win32_set_compression_state(HANDLE hFile, USHORT format, const wchar_t *path)
+{
+ DWORD bytesReturned = 0;
+ if (!DeviceIoControl(hFile, FSCTL_SET_COMPRESSION,
+ &format, sizeof(USHORT),
+ NULL, 0,
+ &bytesReturned, NULL))
+ {
+ /* Could be a warning only, but we only call this if the volume
+ * supports compression. So I'm calling this an error. */
+ DWORD err = GetLastError();
+ ERROR("Failed to set compression flag on \"%ls\"", path);
+ win32_error(err);
+ if (err == ERROR_ACCESS_DENIED || err == ERROR_PRIVILEGE_NOT_HELD)
+ return WIMLIB_ERR_INSUFFICIENT_PRIVILEGES_TO_EXTRACT;
+ else
+ return WIMLIB_ERR_WRITE;
+ }
+ return 0;
+}
+
+static int
+win32_set_sparse(HANDLE hFile, const wchar_t *path)
+{
+ DWORD bytesReturned = 0;
+ if (!DeviceIoControl(hFile, FSCTL_SET_SPARSE,
+ NULL, 0,
+ NULL, 0,
+ &bytesReturned, NULL))
+ {
+ /* Could be a warning only, but we only call this if the volume
+ * supports sparse files. So I'm calling this an error. */
+ DWORD err = GetLastError();
+ WARNING("Failed to set sparse flag on \"%ls\"", path);
+ win32_error(err);
+ if (err == ERROR_ACCESS_DENIED || err == ERROR_PRIVILEGE_NOT_HELD)
+ return WIMLIB_ERR_INSUFFICIENT_PRIVILEGES_TO_EXTRACT;
+ else
+ return WIMLIB_ERR_WRITE;
+ }
+ return 0;
+}
+
+/*
+ * Sets the security descriptor on an extracted file.
+ */
+static int
+win32_set_security_data(const struct wim_inode *inode,
+ HANDLE hFile,
+ const wchar_t *path,
+ struct apply_args *args)
+{
+ PSECURITY_DESCRIPTOR descriptor;
+ unsigned long n;
+ DWORD err;
+ const struct wim_security_data *sd;
+
+ SECURITY_INFORMATION securityInformation = 0;
+
+ void *owner = NULL;
+ void *group = NULL;
+ ACL *dacl = NULL;
+ ACL *sacl = NULL;
+
+ BOOL owner_defaulted;
+ BOOL group_defaulted;
+ BOOL dacl_present;
+ BOOL dacl_defaulted;
+ BOOL sacl_present;
+ BOOL sacl_defaulted;
+
+ sd = wim_const_security_data(args->w);
+ descriptor = sd->descriptors[inode->i_security_id];
+
+ GetSecurityDescriptorOwner(descriptor, &owner, &owner_defaulted);
+ if (owner)
+ securityInformation |= OWNER_SECURITY_INFORMATION;
+
+ GetSecurityDescriptorGroup(descriptor, &group, &group_defaulted);
+ if (group)
+ securityInformation |= GROUP_SECURITY_INFORMATION;
+
+ GetSecurityDescriptorDacl(descriptor, &dacl_present,
+ &dacl, &dacl_defaulted);
+ if (dacl)
+ securityInformation |= DACL_SECURITY_INFORMATION;
+
+ GetSecurityDescriptorSacl(descriptor, &sacl_present,
+ &sacl, &sacl_defaulted);
+ if (sacl)
+ securityInformation |= SACL_SECURITY_INFORMATION;
+
+again:
+ if (securityInformation == 0)
+ return 0;
+ if (SetSecurityInfo(hFile, SE_FILE_OBJECT,
+ securityInformation, owner, group, dacl, sacl))
+ return 0;
+ err = GetLastError();
+ if (args->extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
+ goto fail;
+ switch (err) {
+ case ERROR_PRIVILEGE_NOT_HELD:
+ if (securityInformation & SACL_SECURITY_INFORMATION) {
+ n = args->num_set_sacl_priv_notheld++;
+ securityInformation &= ~SACL_SECURITY_INFORMATION;
+ sacl = NULL;
+ if (n < MAX_SET_SACL_PRIV_NOTHELD_WARNINGS) {
+ WARNING(
+"We don't have enough privileges to set the full security\n"
+" descriptor on \"%ls\"!\n", path);
+ if (args->num_set_sd_access_denied +
+ args->num_set_sacl_priv_notheld == 1)
+ {
+ WARNING("%ls", apply_access_denied_msg);
+ }
+ WARNING("Re-trying with SACL omitted.\n", path);
+ } else if (n == MAX_GET_SACL_PRIV_NOTHELD_WARNINGS) {
+ WARNING(
+"Suppressing further 'privileges not held' error messages when setting\n"
+" security descriptors.");
+ }
+ goto again;
+ }
+ /* Fall through */
+ case ERROR_INVALID_OWNER:
+ case ERROR_ACCESS_DENIED:
+ n = args->num_set_sd_access_denied++;
+ if (n < MAX_SET_SD_ACCESS_DENIED_WARNINGS) {
+ WARNING("Failed to set security descriptor on \"%ls\": "
+ "Access denied!\n", path);
+ if (args->num_set_sd_access_denied +
+ args->num_set_sacl_priv_notheld == 1)
+ {
+ WARNING("%ls", apply_access_denied_msg);
+ }
+ } else if (n == MAX_SET_SD_ACCESS_DENIED_WARNINGS) {
+ WARNING(
+"Suppressing further access denied error messages when setting\n"
+" security descriptors");
+ }
+ return 0;
+ default:
+fail:
+ ERROR("Failed to set security descriptor on \"%ls\"", path);
+ win32_error(err);
+ if (err == ERROR_ACCESS_DENIED || err == ERROR_PRIVILEGE_NOT_HELD)
+ return WIMLIB_ERR_INSUFFICIENT_PRIVILEGES_TO_EXTRACT;
+ else
+ return WIMLIB_ERR_WRITE;
+ }
+}
+
+
+static int
+win32_extract_chunk(const void *buf, size_t len, void *arg)
+{
+ HANDLE hStream = arg;
+
+ DWORD nbytes_written;
+ wimlib_assert(len <= 0xffffffff);
+
+ if (!WriteFile(hStream, buf, len, &nbytes_written, NULL) ||
+ nbytes_written != len)
+ {