X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fextract_image.c;h=d331dc0de70060944d900a527e1467ac5db4e219;hp=3d7fd36c6cb6736ee470607e99dbac82042767f4;hb=a8972bde4b080d2dd33a7500705d431b0f1fe901;hpb=f389abff995f590fd762777e302f99a413521765

diff --git a/src/extract_image.c b/src/extract_image.c
index 3d7fd36c..d331dc0d 100644
--- a/src/extract_image.c
+++ b/src/extract_image.c
@@ -25,19 +25,16 @@
 
 #include "config.h"
 
-#if defined(__CYGWIN__) || defined(__WIN32__)
-#	include <windows.h>
-#	ifdef ERROR
-#		undef ERROR
-#	endif
-#	include <wchar.h>
+#include <dirent.h>
+
+#ifdef __WIN32__
+#  include "win32.h"
 #else
-#	include <dirent.h>
-#	ifdef HAVE_UTIME_H
-#		include <utime.h>
-#	endif
-#	include "timestamp.h"
-#	include <sys/time.h>
+#  ifdef HAVE_UTIME_H
+#    include <utime.h>
+#  endif
+#  include "timestamp.h"
+#  include <sys/time.h>
 #endif
 
 #include <errno.h>
@@ -45,7 +42,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
-
 #include <unistd.h>
 
 #include "dentry.h"
@@ -54,300 +50,46 @@
 #include "xml.h"
 
 #ifdef WITH_NTFS_3G
-#include <ntfs-3g/volume.h>
+#  include <ntfs-3g/volume.h>
 #endif
 
 #ifdef HAVE_ALLOCA_H
-#include <alloca.h>
+#  include <alloca.h>
 #endif
 
-#if defined(__CYGWIN__) || defined(__WIN32__)
-
-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_wim_resource(lte, buf + 8, 0);
-	if (ret)
-		return ret;
-	*(u32*)(buf + 0) = reparse_tag;
-	*(u16*)(buf + 4) = 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);
-		return WIMLIB_ERR_WRITE;
-	}
-	return 0;
-}
-
+#ifndef __WIN32__
 
-static int win32_extract_chunk(const u8 *buf, size_t len, u64 offset, void *arg)
+/* Returns the number of components of @path.  */
+static unsigned
+get_num_path_components(const char *path)
 {
-	HANDLE hStream = arg;
-
-	DWORD nbytes_written;
-	wimlib_assert(len <= 0xffffffff);
-
-	if (!WriteFile(hStream, buf, len, &nbytes_written, NULL) ||
-	    nbytes_written != len)
-	{
-		DWORD err = GetLastError();
-		ERROR("WriteFile(): write error");
-		win32_error(err);
-		return WIMLIB_ERR_WRITE;
-	}
-	return 0;
+	unsigned num_components = 0;
+	while (*path) {
+		while (*path == '/')
+			path++;
+		if (*path)
+			num_components++;
+		while (*path && *path != '/')
+			path++;
+	}
+	return num_components;
 }
 
-static int do_win32_extract_stream(HANDLE hStream, struct wim_lookup_table_entry *lte)
+static const char *
+path_next_part(const char *path)
 {
-	return extract_wim_resource(lte, wim_resource_size(lte),
-				    win32_extract_chunk, hStream);
+	while (*path && *path != '/')
+		path++;
+	while (*path && *path == '/')
+		path++;
+	return path;
 }
 
