X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fwin32_apply.c;h=df42653cd475176311237bfd28d9354b6548d796;hb=efdb571bf22033727f0d15bb161614686e5bcf66;hp=f741b447e078322adf12d86f2d213f405a0b82d7;hpb=b5b9681794d1f5f13350e3567f6f6e74f5c779cf;p=wimlib

diff --git a/src/win32_apply.c b/src/win32_apply.c
index f741b447..df42653c 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.  */
@@ -103,7 +101,7 @@ struct win32_apply_ctx {
 
 	/* 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)  */
@@ -357,7 +355,7 @@ dentry_extraction_path_length(const struct wim_dentry *dentry)
 	d = dentry;
 	do {
 		len += d->d_extraction_name_nchars + 1;
-		d = d->parent;
+		d = d->d_parent;
 	} while (!dentry_is_root(d) && will_extract_dentry(d));
 
 	return --len;  /* No leading slash  */
@@ -426,8 +424,8 @@ build_extraction_path(const struct wim_dentry *dentry,
 	ctx->pathbuf.Length = len * sizeof(wchar_t);
 	p = ctx->pathbuf.Buffer + len;
 	for (d = dentry;
-	     !dentry_is_root(d->parent) && will_extract_dentry(d->parent);
-	     d = d->parent)
+	     !dentry_is_root(d->d_parent) && will_extract_dentry(d->d_parent);
+	     d = d->d_parent)
 	{
 		p -= d->d_extraction_name_nchars;
 		wmemcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
@@ -482,7 +480,7 @@ build_win32_extraction_path(const struct wim_dentry *dentry,
 	ctx->pathbuf.Length += ctx->target_ntpath.Length + sizeof(wchar_t);
 	ctx->pathbuf.Buffer[ctx->pathbuf.Length / sizeof(wchar_t)] = L'\0';
 
-	wimlib_assert(ctx->pathbuf.Length >= 8 &&
+	wimlib_assert(ctx->pathbuf.Length >= 4 * sizeof(wchar_t) &&
 		      !wmemcmp(ctx->pathbuf.Buffer, L"\\??\\", 4));
 
 	ctx->pathbuf.Buffer[1] = L'\\';
@@ -512,24 +510,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).  */
 
-	status = (*func_RtlDosPathNameToNtPathName_U_WithStatus)(ctx->common.target,
-								 &ctx->target_ntpath,
-								 NULL, NULL);
-	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;
@@ -976,22 +965,6 @@ create_directories(struct list_head *dentry_list,
 	return 0;
 }
 
-/* Gets the number of bytes to allocate for the specified inode.  */
-static void
-inode_get_allocation_size(const struct wim_inode *inode,
-			  LARGE_INTEGER *allocation_size_ret)
-{
-	const struct wim_lookup_table_entry *unnamed_stream;
-
-	/* We just count the unnamed data stream.  */
-
-	unnamed_stream = inode_unnamed_lte_resolved(inode);
-	if (unnamed_stream)
-		allocation_size_ret->QuadPart = unnamed_stream->size;
-	else
-		allocation_size_ret->QuadPart = 0;
-}
-
 /*
  * Creates the nondirectory file named by @dentry.
  *
@@ -1004,17 +977,12 @@ create_nondirectory_inode(HANDLE *h_ret, const struct wim_dentry *dentry,
 			  struct win32_apply_ctx *ctx)
 {
 	const struct wim_inode *inode;
-	LARGE_INTEGER allocation_size;
 	ULONG attrib;
 	NTSTATUS status;
 	bool retried = false;
 
 	inode = dentry->d_inode;
 
-	/* To increase performance, we will pre-allocate space for the file
-	 * data.  */
-	inode_get_allocation_size(inode, &allocation_size);
-
 	/* If the file already exists and has FILE_ATTRIBUTE_SYSTEM and/or
 	 * FILE_ATTRIBUTE_HIDDEN, these must be specified in order to supersede
 	 * the file.
@@ -1040,7 +1008,7 @@ create_nondirectory_inode(HANDLE *h_ret, const struct wim_dentry *dentry,
 	build_extraction_path(dentry, ctx);
 retry:
 	status = do_create_file(h_ret, GENERIC_READ | GENERIC_WRITE | DELETE,
-				&allocation_size, attrib, FILE_SUPERSEDE,
+				NULL, attrib, FILE_SUPERSEDE,
 				FILE_NON_DIRECTORY_FILE, ctx);
 	if (NT_SUCCESS(status)) {
 		int ret;
@@ -1282,7 +1250,7 @@ begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
 {
 	const struct wim_inode *inode = dentry->d_inode;
 	size_t stream_name_nchars = 0;
-	LARGE_INTEGER allocation_size;
+	FILE_ALLOCATION_INFORMATION alloc_info;
 	HANDLE h;
 	NTSTATUS status;
 
@@ -1354,7 +1322,9 @@ begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
 					    &info, ctx->common.progctx);
 			FREE(dentry->_full_path);
 			dentry->_full_path = NULL;
-			return ret;
+			if (ret)
+				return ret;
+			/* Go on and open the file for normal extraction.  */
 		} else {
 			FREE(dentry->_full_path);
 			dentry->_full_path = NULL;
@@ -1367,17 +1337,18 @@ begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
 		}
 	}
 
-	/* Too many open handles?  */
-	if (ctx->num_open_handles == MAX_OPEN_HANDLES) {
-		ERROR("Too many 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;
 	}
 
 	/* Open a new handle  */
-	allocation_size.QuadPart = stream->size;
 	status = do_create_file(&h,
 				FILE_WRITE_DATA | SYNCHRONIZE,
-				&allocation_size, 0, FILE_OPEN_IF,
+				NULL, 0, FILE_OPEN_IF,
 				FILE_SEQUENTIAL_ONLY |
 					FILE_SYNCHRONOUS_IO_NONALERT,
 				ctx);
@@ -1390,6 +1361,12 @@ begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
 	}
 
 	ctx->open_handles[ctx->num_open_handles++] = h;
+
+	/* Allocate space for the data.  */
+	alloc_info.AllocationSize.QuadPart = stream->size;
+	(*func_NtSetInformationFile)(h, &ctx->iosb,
+				     &alloc_info, sizeof(alloc_info),
+				     FileAllocationInformation);
 	return 0;
 }
 
@@ -1474,7 +1451,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)
 {
@@ -1487,7 +1470,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'\\');
@@ -1536,14 +1519,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
@@ -1645,8 +1632,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);
@@ -1690,11 +1676,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:
@@ -1761,7 +1742,10 @@ end_extract_stream(struct wim_lookup_table_entry *stream, int status, void *_ctx
 			dentry = list_first_entry(&ctx->reparse_dentries,
 						  struct wim_dentry, tmp_list);
 			build_extraction_path(dentry, ctx);
-			ERROR("Invalid reparse point", current_path(ctx));
+			ERROR("Reparse data of \"%ls\" has size "
+			      "%"PRIu64" bytes (exceeds %u bytes)",
+			      current_path(ctx), stream->size,
+			      REPARSE_DATA_MAX_SIZE);
 			return WIMLIB_ERR_INVALID_REPARSE_DATA;
 		}
 		/* In the WIM format, reparse streams are just the reparse data
@@ -2081,3 +2065,5 @@ const struct apply_operations win32_apply_ops = {
 	.extract                = win32_extract,
 	.context_size           = sizeof(struct win32_apply_ctx),
 };
+
+#endif /* __WIN32__ */