X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fwin32_apply.c;h=f871f020f5c9e08e475a9263f02dbfde6f9b832f;hb=3ee9acdab75547655dd7fb9d3c423daeb3051642;hp=4f4cf6eb3350658bc01f14150fc7eeb2bfb0a2f1;hpb=a3c63defc94455a84fa681024a461691c1ad5661;p=wimlib

diff --git a/src/win32_apply.c b/src/win32_apply.c
index 4f4cf6eb..f871f020 100644
--- a/src/win32_apply.c
+++ b/src/win32_apply.c
@@ -21,6 +21,8 @@
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
+#ifdef __WIN32__
+
 #ifdef HAVE_CONFIG_H
 #  include "config.h"
 #endif
@@ -38,10 +40,6 @@
 #include "wimlib/xml.h"
 #include "wimlib/wimboot.h"
 
-/* TODO: Add workaround for when a stream needs to be extracted to more places
- * than this  */
-#define MAX_OPEN_HANDLES 32768
-
 struct win32_apply_ctx {
 
 	/* Extract flags, the pointer to the WIMStruct, etc.  */
@@ -98,12 +96,12 @@ struct win32_apply_ctx {
 	struct reparse_buffer_disk rpbuf;
 
 	/* Temporary buffer for reparse data of "fixed" absolute symbolic links
-	 * and junction  */
+	 * and junctions  */
 	struct reparse_buffer_disk rpfixbuf;
 
 	/* Array of open handles to filesystem streams currently being written
 	 */
-	HANDLE open_handles[MAX_OPEN_HANDLES];
+	HANDLE open_handles[MAX_OPEN_STREAMS];
 
 	/* Number of handles in @open_handles currently open (filled in from the
 	 * beginning of the array)  */
@@ -237,7 +235,7 @@ win32_get_supported_features(const wchar_t *target,
 	return 0;
 }
 
-/* Load the patterns from [PrepopulateList] of WimBootCompresse.ini in the WIM
+/* Load the patterns from [PrepopulateList] of WimBootCompress.ini in the WIM
  * image being extracted.  */
 static int
 load_prepopulate_pats(struct win32_apply_ctx *ctx)
@@ -327,8 +325,7 @@ start_wimboot_extraction(struct win32_apply_ctx *ctx)
 	if (ret == WIMLIB_ERR_NOMEM)
 		return ret;
 
-	if (!wim_info_get_wimboot(wim->wim_info,
-				  wim->current_image))
+	if (!wim_info_get_wimboot(wim->wim_info, wim->current_image))
 		WARNING("Image is not marked as WIMBoot compatible!");
 
 	ret = hash_lookup_table(ctx->common.wim,
@@ -344,6 +341,80 @@ start_wimboot_extraction(struct win32_apply_ctx *ctx)
 					    &ctx->wimboot.wof_running);
 }
 
+static void
+build_win32_extraction_path(const struct wim_dentry *dentry,
+			    struct win32_apply_ctx *ctx);
+
+/* Sets WimBoot=1 in the extracted SYSTEM registry hive.
+ *
+ * WIMGAPI does this, and it's possible that it's important.
+ * But I don't know exactly what this value means to Windows.  */
+static int
+end_wimboot_extraction(struct win32_apply_ctx *ctx)
+{
+	struct wim_dentry *dentry;
+	wchar_t subkeyname[32];
+	LONG res;
+	LONG res2;
+	HKEY key;
+	DWORD value;
+
+	dentry = get_dentry(ctx->common.wim, L"\\Windows\\System32\\config\\SYSTEM",
+			    WIMLIB_CASE_INSENSITIVE);
+
+	if (!dentry || !will_extract_dentry(dentry))
+		goto out;
+
+	if (!will_extract_dentry(wim_get_current_root_dentry(ctx->common.wim)))
+		goto out;
+
+	/* Not bothering to use the native routines (e.g. NtLoadKey()) for this.
+	 * If this doesn't work, you probably also have many other problems.  */
+
+	build_win32_extraction_path(dentry, ctx);
+
+	randomize_char_array_with_alnum(subkeyname, 20);
+	subkeyname[20] = L'\0';
+
+	res = RegLoadKey(HKEY_LOCAL_MACHINE, subkeyname, ctx->pathbuf.Buffer);
+	if (res)
+		goto out_check_res;
+
+	wcscpy(&subkeyname[20], L"\\Setup");
+
+	res = RegCreateKeyEx(HKEY_LOCAL_MACHINE, subkeyname, 0, NULL,
+			     REG_OPTION_BACKUP_RESTORE, 0, NULL, &key, NULL);
+	if (res)
+		goto out_unload_key;
+
+	value = 1;
+
+	res = RegSetValueEx(key, L"WimBoot", 0, REG_DWORD,
+			    (const BYTE *)&value, sizeof(DWORD));
+	if (res)
+		goto out_close_key;
+
+	res = RegFlushKey(key);
+
+out_close_key:
+	res2 = RegCloseKey(key);
+	if (!res)
+		res = res2;
+out_unload_key:
+	subkeyname[20] = L'\0';
+	RegUnLoadKey(HKEY_LOCAL_MACHINE, subkeyname);
+out_check_res:
+	if (res) {
+		/* Warning only.  */
+		set_errno_from_win32_error(res);
+		WARNING_WITH_ERRNO("Failed to set \\Setup: dword \"WimBoot\"=1 value "
+				   "in registry hive \"%ls\" (err=0x%08"PRIu32")",
+				   ctx->pathbuf.Buffer, (u32)res);
+	}
+out:
+	return 0;
+}
+
 /* Returns the number of wide characters needed to represent the path to the
  * specified @dentry, relative to the target directory, when extracted.
  *
@@ -368,7 +439,7 @@ dentry_extraction_path_length(const struct wim_dentry *dentry)
  *
  * If the inode has no named data streams, this will be 0.  Otherwise, this will
  * be 1 plus the length of the longest-named data stream, since the data stream
- * name must be separated form the path by the ':' character.  */
+ * name must be separated from the path by the ':' character.  */
 static size_t
 inode_longest_named_data_stream_spec(const struct wim_inode *inode)
 {
@@ -464,7 +535,7 @@ build_extraction_path_with_ads(const struct wim_dentry *dentry,
  * The path is saved in ctx->pathbuf and will be null terminated.
  *
  * XXX: We could get rid of this if it wasn't needed for the file encryption
- * APIs.  */
+ * APIs, and the registry manipulation in WIMBoot mode.  */
 static void
 build_win32_extraction_path(const struct wim_dentry *dentry,
 			    struct win32_apply_ctx *ctx)
@@ -512,33 +583,15 @@ current_path(struct win32_apply_ctx *ctx)
 static int
 prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
 {
+	int ret;
 	NTSTATUS status;
 	size_t path_max;
 
 	/* Open handle to the target directory (possibly creating it).  */
 
-	if (func_RtlDosPathNameToNtPathName_U_WithStatus) {
-		status = (*func_RtlDosPathNameToNtPathName_U_WithStatus)(ctx->common.target,
-									 &ctx->target_ntpath,
-									 NULL, NULL);
-	} else {
-		if ((*func_RtlDosPathNameToNtPathName_U)(ctx->common.target,
-							 &ctx->target_ntpath,
-							 NULL, NULL))
-			status = STATUS_SUCCESS;
-		else
-			status = STATUS_NO_MEMORY;
-	}
-	if (!NT_SUCCESS(status)) {
-		if (status == STATUS_NO_MEMORY) {
-			return WIMLIB_ERR_NOMEM;
-		} else {
-			ERROR("\"%ls\": invalid path name "
-			      "(status=0x%08"PRIx32")",
-			      ctx->common.target, (u32)status);
-			return WIMLIB_ERR_INVALID_PARAM;
-		}
-	}
+	ret = win32_path_to_nt_path(ctx->common.target, &ctx->target_ntpath);
+	if (ret)
+		return ret;
 
 	ctx->attr.Length = sizeof(ctx->attr);
 	ctx->attr.ObjectName = &ctx->target_ntpath;
@@ -683,7 +736,7 @@ adjust_compression_attribute(HANDLE h, const struct wim_dentry *dentry,
  * handle to the file.  If it does, it sets it to NULL.
  */
 static int
-maybe_clear_encryption_attribute(HANDLE *h_ret, const struct wim_dentry *dentry,
+maybe_clear_encryption_attribute(HANDLE *h_ptr, const struct wim_dentry *dentry,
 				 struct win32_apply_ctx *ctx)
 {
 	if (dentry->d_inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED)
@@ -700,7 +753,7 @@ maybe_clear_encryption_attribute(HANDLE *h_ret, const struct wim_dentry *dentry,
 	BOOL bret;
 
 	/* Get current attributes  */
-	status = (*func_NtQueryInformationFile)(*h_ret, &ctx->iosb,
+	status = (*func_NtQueryInformationFile)(*h_ptr, &ctx->iosb,
 						&info, sizeof(info),
 						FileBasicInformation);
 	if (NT_SUCCESS(status) &&
@@ -716,8 +769,8 @@ maybe_clear_encryption_attribute(HANDLE *h_ret, const struct wim_dentry *dentry,
 	 * handle to the file so we don't get ERROR_SHARING_VIOLATION.  We also
 	 * hack together a Win32 path, although we will use the \\?\ prefix so
 	 * it will actually be a NT path in disguise...  */
-	(*func_NtClose)(*h_ret);
-	*h_ret = NULL;
+	(*func_NtClose)(*h_ptr);
+	*h_ptr = NULL;
 
 	build_win32_extraction_path(dentry, ctx);
 
@@ -970,7 +1023,7 @@ create_directories(struct list_head *dentry_list,
 		 * wait until later to actually set the reparse data.  */
 
 		/* If the root dentry is being extracted, it was already done so
-		 * it prepare_target().  */
+		 * in prepare_target().  */
 		if (dentry_is_root(dentry))
 			continue;
 
@@ -981,6 +1034,10 @@ create_directories(struct list_head *dentry_list,
 		ret = create_any_empty_ads(dentry, ctx);
 		if (ret)
 			return ret;
+
+		ret = report_file_created(&ctx->common);
+		if (ret)
+			return ret;
 	}
 	return 0;
 }
@@ -1228,6 +1285,9 @@ create_nondirectories(struct list_head *dentry_list, struct win32_apply_ctx *ctx
 		ret = create_nondirectory(inode, ctx);
 		if (ret)
 			return ret;
+		ret = report_file_created(&ctx->common);
+		if (ret)
+			return ret;
 	}
 	return 0;
 }
@@ -1357,8 +1417,10 @@ begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
 		}
 	}
 
-	/* Too many open handles?  */
-	if (ctx->num_open_handles == MAX_OPEN_HANDLES) {
+	if (ctx->num_open_handles == MAX_OPEN_STREAMS) {
+		/* XXX: Fix this.  But because of the checks in
+		 * extract_stream_list(), this can now only happen on a
+		 * filesystem that does not support hard links.  */
 		ERROR("Can't extract data: too many open files!");
 		return WIMLIB_ERR_UNSUPPORTED;
 	}
@@ -1469,7 +1531,13 @@ skip_nt_toplevel_component(const wchar_t *path, size_t path_nchars)
 
 /* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
  * pointer to the suffix of the path that is device-relative, such as
- * Windows\System32.  */
+ * Windows\System32.
+ *
+ * The path has an explicit length and is not necessarily null terminated.
+ *
+ * If the path just something like \??\e: then the returned pointer will point
+ * just past the colon.  In this case the length of the result will be 0
+ * characters.  */
 static const wchar_t *
 get_device_relative_path(const wchar_t *path, size_t path_nchars)
 {
@@ -1482,7 +1550,7 @@ get_device_relative_path(const wchar_t *path, size_t path_nchars)
 
 	path = wmemchr(path, L'\\', (end - path));
 	if (!path)
-		return orig_path;
+		return end;
 	do {
 		path++;
 	} while (path != end && *path == L'\\');
@@ -1531,14 +1599,18 @@ try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx)
 
 	target_ntpath_nchars = ctx->target_ntpath.Length / sizeof(wchar_t);
 
-	fixed_subst_name_nchars = target_ntpath_nchars + 1 + relpath_nchars;
+	fixed_subst_name_nchars = target_ntpath_nchars;
+	if (relpath_nchars)
+		fixed_subst_name_nchars += 1 + relpath_nchars;
 	wchar_t fixed_subst_name[fixed_subst_name_nchars];
 
 	wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer,
 		target_ntpath_nchars);
-	fixed_subst_name[target_ntpath_nchars] = L'\\';
-	wmemcpy(&fixed_subst_name[target_ntpath_nchars + 1],
-		relpath, relpath_nchars);
+	if (relpath_nchars) {
+		fixed_subst_name[target_ntpath_nchars] = L'\\';
+		wmemcpy(&fixed_subst_name[target_ntpath_nchars + 1],
+			relpath, relpath_nchars);
+	}
 	/* Doesn't need to be null-terminated.  */
 
 	/* Print name should be Win32, but not all NT names can even be
@@ -1640,8 +1712,7 @@ extract_encrypted_file(const struct wim_dentry *dentry,
 
 /* Called when starting to read a stream for extraction on Windows  */
 static int
-begin_extract_stream(struct wim_lookup_table_entry *stream,
-		     u32 flags, void *_ctx)
+begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx)
 {
 	struct win32_apply_ctx *ctx = _ctx;
 	const struct stream_owner *owners = stream_owners(stream);
@@ -1685,11 +1756,6 @@ begin_extract_stream(struct wim_lookup_table_entry *stream,
 		}
 	}
 
-	if (unlikely(ctx->num_open_handles == 0 && ctx->data_buffer_ptr == NULL)) {
-		/* The data of this stream isn't actually needed!
-		 * (This can happen in WIMBoot mode.)  */
-		return BEGIN_STREAM_STATUS_SKIP_STREAM;
-	}
 	return 0;
 
 fail:
@@ -1985,6 +2051,9 @@ apply_metadata(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
 		ret = apply_metadata_to_file(dentry, ctx);
 		if (ret)
 			return ret;
+		ret = report_file_metadata_applied(&ctx->common);
+		if (ret)
+			return ret;
 	}
 	return 0;
 }
@@ -2026,12 +2095,14 @@ win32_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
 	if (ret)
 		goto out;
 
-	if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT) {
+	if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) {
 		ret = start_wimboot_extraction(ctx);
 		if (ret)
 			goto out;
 	}
 
+	reset_file_progress(&ctx->common);
+
 	ret = create_directories(dentry_list, ctx);
 	if (ret)
 		goto out;
@@ -2052,10 +2123,18 @@ win32_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
 	if (ret)
 		goto out;
 
+	reset_file_progress(&ctx->common);
+
 	ret = apply_metadata(dentry_list, ctx);
 	if (ret)
 		goto out;
 
+	if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) {
+		ret = end_wimboot_extraction(ctx);
+		if (ret)
+			goto out;
+	}
+
 	do_warnings(ctx);
 out:
 	if (ctx->h_target)
@@ -2079,3 +2158,5 @@ const struct apply_operations win32_apply_ops = {
 	.extract                = win32_extract,
 	.context_size           = sizeof(struct win32_apply_ctx),
 };
+
+#endif /* __WIN32__ */