-static int win32_extract_stream(const struct wim_inode *inode,
-				const wchar_t *path,
-				const wchar_t *stream_name_utf16,
-				struct wim_lookup_table_entry *lte)
-{
-	wchar_t *stream_path;
-	HANDLE h;
-	int ret;
-	DWORD err;
-	DWORD creationDisposition = CREATE_ALWAYS;
-
-	if (stream_name_utf16) {
-		/* Named stream.  Create a buffer that contains the UTF-16LE
-		 * string [./]@path:@stream_name_utf16.  This is needed to
-		 * create and open the stream using CreateFileW().  I'm not
-		 * aware of any other APIs to do this.  Note: note that the
-		 * '$DATA' suffix seems to be unneeded; Additional note: a "./"
-		 * prefix needs to be added when the path is not absolute to
-		 * avoid ambiguity with drive letters. */
-		size_t stream_path_nchars;
-		size_t path_nchars;
-		size_t stream_name_nchars;
-		const wchar_t *prefix;
-
- 		path_nchars = wcslen(path);
-		stream_name_nchars = wcslen(stream_name_utf16);
-		stream_path_nchars = path_nchars + 1 + stream_name_nchars;
-		if (path[0] != L'/' && path[1] != L'\\') {
-			prefix = L"./";
-			stream_path_nchars += 2;
-		} else {
-			prefix = L"";
-		}
-		stream_path = alloca((stream_path_nchars + 1) * sizeof(wchar_t));
-		swprintf(stream_path, stream_path_nchars + 1, L"%ls%ls:%ls",
-			 prefix, path, stream_name_utf16);
-	} else {
-		/* Unnamed stream; it's path is just the path to the file
-		 * itself. */
-		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();
-				if (err != ERROR_ALREADY_EXISTS) {
-					ERROR("Failed to create directory \"%ls\"",
-					      path);
-					win32_error(err);
-					ret = WIMLIB_ERR_MKDIR;
-					goto fail;
-				}
-			}
-			DEBUG("Created directory \"%ls\"", stream_path);
-			if (!(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
-				ret = 0;
-				goto out;
-			}
-			creationDisposition = OPEN_EXISTING;
-		}
-	}
-
-	DEBUG("Opening \"%ls\"", stream_path);
-	h = CreateFileW(stream_path,
-			GENERIC_WRITE | WRITE_OWNER | WRITE_DAC,
-			0,
-			NULL,
-			creationDisposition,
-			FILE_FLAG_OPEN_REPARSE_POINT |
-			    FILE_FLAG_BACKUP_SEMANTICS |
-			    inode->i_attributes,
-			NULL);
-	if (h == INVALID_HANDLE_VALUE) {
-		err = GetLastError();
-		ERROR("Failed to create \"%ls\"", stream_path);
-		win32_error(err);
-		ret = WIMLIB_ERR_OPEN;
-		goto fail;
-	}
-
-	if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT &&
-	    stream_name_utf16 == NULL)
-	{
-		DEBUG("Setting reparse data on \"%ls\"", path);
-		ret = win32_set_reparse_data(h, inode->i_reparse_tag, lte, path);
-		if (ret)
-			goto fail_close_handle;
-	} else {
-		if (lte) {
-			DEBUG("Extracting \"%ls\" (len = %zu)",
-			      stream_path, wim_resource_size(lte));
-			ret = do_win32_extract_stream(h, lte);
-			if (ret)
-				goto fail_close_handle;
-		}
-	}
-
-	DEBUG("Closing \"%ls\"", stream_path);
-	if (!CloseHandle(h)) {
-		err = GetLastError();
-		ERROR("Failed to close \"%ls\"", stream_path);
-		win32_error(err);
-		ret = WIMLIB_ERR_WRITE;
-		goto fail;
-	}
-	ret = 0;
-	goto out;
-fail_close_handle:
-	CloseHandle(h);
-fail:
-	ERROR("Error extracting %ls", stream_path);
-out:
-	return ret;
-}
-
-/*
- * 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).  This in Win32-specific code.
- *
- * @inode:	WIM inode for this file or directory.
- * @path:	UTF-16LE external path to extract the inode to.
- *
- * Returns 0 on success; nonzero on failure.
- */
-static int win32_extract_streams(struct wim_inode *inode,
-				 const wchar_t *path)
-{
-	struct wim_lookup_table_entry *unnamed_lte;
-	int ret;
-
-	unnamed_lte = inode_unnamed_lte_resolved(inode);
-	ret = win32_extract_stream(inode, path, NULL, unnamed_lte);
-	if (ret)
-		goto out;
-	for (u16 i = 0; i < inode->i_num_ads; i++) {
-		const struct wim_ads_entry *ads_entry = &inode->i_ads_entries[i];
-		if (ads_entry->stream_name_len != 0) {
-			/* Skip special UNIX data entries (see documentation for
-			 * WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) */
-			if (ads_entry->stream_name_len == WIMLIB_UNIX_DATA_TAG_LEN
-			    && !memcmp(ads_entry->stream_name_utf8,
-				       WIMLIB_UNIX_DATA_TAG,
-				       WIMLIB_UNIX_DATA_TAG_LEN))
-				continue;
-			ret = win32_extract_stream(inode,
-						   path,
-						   (const wchar_t*)ads_entry->stream_name,
-						   ads_entry->lte);
-			if (ret)
-				break;
-		}
-	}
-out:
-	return ret;
-}
-
-/*
- * Sets the security descriptor on an extracted file.  This is Win32-specific
- * code.
- *
- * @inode:	The WIM inode that was extracted and has a security descriptor.
- * @path:	UTF-16LE external path that the inode was extracted to.
- * @sd:		Security data for the WIM image.
- * @path_utf8:  @path in UTF-8 for error messages only.
- *
- * Returns 0 on success; nonzero on failure.
- */
-static int win32_set_security_data(const struct wim_inode *inode,
-				   const wchar_t *path,
-				   const struct wim_security_data *sd)
-{
-	SECURITY_INFORMATION securityInformation = DACL_SECURITY_INFORMATION |
-					           SACL_SECURITY_INFORMATION |
-					           OWNER_SECURITY_INFORMATION |
-					           GROUP_SECURITY_INFORMATION;
-	if (!SetFileSecurityW(path, securityInformation,
-			      (PSECURITY_DESCRIPTOR)sd->descriptors[inode->i_security_id]))
-	{
-		DWORD err = GetLastError();
-		ERROR("Can't set security descriptor on \"%ls\"", path);
-		win32_error(err);
-		return WIMLIB_ERR_WRITE;
-	}
-	return 0;
-}
-
-#else /* __CYGWIN__ || __WIN32__ */
-static int extract_regular_file_linked(struct wim_dentry *dentry,
-				       const char *output_path,
-				       struct apply_args *args,
-				       struct wim_lookup_table_entry *lte)
+static int
+extract_regular_file_linked(struct wim_dentry *dentry,
+			    const char *output_path,
+			    struct apply_args *args,
+			    struct wim_lookup_table_entry *lte)
 {
 	/* This mode overrides the normal hard-link extraction and
 	 * instead either symlinks or hardlinks *all* identical files in
@@ -370,7 +112,7 @@ static int extract_regular_file_linked(struct wim_dentry *dentry,
 		size_t i;
 
 		num_path_components =
-			get_num_path_components(dentry->full_path_utf8) - 1;
+			get_num_path_components(dentry->full_path) - 1;
 		num_output_dir_path_components =
 			get_num_path_components(args->target);
 
@@ -391,12 +133,13 @@ static int extract_regular_file_linked(struct wim_dentry *dentry,
 		p2 = lte->extracted_file;
 		while (*p2 == '/')
 			p2++;
-		while (num_output_dir_path_components--)
-			p2 = path_next_part(p2, NULL);
+		while (num_output_dir_path_components > 0) {
+			p2 = path_next_part(p2);
+			num_output_dir_path_components--;
+		}
 		strcpy(p, p2);
 		if (symlink(buf, output_path) != 0) {
-			ERROR_WITH_ERRNO("Failed to symlink `%s' to "
-					 "`%s'",
+			ERROR_WITH_ERRNO("Failed to symlink `%s' to `%s'",
 					 buf, lte->extracted_file);
 			return WIMLIB_ERR_LINK;
 		}
@@ -404,8 +147,9 @@ static int extract_regular_file_linked(struct wim_dentry *dentry,
 	return 0;
 }
 
-static int symlink_apply_unix_data(const char *link,
-				   const struct wimlib_unix_data *unix_data)
+static int
+symlink_apply_unix_data(const char *link,
+			const struct wimlib_unix_data *unix_data)
 {
 	if (lchown(link, unix_data->uid, unix_data->gid)) {
 		if (errno == EPERM) {
@@ -419,7 +163,8 @@ static int symlink_apply_unix_data(const char *link,
 	return 0;
 }
 
-static int fd_apply_unix_data(int fd, const struct wimlib_unix_data *unix_data)
+static int
+fd_apply_unix_data(int fd, const struct wimlib_unix_data *unix_data)
 {
 	if (fchown(fd, unix_data->uid, unix_data->gid)) {
 		if (errno == EPERM) {
@@ -443,8 +188,8 @@ static int fd_apply_unix_data(int fd, const struct wimlib_unix_data *unix_data)
 	return 0;
 }
 
-static int dir_apply_unix_data(const char *dir,
-			       const struct wimlib_unix_data *unix_data)
+static int
+dir_apply_unix_data(const char *dir, const struct wimlib_unix_data *unix_data)
 {
 	int dfd = open(dir, O_RDONLY);
 	int ret;
@@ -461,10 +206,11 @@ static int dir_apply_unix_data(const char *dir,
 	return ret;
 }
 
-static int extract_regular_file_unlinked(struct wim_dentry *dentry,
-				         struct apply_args *args,
-				         const char *output_path,
-				         struct wim_lookup_table_entry *lte)
+static int
+extract_regular_file_unlinked(struct wim_dentry *dentry,
+			      struct apply_args *args,
+			      const char *output_path,
+			      struct wim_lookup_table_entry *lte)
 {
 	/* Normal mode of extraction.  Regular files and hard links are
 	 * extracted in the way that they appear in the WIM. */
@@ -551,9 +297,10 @@ out:
 	return ret;
 }
 
-static int extract_regular_file(struct wim_dentry *dentry,
-				struct apply_args *args,
-				const char *output_path)
+static int
+extract_regular_file(struct wim_dentry *dentry,
+		     struct apply_args *args,
+		     const char *output_path)
 {
 	struct wim_lookup_table_entry *lte;
 	const struct wim_inode *inode = dentry->d_inode;
@@ -574,9 +321,10 @@ static int extract_regular_file(struct wim_dentry *dentry,
 	return extract_regular_file_unlinked(dentry, args, output_path, lte);
 }
 
-static int extract_symlink(struct wim_dentry *dentry,
-			   struct apply_args *args,
-			   const char *output_path)
+static int
+extract_symlink(struct wim_dentry *dentry,
+		struct apply_args *args,
+		const char *output_path)
 {
 	char target[4096];
 	ssize_t ret = inode_readlink(dentry->d_inode, target,
@@ -585,7 +333,7 @@ static int extract_symlink(struct wim_dentry *dentry,
 
 	if (ret <= 0) {
 		ERROR("Could not read the symbolic link from dentry `%s'",
-		      dentry->full_path_utf8);
+		      dentry->full_path);
 		return WIMLIB_ERR_INVALID_DENTRY;
 	}
 	ret = symlink(target, output_path);
@@ -612,39 +360,40 @@ static int extract_symlink(struct wim_dentry *dentry,
 	return 0;
 }
 
-#endif /* !(__CYGWIN__ || __WIN32__) */
+#endif /* !__WIN32__ */
 
-static int extract_directory(struct wim_dentry *dentry,
-			     const char *output_path, bool is_root)
+static int
+extract_directory(struct wim_dentry *dentry,
+		  const tchar *output_path, bool is_root)
 {
 	int ret;
 	struct stat stbuf;
 
-	ret = stat(output_path, &stbuf);
+	ret = tstat(output_path, &stbuf);
 	if (ret == 0) {
 		if (S_ISDIR(stbuf.st_mode)) {
 			/*if (!is_root)*/
 				/*WARNING("`%s' already exists", output_path);*/
 			goto dir_exists;
 		} else {
-			ERROR("`%s' is not a directory", output_path);
+			ERROR("`%"TS"' is not a directory", output_path);
 			return WIMLIB_ERR_MKDIR;
 		}
 	} else {
 		if (errno != ENOENT) {
-			ERROR_WITH_ERRNO("Failed to stat `%s'", output_path);
+			ERROR_WITH_ERRNO("Failed to stat `%"TS"'", output_path);
 			return WIMLIB_ERR_STAT;
 		}
 	}
-	if (mkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP |
-			       S_IROTH | S_IXOTH) != 0) {
-		ERROR_WITH_ERRNO("Cannot create directory `%s'",
-				 output_path);
+
+	if (tmkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))
+	{
+		ERROR_WITH_ERRNO("Cannot create directory `%"TS"'", output_path);
 		return WIMLIB_ERR_MKDIR;
 	}
 dir_exists:
 	ret = 0;
-#if !defined(__CYGWIN__) && !defined(__WIN32__)
+#ifndef __WIN32__
 	if (dentry) {
 		struct wimlib_unix_data unix_data;
 		ret = inode_get_unix_data(dentry->d_inode, &unix_data, NULL);
@@ -659,81 +408,14 @@ dir_exists:
 	return ret;
 }
 
-/* Extracts a file, directory, or symbolic link from the WIM archive. */
-static int apply_dentry_normal(struct wim_dentry *dentry, void *arg)
+#ifndef __WIN32__
+static int unix_do_apply_dentry(const char *output_path,
+				size_t output_path_len,
+				struct wim_dentry *dentry,
+				struct apply_args *args)
 {
-	struct apply_args *args = arg;
-	struct wim_inode *inode = dentry->d_inode;
-	size_t len;
-	char *output_path;
-
-	len = strlen(args->target);
-	if (dentry_is_root(dentry)) {
-		output_path = (char*)args->target;
-	} else {
-		output_path = alloca(len + dentry->full_path_utf8_len + 1);
-		memcpy(output_path, args->target, len);
-		memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len);
-		output_path[len + dentry->full_path_utf8_len] = '\0';
-		len += dentry->full_path_utf8_len;
-	}
-
-#if defined(__CYGWIN__) || defined(__WIN32__)
-	char *utf16_path;
-	size_t utf16_path_len;
-	DWORD err;
-	int ret;
-	ret = utf8_to_utf16(output_path, len, &utf16_path, &utf16_path_len);
-	if (ret)
-		return ret;
+	const struct wim_inode *inode = dentry->d_inode;
 
-	if (inode->i_nlink > 1 && inode->i_extracted_file != NULL) {
-		/* Linked file, with another name already extracted.  Create a
-		 * hard link. */
-		DEBUG("Creating hard link \"%ls => %ls\"",
-		      (const wchar_t*)utf16_path,
-		      (const wchar_t*)inode->i_extracted_file);
-		if (!CreateHardLinkW((const wchar_t*)utf16_path,
-				     (const wchar_t*)inode->i_extracted_file,
-				     NULL))
-		{
-			err = GetLastError();
-			ERROR("Can't create hard link \"%ls => %ls\"",
-			      (const wchar_t*)utf16_path,
-			      (const wchar_t*)inode->i_extracted_file);
-			ret = WIMLIB_ERR_LINK;
-			win32_error(err);
-		}
-	} else {
-		/* Create the file, directory, or reparse point, and extract the
-		 * data streams. */
-		ret = win32_extract_streams(inode, (const wchar_t*)utf16_path);
-		if (ret)
-			goto out_free_utf16_path;
-
-		/* Set security descriptor if present */
-		if (inode->i_security_id != -1) {
-			DEBUG("Setting security descriptor %d on %s",
-			      inode->i_security_id, output_path);
-			ret = win32_set_security_data(inode,
-						      (const wchar_t*)utf16_path,
-						      wim_const_security_data(args->w));
-			if (ret)
-				goto out_free_utf16_path;
-		}
-		if (inode->i_nlink > 1) {
-			/* Save extracted path for a later call to
-			 * CreateHardLinkW() if this inode has multiple links.
-			 * */
-			inode->i_extracted_file = utf16_path;
-			goto out;
-		}
-	}
-out_free_utf16_path:
-	FREE(utf16_path);
-out:
-	return ret;
-#else
 	if (inode_is_symlink(inode))
 		return extract_symlink(dentry, args, output_path);
 	else if (inode_is_directory(inode))
@@ -742,116 +424,128 @@ out:
 					 output_path, false);
 	else
 		return extract_regular_file(dentry, args, output_path);
-#endif
 }
 
-/* Apply timestamps to an extracted file or directory */
-static int apply_dentry_timestamps_normal(struct wim_dentry *dentry, void *arg)
+static int
+unix_do_apply_dentry_timestamps(const char *output_path,
+				size_t output_path_len,
+				const struct wim_dentry *dentry,
+				struct apply_args *args)
 {
-	struct apply_args *args = arg;
-	size_t len;
-	char *output_path;
 	int ret;
 	const struct wim_inode *inode = dentry->d_inode;
 
-	len = strlen(args->target);
-	if (dentry_is_root(dentry)) {
-		output_path = (char*)args->target;
-	} else {
-		output_path = alloca(len + dentry->full_path_utf8_len + 1);
-		memcpy(output_path, args->target, len);
-		memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len);
-		output_path[len + dentry->full_path_utf8_len] = '\0';
-		len += dentry->full_path_utf8_len;
-	}
-
-#if defined(__CYGWIN__) || defined(__WIN32__)
-	/* Win32 */
-	char *utf16_path;
-	size_t utf16_path_len;
-	DWORD err;
-	HANDLE h;
-	BOOL bret1, bret2;
+#ifdef HAVE_UTIMENSAT
+	/* Convert the WIM timestamps, which are accurate to 100 nanoseconds,
+	 * into `struct timespec's for passing to utimensat(), which is accurate
+	 * to 1 nanosecond. */
 
-	ret = utf8_to_utf16(output_path, len, &utf16_path, &utf16_path_len);
+	struct timespec ts[2];
+	ts[0] = wim_timestamp_to_timespec(inode->i_last_access_time);
+	ts[1] = wim_timestamp_to_timespec(inode->i_last_write_time);
+	ret = utimensat(AT_FDCWD, output_path, ts, AT_SYMLINK_NOFOLLOW);
 	if (ret)
-		return ret;
+		ret = errno;
+#else
+	ret = ENOSYS;
+#endif
 
-	DEBUG("Opening \"%ls\" to set timestamps", utf16_path);
-	h = CreateFileW((const wchar_t*)utf16_path,
-			GENERIC_WRITE,
-			FILE_SHARE_READ,
-			NULL,
-			OPEN_EXISTING,
-			FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
-			NULL);
-
-	if (h == INVALID_HANDLE_VALUE)
-		err = GetLastError();
-	FREE(utf16_path);
-	if (h == INVALID_HANDLE_VALUE)
-		goto fail;
-
-	FILETIME creationTime = {.dwLowDateTime = dentry->d_inode->i_creation_time & 0xffffffff,
-				 .dwHighDateTime = dentry->d_inode->i_creation_time >> 32};
-	FILETIME lastAccessTime = {.dwLowDateTime = dentry->d_inode->i_last_access_time & 0xffffffff,
-				  .dwHighDateTime = dentry->d_inode->i_last_access_time >> 32};
-	FILETIME lastWriteTime = {.dwLowDateTime = dentry->d_inode->i_last_write_time & 0xffffffff,
-				  .dwHighDateTime = dentry->d_inode->i_last_write_time >> 32};
-
-	DEBUG("Calling SetFileTime() on \"%s\"", output_path);
-	if (!SetFileTime(h, &creationTime, &lastAccessTime, &lastWriteTime)) {
-		err = GetLastError();
-		CloseHandle(h);
-		goto fail;
+	if (ret == ENOSYS) {
+		/* utimensat() not implemented or not available */
+	#ifdef HAVE_LUTIMES
+		/* Convert the WIM timestamps, which are accurate to 100
+		 * nanoseconds, into `struct timeval's for passing to lutimes(),
+		 * which is accurate to 1 microsecond. */
+		struct timeval tv[2];
+		tv[0] = wim_timestamp_to_timeval(inode->i_last_access_time);
+		tv[1] = wim_timestamp_to_timeval(inode->i_last_write_time);
+		ret = lutimes(output_path, tv);
+		if (ret)
+			ret = errno;
+	#endif
+	}
+
+	if (ret == ENOSYS) {
+		/* utimensat() and lutimes() both not implemented or not
+		 * available */
+	#ifdef HAVE_UTIME
+		/* Convert the WIM timestamps, which are accurate to 100
+		 * nanoseconds, into a `struct utimbuf's for passing to
+		 * utime(), which is accurate to 1 second. */
+		struct utimbuf buf;
+		buf.actime = wim_timestamp_to_unix(inode->i_last_access_time);
+		buf.modtime = wim_timestamp_to_unix(inode->i_last_write_time);
+		ret = utime(output_path, &buf);
+	#endif
 	}
-	DEBUG("Closing \"%s\"", output_path);
-	if (!CloseHandle(h)) {
-		err = GetLastError();
-		goto fail;
+	if (ret && args->num_utime_warnings < 10) {
+		WARNING_WITH_ERRNO("Failed to set timestamp on file `%s'",
+				    output_path);
+		args->num_utime_warnings++;
 	}
 	return 0;
-fail:
-	ERROR("Can't set timestamps on \"%s\"", output_path);
-	win32_error(err);
-	return WIMLIB_ERR_WRITE;
+}
+#endif /* !__WIN32__ */
+
+/* Extracts a file, directory, or symbolic link from the WIM archive. */
+static int
+apply_dentry_normal(struct wim_dentry *dentry, void *arg)
+{
+	struct apply_args *args = arg;
+	tchar *output_path;
+	size_t len;
+
+	len = tstrlen(args->target);
+	if (dentry_is_root(dentry)) {
+		output_path = (tchar*)args->target;
+	} else {
+		output_path = alloca(len * sizeof(tchar) + dentry->full_path_nbytes +
+				     sizeof(tchar));
+		memcpy(output_path, args->target, len * sizeof(tchar));
+		memcpy(output_path + len, dentry->full_path, dentry->full_path_nbytes);
+		len += dentry->full_path_nbytes / sizeof(tchar);
+		output_path[len] = T('\0');
+	}
+#ifdef __WIN32__
+	return win32_do_apply_dentry(output_path, len, dentry, args);
 #else
-	/* UNIX */
+	return unix_do_apply_dentry(output_path, len, dentry, args);
+#endif
+}
 
-	/* Convert the WIM timestamps, which are accurate to 100 nanoseconds,
-	 * into struct timeval's. */
-	struct timeval tv[2];
-	wim_timestamp_to_timeval(inode->i_last_access_time, &tv[0]);
-	wim_timestamp_to_timeval(inode->i_last_write_time, &tv[1]);
-	#ifdef HAVE_LUTIMES
-	ret = lutimes(output_path, tv);
-	#else
-	ret = -1;
-	errno = ENOSYS;
-	#endif
-	if (ret != 0) {
-		#ifdef HAVE_UTIME
-		if (errno == ENOSYS) {
-			struct utimbuf buf;
-			buf.actime = wim_timestamp_to_unix(inode->i_last_access_time);
-			buf.modtime = wim_timestamp_to_unix(inode->i_last_write_time);
-			if (utime(output_path, &buf) == 0)
-				return 0;
-		}
-		#endif
-		if (errno != ENOSYS || args->num_lutimes_warnings < 10) {
-			/*WARNING_WITH_ERRNO("Failed to set timestamp on file `%s',*/
-					    /*output_path");*/
-			args->num_lutimes_warnings++;
-		}
+
+/* Apply timestamps to an extracted file or directory */
+static int
+apply_dentry_timestamps_normal(struct wim_dentry *dentry, void *arg)
+{
+	struct apply_args *args = arg;
+	size_t len;
+	tchar *output_path;
+
+	len = tstrlen(args->target);
+	if (dentry_is_root(dentry)) {
+		output_path = (tchar*)args->target;
+	} else {
+		output_path = alloca(len * sizeof(tchar) + dentry->full_path_nbytes +
+				     sizeof(tchar));
+		memcpy(output_path, args->target, len * sizeof(tchar));
+		memcpy(output_path + len, dentry->full_path, dentry->full_path_nbytes);
+		len += dentry->full_path_nbytes / sizeof(tchar);
+		output_path[len] = T('\0');
 	}
-	return 0;
+
+
+#ifdef __WIN32__
+	return win32_do_apply_dentry_timestamps(output_path, len, dentry, args);
+#else
+	return unix_do_apply_dentry_timestamps(output_path, len, dentry, args);
 #endif
 }
 
 /* Extract a dentry if it hasn't already been extracted, and either the dentry
  * has no streams or WIMLIB_EXTRACT_FLAG_NO_STREAMS is not specified. */
-static int maybe_apply_dentry(struct wim_dentry *dentry, void *arg)
+static int
+maybe_apply_dentry(struct wim_dentry *dentry, void *arg)
 {
 	struct apply_args *args = arg;
 	int ret;
@@ -865,7 +559,7 @@ static int maybe_apply_dentry(struct wim_dentry *dentry, void *arg)
 
 	if ((args->extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) &&
 	     args->progress_func) {
-		args->progress.extract.cur_path = dentry->full_path_utf8;
+		args->progress.extract.cur_path = dentry->full_path;
 		args->progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY,
 				    &args->progress);
 	}
@@ -875,55 +569,10 @@ static int maybe_apply_dentry(struct wim_dentry *dentry, void *arg)
 	return ret;
 }
 
-static int cmp_streams_by_wim_position(const void *p1, const void *p2)
-{
-	const struct wim_lookup_table_entry *lte1, *lte2;
-	lte1 = *(const struct wim_lookup_table_entry**)p1;
-	lte2 = *(const struct wim_lookup_table_entry**)p2;
-	if (lte1->resource_entry.offset < lte2->resource_entry.offset)
-		return -1;
-	else if (lte1->resource_entry.offset > lte2->resource_entry.offset)
-		return 1;
-	else
-		return 0;
-}
-
-static int sort_stream_list_by_wim_position(struct list_head *stream_list)
-{
-	struct list_head *cur;
-	size_t num_streams;
-	struct wim_lookup_table_entry **array;
-	size_t i;
-	size_t array_size;
-
-	num_streams = 0;
-	list_for_each(cur, stream_list)
-		num_streams++;
-	array_size = num_streams * sizeof(array[0]);
-	array = MALLOC(array_size);
-	if (!array) {
-		ERROR("Failed to allocate %zu bytes to sort stream entries",
-		      array_size);
-		return WIMLIB_ERR_NOMEM;
-	}
-	cur = stream_list->next;
-	for (i = 0; i < num_streams; i++) {
-		array[i] = container_of(cur, struct wim_lookup_table_entry, staging_list);
-		cur = cur->next;
-	}
-
-	qsort(array, num_streams, sizeof(array[0]), cmp_streams_by_wim_position);
-
-	INIT_LIST_HEAD(stream_list);
-	for (i = 0; i < num_streams; i++)
-		list_add_tail(&array[i]->staging_list, stream_list);
-	FREE(array);
-	return 0;
-}
-
-static void calculate_bytes_to_extract(struct list_head *stream_list,
-				       int extract_flags,
-				       union wimlib_progress_info *progress)
+static void
+calculate_bytes_to_extract(struct list_head *stream_list,
+			   int extract_flags,
+			   union wimlib_progress_info *progress)
 {
 	struct wim_lookup_table_entry *lte;
 	u64 total_bytes = 0;
@@ -952,8 +601,9 @@ static void calculate_bytes_to_extract(struct list_head *stream_list,
 	progress->extract.completed_bytes = 0;
 }
 
-static void maybe_add_stream_for_extraction(struct wim_lookup_table_entry *lte,
-					    struct list_head *stream_list)
+static void
+maybe_add_stream_for_extraction(struct wim_lookup_table_entry *lte,
+				struct list_head *stream_list)
 {
 	if (++lte->out_refcnt == 1) {
 		INIT_LIST_HEAD(&lte->inode_list);
@@ -961,9 +611,10 @@ static void maybe_add_stream_for_extraction(struct wim_lookup_table_entry *lte,
 	}
 }
 
-static void inode_find_streams_for_extraction(struct wim_inode *inode,
-					      struct list_head *stream_list,
-					      int extract_flags)
+static void
+inode_find_streams_for_extraction(struct wim_inode *inode,
+				  struct list_head *stream_list,
+				  int extract_flags)
 {
 	struct wim_lookup_table_entry *lte;
 	bool inode_added = false;
@@ -977,7 +628,7 @@ static void inode_find_streams_for_extraction(struct wim_inode *inode,
 #ifdef WITH_NTFS_3G
 	if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
 		for (unsigned i = 0; i < inode->i_num_ads; i++) {
-			if (inode->i_ads_entries[i].stream_name_len != 0) {
+			if (inode->i_ads_entries[i].stream_name_nbytes != 0) {
 				lte = inode->i_ads_entries[i].lte;
 				if (lte) {
 					maybe_add_stream_for_extraction(lte,
@@ -994,10 +645,11 @@ static void inode_find_streams_for_extraction(struct wim_inode *inode,
 #endif
 }
 
-static void find_streams_for_extraction(struct hlist_head *inode_list,
-					struct list_head *stream_list,
-					struct wim_lookup_table *lookup_table,
-					int extract_flags)
+static void
+find_streams_for_extraction(struct hlist_head *inode_list,
+			    struct list_head *stream_list,
+			    struct wim_lookup_table *lookup_table,
+			    int extract_flags)
 {
 	struct wim_inode *inode;
 	struct hlist_node *cur;
@@ -1032,10 +684,11 @@ static const struct apply_operations ntfs_apply_operations = {
 };
 #endif
 
-static int apply_stream_list(struct list_head *stream_list,
-			     struct apply_args *args,
-			     const struct apply_operations *ops,
-			     wimlib_progress_func_t progress_func)
+static int
+apply_stream_list(struct list_head *stream_list,
+		  struct apply_args *args,
+		  const struct apply_operations *ops,
+		  wimlib_progress_func_t progress_func)
 {
 	uint64_t bytes_per_progress = args->progress.extract.total_bytes / 100;
 	uint64_t next_progress = bytes_per_progress;
@@ -1087,9 +740,10 @@ static int apply_stream_list(struct list_head *stream_list,
 
 /* Extracts the image @image from the WIM @w to the directory or NTFS volume
  * @target. */
-static int extract_single_image(WIMStruct *w, int image,
-				const char *target, int extract_flags,
-				wimlib_progress_func_t progress_func)
+static int
+extract_single_image(WIMStruct *w, int image,
+		     const tchar *target, int extract_flags,
+		     wimlib_progress_func_t progress_func)
 {
 	int ret;
 	struct list_head stream_list;
@@ -1098,12 +752,12 @@ static int extract_single_image(WIMStruct *w, int image,
 	struct apply_args args;
 	const struct apply_operations *ops;
 
-	args.w                    = w;
-	args.target               = target;
-	args.extract_flags        = extract_flags;
-	args.num_lutimes_warnings = 0;
-	args.stream_list          = &stream_list;
-	args.progress_func	  = progress_func;
+	memset(&args, 0, sizeof(args));
+
+	args.w                  = w;
+	args.target             = target;
+	args.extract_flags      = extract_flags;
+	args.progress_func      = progress_func;
 
 	if (progress_func) {
 		args.progress.extract.wimfile_name = w->filename;
@@ -1118,7 +772,8 @@ static int extract_single_image(WIMStruct *w, int image,
 	if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
 		args.vol = ntfs_mount(target, 0);
 		if (!args.vol) {
-			ERROR_WITH_ERRNO("Failed to mount NTFS volume `%s'", target);
+			ERROR_WITH_ERRNO("Failed to mount NTFS volume `%"TS"'",
+					 target);
 			return WIMLIB_ERR_NTFS_3G;
 		}
 		ops = &ntfs_apply_operations;
@@ -1199,7 +854,8 @@ out:
 	/* Unmount the NTFS volume */
 	if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
 		if (ntfs_umount(args.vol, FALSE) != 0) {
-			ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%s'", args.target);
+			ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%"TS"'",
+					 args.target);
 			if (ret == 0)
 				ret = WIMLIB_ERR_NTFS_3G;
 		}
@@ -1208,33 +864,53 @@ out:
 	return ret;
 }
 
+static const tchar *filename_forbidden_chars = 
+T(
+#ifdef __WIN32__
+"<>:\"/\\|?*"
+#else
+"/"
+#endif
+);
+
+/* This function checks if it is okay to use a WIM image's name as a directory
+ * name.  */
+static bool
+image_name_ok_as_dir(const tchar *image_name)
+{
+	return image_name && *image_name &&
+		!tstrpbrk(image_name, filename_forbidden_chars);
+}
 
 /* Extracts all images from the WIM to the directory @target, with the images
  * placed in subdirectories named by their image names. */
-static int extract_all_images(WIMStruct *w, const char *target,
-			      int extract_flags,
-			      wimlib_progress_func_t progress_func)
+static int
+extract_all_images(WIMStruct *w,
+		   const tchar *target,
+		   int extract_flags,
+		   wimlib_progress_func_t progress_func)
 {
 	size_t image_name_max_len = max(xml_get_max_image_name_len(w), 20);
-	size_t output_path_len = strlen(target);
-	char buf[output_path_len + 1 + image_name_max_len + 1];
+	size_t output_path_len = tstrlen(target);
+	tchar buf[output_path_len + 1 + image_name_max_len + 1];
 	int ret;
 	int image;
-	const char *image_name;
+	const tchar *image_name;
 
 	ret = extract_directory(NULL, target, true);
-	if (ret != 0)
+	if (ret)
 		return ret;
 
-	memcpy(buf, target, output_path_len);
-	buf[output_path_len] = '/';
+	tmemcpy(buf, target, output_path_len);
+	buf[output_path_len] = T('/');
 	for (image = 1; image <= w->hdr.image_count; image++) {
 		image_name = wimlib_get_image_name(w, image);
-		if (image_name && *image_name) {
-			strcpy(buf + output_path_len + 1, image_name);
+		if (image_name_ok_as_dir(image_name)) {
+			tstrcpy(buf + output_path_len + 1, image_name);
 		} else {
-			/* Image name is empty. Use image number instead */
-			sprintf(buf + output_path_len + 1, "%d", image);
+			/* Image name is empty, or contains forbidden
+			 * characters. */
+			tsprintf(buf + output_path_len + 1, T("%d"), image);
 		}
 		ret = extract_single_image(w, image, buf, extract_flags,
 					   progress_func);
@@ -1246,13 +922,14 @@ static int extract_all_images(WIMStruct *w, const char *target,
 
 /* Extracts a single image or all images from a WIM file to a directory or NTFS
  * volume. */
-WIMLIBAPI int wimlib_extract_image(WIMStruct *w,
-				   int image,
-				   const char *target,
-				   int extract_flags,
-				   WIMStruct **additional_swms,
-				   unsigned num_additional_swms,
-				   wimlib_progress_func_t progress_func)
+WIMLIBAPI int
+wimlib_extract_image(WIMStruct *w,
+		     int image,
+		     const tchar *target,
+		     int extract_flags,
+		     WIMStruct **additional_swms,
+		     unsigned num_additional_swms,
+		     wimlib_progress_func_t progress_func)
 {
 	struct wim_lookup_table *joined_tab, *w_tab_save;
 	int ret;
@@ -1266,7 +943,7 @@ WIMLIBAPI int wimlib_extract_image(WIMStruct *w,
 			== (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))
 		return WIMLIB_ERR_INVALID_PARAM;
 
-#if defined(__CYGWIN__) || defined(__WIN32__)
+#ifdef __WIN32__
 	if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) {
 		ERROR("Extracting UNIX data is not supported on Windows");
 		return WIMLIB_ERR_INVALID_PARAM;