X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fadd_image.c;h=67a354e4b27b0e3424f020de322a0d22adfc1a3f;hp=fa3e77b04d33224c906af258a7d8b1a69c32f3e9;hb=7acdc3aecd7ce546727ae8239e0d942c2a00db43;hpb=ebd6c0ec0ff47ac18af4ef918fd78fb8d9f19540

diff --git a/src/add_image.c b/src/add_image.c
index fa3e77b0..67a354e4 100644
--- a/src/add_image.c
+++ b/src/add_image.c
@@ -21,51 +21,32 @@
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
+#include "config.h"
 
-#if defined(__CYGWIN__) || defined(__WIN32__)
-#	include <windows.h>
-#	include <ntdef.h>
-#	include <wchar.h>
-#	include <sys/cygwin.h>
-#	include <fcntl.h>
-#	ifdef ERROR
-#		undef ERROR
-#	endif
-#	include "security.h"
+#ifdef __WIN32__
+#  include "win32.h"
+#else
+#  include <dirent.h>
+#  include <sys/stat.h>
+#  include <fnmatch.h>
+#  include "timestamp.h"
 #endif
 
 #include "wimlib_internal.h"
 #include "dentry.h"
-#include "timestamp.h"
 #include "lookup_table.h"
 #include "xml.h"
-#include <string.h>
-#include <fnmatch.h>
-#include <stdlib.h>
+
 #include <ctype.h>
-#include <sys/stat.h>
-#include <dirent.h>
 #include <errno.h>
+#include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
-#if defined(__CYGWIN__) || defined(__WIN32__)
-/*#define ERROR_WIN32_SAFE(format, ...)		\*/
-/*{(						\*/
-          /*DWORD err = GetLastError();		\*/
-	/*ERROR(format, ##__VA_ARGS__);		\*/
-	/*SetLastError(err);			\*/
-/*)}*/
-#define DEBUG_WIN32_SAFE(format, ...)		\
-({						\
-	DWORD err = GetLastError();		\
-	DEBUG(format, ##__VA_ARGS__);		\
-	SetLastError(err);			\
-})
+#ifdef HAVE_ALLOCA_H
+#  include <alloca.h>
 #endif
 
-#define WIMLIB_ADD_IMAGE_FLAG_ROOT	0x80000000
-#define WIMLIB_ADD_IMAGE_FLAG_SOURCE    0x40000000
-
 /*
  * Adds the dentry tree and security data for a new image to the image metadata
  * array of the WIMStruct.
@@ -117,413 +98,7 @@ err:
 
 }
 
-#if defined(__CYGWIN__) || defined(__WIN32__)
-static u64 FILETIME_to_u64(const FILETIME *ft)
-{
-	return ((u64)ft->dwHighDateTime << 32) | (u64)ft->dwLowDateTime;
-}
-
-#ifdef ENABLE_ERROR_MESSAGES
-static void win32_error(DWORD err_code)
-{
-	char *buffer;
-	DWORD nchars;
-	nchars = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
-				NULL, err_code, 0,
-				(char*)&buffer, 0, NULL);
-	if (nchars == 0) {
-		ERROR("Error printing error message! "
-		      "Computer will self-destruct in 3 seconds.");
-	} else {
-		ERROR("Win32 error: %s", buffer);
-		LocalFree(buffer);
-	}
-}
-#else
-#define win32_error(err_code)
-#endif
-
-static HANDLE win32_open_file(const wchar_t *path)
-{
-	return CreateFileW(path,
-			   GENERIC_READ | READ_CONTROL,
-			   FILE_SHARE_READ,
-			   NULL, /* lpSecurityAttributes */
-			   OPEN_EXISTING,
-			   FILE_FLAG_BACKUP_SEMANTICS |
-				   FILE_FLAG_OPEN_REPARSE_POINT,
-			   NULL /* hTemplateFile */);
-}
-
-int win32_read_file(const char *filename,
-		    void *handle, u64 offset, size_t size, u8 *buf)
-{
-	HANDLE h = handle;
-	DWORD err;
-	DWORD bytesRead;
-	LARGE_INTEGER liOffset = {.QuadPart = offset};
-
-	wimlib_assert(size <= 0xffffffff);
-
-	if (SetFilePointerEx(h, liOffset, NULL, FILE_BEGIN))
-		if (ReadFile(h, buf, size, &bytesRead, NULL) && bytesRead == size)
-			return 0;
-	err = GetLastError();
-	ERROR("Error reading \"%s\"", filename);
-	win32_error(err);
-	return WIMLIB_ERR_READ;
-}
-
-void win32_close_handle(void *handle)
-{
-	CloseHandle((HANDLE)handle);
-}
-
-void *win32_open_handle(const char *path_utf16)
-{
-	return (void*)win32_open_file((const wchar_t*)path_utf16);
-}
-
-static int build_dentry_tree(struct wim_dentry **root_ret,
-			     const char *root_disk_path,
-			     struct wim_lookup_table *lookup_table,
-			     struct wim_security_data *sd,
-			     const struct capture_config *config,
-			     int add_image_flags,
-			     wimlib_progress_func_t progress_func,
-			     void *extra_arg);
-
-static int win32_get_short_name(struct wim_dentry *dentry,
-				const wchar_t *path_utf16)
-{
-	WIN32_FIND_DATAW dat;
-	if (FindFirstFileW(path_utf16, &dat) &&
-	    dat.cAlternateFileName[0] != L'\0')
-	{
-		size_t short_name_len = wcslen(dat.cAlternateFileName) * 2;
-		size_t n = short_name_len + sizeof(wchar_t);
-		dentry->short_name = MALLOC(n);
-		if (!dentry->short_name)
-			return WIMLIB_ERR_NOMEM;
-		memcpy(dentry->short_name, dat.cAlternateFileName, n);
-		dentry->short_name_len = short_name_len;
-	}
-	return 0;
-}
-
-static int win32_get_security_descriptor(struct wim_dentry *dentry,
-					 struct sd_set *sd_set,
-					 const wchar_t *path_utf16,
-					 const char *path)
-{
-	SECURITY_INFORMATION requestedInformation;
-	DWORD lenNeeded = 0;
-	BOOL status;
-	DWORD err;
-
-#ifdef BACKUP_SECURITY_INFORMATION
-	requestedInformation = BACKUP_SECURITY_INFORMATION;
-#else
-	requestedInformation = DACL_SECURITY_INFORMATION |
-			       SACL_SECURITY_INFORMATION |
-			       OWNER_SECURITY_INFORMATION |
-			       GROUP_SECURITY_INFORMATION;
-#endif
-	/* Request length of security descriptor */
-	status = GetFileSecurityW(path_utf16, requestedInformation,
-				  NULL, 0, &lenNeeded);
-	err = GetLastError();
-
-	/* Error code appears to be ERROR_INSUFFICIENT_BUFFER but
-	 * GetFileSecurity is poorly documented... */
-	if (err == ERROR_INSUFFICIENT_BUFFER || err == NO_ERROR) {
-		DWORD len = lenNeeded;
-		char buf[len];
-		if (GetFileSecurityW(path_utf16, requestedInformation,
-				     buf, len, &lenNeeded))
-		{
-			int security_id = sd_set_add_sd(sd_set, buf, len);
-			if (security_id < 0)
-				return WIMLIB_ERR_NOMEM;
-			else {
-				dentry->d_inode->i_security_id = security_id;
-				return 0;
-			}
-		} else {
-			err = GetLastError();
-		}
-	}
-	ERROR("Win32 API: Failed to read security descriptor of \"%s\"",
-	      path);
-	win32_error(err);
-	return WIMLIB_ERR_READ;
-}
-
-
-static int win32_recurse_directory(struct wim_dentry *root,
-				   const char *root_disk_path,
-				   struct wim_lookup_table *lookup_table,
-				   struct wim_security_data *sd,
-				   const struct capture_config *config,
-				   int add_image_flags,
-				   wimlib_progress_func_t progress_func,
-				   struct sd_set *sd_set,
-				   const wchar_t *path_utf16,
-				   size_t path_utf16_nchars)
-{
-	WIN32_FIND_DATAW dat;
-	HANDLE hFind;
-	DWORD err;
-	int ret;
-
-	{
-		wchar_t pattern_buf[path_utf16_nchars + 3];
-		memcpy(pattern_buf, path_utf16,
-		       path_utf16_nchars * sizeof(wchar_t));
-		pattern_buf[path_utf16_nchars] = L'/';
-		pattern_buf[path_utf16_nchars + 1] = L'*';
-		pattern_buf[path_utf16_nchars + 2] = L'\0';
-		hFind = FindFirstFileW(pattern_buf, &dat);
-	}
-	if (hFind == INVALID_HANDLE_VALUE) {
-		err = GetLastError();
-		if (err == ERROR_FILE_NOT_FOUND) {
-			return 0;
-		} else {
-			ERROR("Win32 API: Failed to read directory \"%s\"",
-			      root_disk_path);
-			win32_error(err);
-			return WIMLIB_ERR_READ;
-		}
-	}
-	ret = 0;
-	do {
-		if (!(dat.cFileName[0] == L'.' &&
-		      (dat.cFileName[1] == L'\0' ||
-		       (dat.cFileName[1] == L'.' && dat.cFileName[2] == L'\0'))))
-		{
-			struct wim_dentry *child;
-
-			char *utf8_name;
-			size_t utf8_name_nbytes;
-			ret = utf16_to_utf8((const char*)dat.cFileName,
-					    wcslen(dat.cFileName) * sizeof(wchar_t),
-					    &utf8_name,
-					    &utf8_name_nbytes);
-			if (ret)
-				goto out_find_close;
-
-			char name[strlen(root_disk_path) + utf8_name_nbytes + 1];
-			sprintf(name, "%s/%s", root_disk_path, utf8_name);
-			FREE(utf8_name);
-			ret = build_dentry_tree(&child, name, lookup_table,
-						sd, config, add_image_flags,
-						progress_func, sd_set);
-			if (ret)
-				goto out_find_close;
-			if (child)
-				dentry_add_child(root, child);
-		}
-	} while (FindNextFileW(hFind, &dat));
-	err = GetLastError();
-	if (err != ERROR_NO_MORE_FILES) {
-		ERROR("Win32 API: Failed to read directory \"%s\"", root_disk_path);
-		win32_error(err);
-		if (ret == 0)
-			ret = WIMLIB_ERR_READ;
-	}
-out_find_close:
-	FindClose(hFind);
-	return ret;
-}
-
-static int win32_capture_reparse_point(const char *path,
-				       HANDLE hFile,
-				       struct wim_inode *inode,
-				       struct wim_lookup_table *lookup_table)
-{
-	/* "Reparse point data, including the tag and optional GUID,
-	 * cannot exceed 16 kilobytes." - MSDN  */
-	char reparse_point_buf[16 * 1024];
-	DWORD bytesReturned;
-	const REPARSE_DATA_BUFFER *buf;
-
-	if (!DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT,
-			     NULL, 0, reparse_point_buf,
-			     sizeof(reparse_point_buf), &bytesReturned, NULL))
-	{
-		ERROR("Win32 API: Failed to get reparse data of \"%s\"", path);
-		return WIMLIB_ERR_READ;
-	}
-	buf = (const REPARSE_DATA_BUFFER*)reparse_point_buf;
-	inode->i_reparse_tag = buf->ReparseTag;
-	return inode_add_ads_with_data(inode, "", (const u8*)buf + 8,
-				       bytesReturned - 8, lookup_table);
-}
-
-static int win32_sha1sum(const wchar_t *path, u8 hash[SHA1_HASH_SIZE])
-{
-	HANDLE hFile;
-	SHA_CTX ctx;
-	u8 buf[32768];
-	DWORD bytesRead;
-	int ret;
-
-	hFile = win32_open_file(path);
-	if (hFile == INVALID_HANDLE_VALUE)
-		return WIMLIB_ERR_OPEN;
-
-	sha1_init(&ctx);
-	for (;;) {
-		if (!ReadFile(hFile, buf, sizeof(buf), &bytesRead, NULL)) {
-			ret = WIMLIB_ERR_READ;
-			goto out_close_handle;
-		}
-		if (bytesRead == 0)
-			break;
-		sha1_update(&ctx, buf, bytesRead);
-	}
-	ret = 0;
-	sha1_final(hash, &ctx);
-out_close_handle:
-	CloseHandle(hFile);
-	return ret;
-}
-
-static int win32_capture_stream(const char *path,
-				const wchar_t *path_utf16,
-				size_t path_utf16_nchars,
-				struct wim_inode *inode,
-				struct wim_lookup_table *lookup_table,
-				WIN32_FIND_STREAM_DATA *dat)
-{
-	struct wim_ads_entry *ads_entry;
-	u8 hash[SHA1_HASH_SIZE];
-	struct wim_lookup_table_entry *lte;
-	int ret;
-	wchar_t *p, *colon;
-	bool is_named_stream;
-	wchar_t *spath;
-	size_t spath_nchars;
-	DWORD err;
-
-	p = dat->cStreamName;
-	wimlib_assert(*p == L':');
-	p += 1;
-	colon = wcschr(p, L':');
-	wimlib_assert(colon != NULL);
-
-	if (wcscmp(colon + 1, L"$DATA")) {
-		/* Not a DATA stream */
-		ret = 0;
-		goto out;
-	}
-
-	is_named_stream = (p != colon);
-
-	if (is_named_stream) {
-		char *utf8_stream_name;
-		size_t utf8_stream_name_len;
-		ret = utf16_to_utf8((const char *)p,
-				    colon - p,
-				    &utf8_stream_name,
-				    &utf8_stream_name_len);
-		if (ret)
-			goto out;
-		DEBUG_WIN32_SAFE("Add alternate data stream %s:%s", path, utf8_stream_name);
-		ads_entry = inode_add_ads(inode, utf8_stream_name);
-		FREE(utf8_stream_name);
-		if (!ads_entry) {
-			ret = WIMLIB_ERR_NOMEM;
-			goto out;
-		}
-	}
-
-	*colon = '\0';
-	spath_nchars = path_utf16_nchars;
-	if (is_named_stream)
-		spath_nchars += colon - p + 1;
-
-	spath = MALLOC((spath_nchars + 1) * sizeof(wchar_t));
-	memcpy(spath, path_utf16, path_utf16_nchars * sizeof(wchar_t));
-	if (is_named_stream) {
-		spath[path_utf16_nchars] = L':';
-		memcpy(&spath[path_utf16_nchars + 1], p, (colon - p) * sizeof(wchar_t));
-	}
-	spath[spath_nchars] = L'\0';
-
-	ret = win32_sha1sum(spath, hash);
-	if (ret) {
-		err = GetLastError();
-		ERROR("Win32 API: Failed to read \"%s\" to calculate SHA1sum", path);
-		win32_error(err);
-		goto out_free_spath;
-	}
-
-	lte = __lookup_resource(lookup_table, hash);
-	if (lte) {
-		lte->refcnt++;
-	} else {
-		lte = new_lookup_table_entry();
-		if (!lte) {
-			ret = WIMLIB_ERR_NOMEM;
-			goto out_free_spath;
-		}
-		lte->file_on_disk = (char*)spath;
-		spath = NULL;
-		lte->resource_location = RESOURCE_WIN32;
-		lte->resource_entry.original_size = (uint64_t)dat->StreamSize.QuadPart;
-		lte->resource_entry.size = (uint64_t)dat->StreamSize.QuadPart;
-		copy_hash(lte->hash, hash);
-		lookup_table_insert(lookup_table, lte);
-	}
-	if (is_named_stream)
-		ads_entry->lte = lte;
-	else
-		inode->i_lte = lte;
-out_free_spath:
-	FREE(spath);
-out:
-	return ret;
-}
-
-static int win32_capture_streams(const char *path,
-				 const wchar_t *path_utf16,
-				 size_t path_utf16_nchars,
-				 struct wim_inode *inode,
-				 struct wim_lookup_table *lookup_table)
-{
-	WIN32_FIND_STREAM_DATA dat;
-	int ret;
-	HANDLE hFind;
-	DWORD err;
-
-	hFind = FindFirstStreamW(path_utf16, FindStreamInfoStandard, &dat, 0);
-	if (hFind == INVALID_HANDLE_VALUE) {
-		ERROR("Win32 API: Failed to look up data streams of \"%s\"",
-		      path);
-		return WIMLIB_ERR_READ;
-	}
-	do {
-		ret = win32_capture_stream(path, path_utf16,
-					   path_utf16_nchars,
-					   inode, lookup_table,
-					   &dat);
-		if (ret)
-			goto out_find_close;
-	} while (FindNextStreamW(hFind, &dat));
-	err = GetLastError();
-	if (err != ERROR_HANDLE_EOF) {
-		ERROR("Win32 API: Error reading data streams from \"%s\"", path);
-		win32_error(err);
-		ret = WIMLIB_ERR_READ;
-	}
-out_find_close:
-	FindClose(hFind);
-	return ret;
-}
-#endif
-
+#ifndef __WIN32__
 /*
  * build_dentry_tree():
  * 	Recursively builds a tree of WIM dentries from an on-disk directory
@@ -533,7 +108,7 @@ out_find_close:
  *		modified if successful.  Set to NULL if the file or directory was
  *		excluded from capture.
  *
- * @root_disk_path:  The path to the root of the directory tree on disk.
+ * @root_disk_path:  The path to the root of the directory tree on disk (UTF-8).
  *
  * @lookup_table: The lookup table for the WIM file.  For each file added to the
  * 		dentry tree being built, an entry is added to the lookup table,
@@ -548,7 +123,8 @@ out_find_close:
  *
  * @add_flags:  Bitwise or of WIMLIB_ADD_IMAGE_FLAG_*
  *
- * @extra_arg:	Ignored. (Only used in NTFS mode.)
+ * @extra_arg:	Ignored in UNIX builds; used to pass sd_set pointer in Windows
+ *		builds.
  *
  * @return:	0 on success, nonzero on failure.  It is a failure if any of
  *		the files cannot be `stat'ed, or if any of the needed
@@ -557,14 +133,14 @@ out_find_close:
  *		the on-disk files during a call to wimlib_write() or
  *		wimlib_overwrite().
  */
-static int build_dentry_tree(struct wim_dentry **root_ret,
-			     const char *root_disk_path,
-			     struct wim_lookup_table *lookup_table,
-			     struct wim_security_data *sd,
-			     const struct capture_config *config,
-			     int add_image_flags,
-			     wimlib_progress_func_t progress_func,
-			     void *extra_arg)
+static int unix_build_dentry_tree(struct wim_dentry **root_ret,
+				  const char *root_disk_path,
+				  struct wim_lookup_table *lookup_table,
+				  struct wim_security_data *sd,
+				  const struct capture_config *config,
+				  int add_image_flags,
+				  wimlib_progress_func_t progress_func,
+				  void *extra_arg)
 {
 	struct wim_dentry *root = NULL;
 	int ret = 0;
@@ -596,7 +172,6 @@ static int build_dentry_tree(struct wim_dentry **root_ret,
 		progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
 	}
 
-#if !defined(__CYGWIN__) && !defined(__WIN32__)
 	/* UNIX version of capturing a directory tree */
 	struct stat root_stbuf;
 	int (*stat_fn)(const char *restrict, struct stat *restrict);
@@ -651,19 +226,23 @@ static int build_dentry_tree(struct wim_dentry **root_ret,
 	inode = root->d_inode;
 
 #ifdef HAVE_STAT_NANOSECOND_PRECISION
-	inode->i_creation_time = timespec_to_wim_timestamp(&root_stbuf.st_mtim);
-	inode->i_last_write_time = timespec_to_wim_timestamp(&root_stbuf.st_mtim);
-	inode->i_last_access_time = timespec_to_wim_timestamp(&root_stbuf.st_atim);
+	inode->i_creation_time = timespec_to_wim_timestamp(root_stbuf.st_mtim);
+	inode->i_last_write_time = timespec_to_wim_timestamp(root_stbuf.st_mtim);
+	inode->i_last_access_time = timespec_to_wim_timestamp(root_stbuf.st_atim);
 #else
 	inode->i_creation_time = unix_timestamp_to_wim(root_stbuf.st_mtime);
 	inode->i_last_write_time = unix_timestamp_to_wim(root_stbuf.st_mtime);
 	inode->i_last_access_time = unix_timestamp_to_wim(root_stbuf.st_atime);
 #endif
-	if (sizeof(ino_t) >= 8)
-		inode->i_ino = (u64)root_stbuf.st_ino;
-	else
-		inode->i_ino = (u64)root_stbuf.st_ino |
-				   ((u64)root_stbuf.st_dev << ((sizeof(ino_t) * 8) & 63));
+	/* Leave the inode number at 0 for directories. */
+	if (!S_ISDIR(root_stbuf.st_mode)) {
+		if (sizeof(ino_t) >= 8)
+			inode->i_ino = (u64)root_stbuf.st_ino;
+		else
+			inode->i_ino = (u64)root_stbuf.st_ino |
+					   ((u64)root_stbuf.st_dev <<
+					    	((sizeof(ino_t) * 8) & 63));
+	}
 	inode->i_resolved = 1;
 	if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) {
 		ret = inode_set_unix_data(inode, root_stbuf.st_uid,
@@ -761,9 +340,11 @@ static int build_dentry_tree(struct wim_dentry **root_ret,
 			      || (result->d_name[1] == '.' && result->d_name[2] == '\0')))
 					continue;
 			strcpy(name + len + 1, result->d_name);
-			ret = build_dentry_tree(&child, name, lookup_table,
-						NULL, config, add_image_flags,
-						progress_func, NULL);
+			ret = unix_build_dentry_tree(&child, name,
+						     lookup_table,
+						     NULL, config,
+						     add_image_flags,
+						     progress_func, NULL);
 			if (ret != 0)
 				break;
 			if (child)
@@ -813,122 +394,6 @@ static int build_dentry_tree(struct wim_dentry **root_ret,
 			ret = WIMLIB_ERR_READLINK;
 		}
 	}
-#else
-	/* Win32 version of capturing a directory tree */
-
-	wchar_t *path_utf16;
-	size_t path_utf16_nchars;
-	struct sd_set *sd_set;
-	DWORD err;
-
-	if (extra_arg == NULL) {
-		sd_set = alloca(sizeof(struct sd_set));
-		sd_set->rb_root.rb_node = NULL,
-		sd_set->sd = sd;
-	} else {
-		sd_set = extra_arg;
-	}
-
-	DEBUG_WIN32_SAFE("root_disk_path=\"%s\"", root_disk_path);
-	ret = utf8_to_utf16(root_disk_path, strlen(root_disk_path),
-			    (char**)&path_utf16, &path_utf16_nchars);
-	if (ret)
-		goto out_destroy_sd_set;
-	path_utf16_nchars /= sizeof(wchar_t);
-
-	DEBUG_WIN32_SAFE("Win32: Opening file `%s'", root_disk_path);
-	HANDLE hFile = win32_open_file(path_utf16);
-	if (hFile == INVALID_HANDLE_VALUE) {
-		err = GetLastError();
-		ERROR("Win32 API: Failed to open \"%s\"", root_disk_path);
-		win32_error(err);
-		ret = WIMLIB_ERR_OPEN;
-		goto out_free_path_utf16;
-	}
-
-	BY_HANDLE_FILE_INFORMATION file_info;
-	if (!GetFileInformationByHandle(hFile, &file_info)) {
-		err = GetLastError();
-		ERROR("Win32 API: Failed to get file information for \"%s\"",
-		      root_disk_path);
-		win32_error(err);
-		ret = WIMLIB_ERR_STAT;
-		goto out_close_handle;
-	}
-
-	/* Create a WIM dentry */
-	root = new_dentry_with_timeless_inode(path_basename(root_disk_path));
-	if (!root) {
-		if (errno == EILSEQ)
-			ret = WIMLIB_ERR_INVALID_UTF8_STRING;
-		else if (errno == ENOMEM)
-			ret = WIMLIB_ERR_NOMEM;
-		else
-			ret = WIMLIB_ERR_ICONV_NOT_AVAILABLE;
-		goto out_free_path_utf16;
-	}
-
-	/* Start preparing the associated WIM inode */
-	inode = root->d_inode;
-
-	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_ino = ((u64)file_info.nFileIndexHigh << 32) |
-			(u64)file_info.nFileIndexLow;
-
-	inode->i_resolved = 1;
-	add_image_flags &= ~(WIMLIB_ADD_IMAGE_FLAG_ROOT | WIMLIB_ADD_IMAGE_FLAG_SOURCE);
-
-	/* Get DOS name and security descriptor (if any). */
-	ret = win32_get_short_name(root, path_utf16);
-	if (ret)
-		goto out_close_handle;
-	ret = win32_get_security_descriptor(root, sd_set, path_utf16,
-					    root_disk_path);
-	if (ret)
-		goto out_close_handle;
-
-	if (inode_is_directory(inode)) {
-		/* Directory (not a reparse point) --- recurse to children */
-		DEBUG_WIN32_SAFE("Recursing to directory \"%s\"", root_disk_path);
-		ret = win32_recurse_directory(root,
-					      root_disk_path,
-					      lookup_table,
-					      sd,
-					      config,
-					      add_image_flags,
-					      progress_func,
-					      sd_set,
-					      path_utf16,
-					      path_utf16_nchars);
-	} else if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
-		/* Reparse point: save the reparse tag and data */
-
-		DEBUG_WIN32_SAFE("Capturing reparse point `%s'", root_disk_path);
-		ret = win32_capture_reparse_point(root_disk_path,
-						  hFile,
-						  inode,
-						  lookup_table);
-
-	} else {
-		DEBUG_WIN32_SAFE("Capturing streams of \"%s\"", root_disk_path);
-		/* Not a directory, not a reparse point */
-		ret = win32_capture_streams(root_disk_path,
-					    path_utf16,
-					    path_utf16_nchars,
-					    inode,
-					    lookup_table);
-	}
-out_close_handle:
-	CloseHandle(hFile);
-out_destroy_sd_set:
-	if (extra_arg == NULL)
-		destroy_sd_set(sd_set);
-out_free_path_utf16:
-	FREE(path_utf16);
-#endif
 out:
 	if (ret == 0)
 		*root_ret = root;
@@ -936,6 +401,7 @@ out:
 		free_dentry_tree(root, lookup_table);
 	return ret;
 }
+#endif /* !__WIN32__ */
 
 enum pattern_type {
 	NONE = 0,
@@ -1131,11 +597,14 @@ static bool match_pattern(const char *path, const char *path_basename,
 				/* A file name pattern */
 				string = path_basename;
 		}
+
+		/* Warning: on Windows native builds, fnmatch() calls the
+		 * replacement function in win32.c. */
 		if (fnmatch(pat, string, FNM_PATHNAME
-			#ifdef FNM_CASEFOLD
-					| FNM_CASEFOLD
-			#endif
-			) == 0)
+				#ifdef FNM_CASEFOLD
+			    		| FNM_CASEFOLD
+				#endif
+			    ) == 0)
 		{
 			DEBUG("`%s' matches the pattern \"%s\"",
 			      string, pat);
@@ -1175,7 +644,7 @@ static const char *canonicalize_target_path(char *target_path)
 {
 	char *p;
 	if (target_path == NULL)
-		target_path = "";
+		return "";
 	for (;;) {
 		if (*target_path == '\0')
 			return target_path;
@@ -1191,6 +660,17 @@ static const char *canonicalize_target_path(char *target_path)
 	return target_path;
 }
 
+#ifdef __WIN32__
+static void zap_backslashes(char *s)
+{
+	while (*s) {
+		if (*s == '\\')
+			*s = '/';
+		s++;
+	}
+}
+#endif
+
 /* Strip leading and trailing slashes from the target paths */
 static void canonicalize_targets(struct wimlib_capture_source *sources,
 				 size_t num_sources)
@@ -1199,6 +679,14 @@ static void canonicalize_targets(struct wimlib_capture_source *sources,
 		DEBUG("Canonicalizing { source: \"%s\", target=\"%s\"}",
 		      sources->fs_source_path,
 		      sources->wim_target_path);
+#ifdef __WIN32__
+		/* The Windows API can handle forward slashes.  Just get rid of
+		 * backslashes to avoid confusing other parts of the library
+		 * code. */
+		zap_backslashes(sources->fs_source_path);
+		if (sources->wim_target_path)
+			zap_backslashes(sources->wim_target_path);
+#endif
 		sources->wim_target_path =
 			(char*)canonicalize_target_path(sources->wim_target_path);
 		DEBUG("Canonical target: \"%s\"", sources->wim_target_path);
@@ -1216,7 +704,7 @@ static int capture_source_cmp(const void *p1, const void *p2)
  * after leading and trailing forward slashes are stripped.
  *
  * One purpose of this is to make sure that target paths that are inside other
- * target paths are extracted after the containing target paths. */
+ * target paths are added after the containing target paths. */
 static void sort_sources(struct wimlib_capture_source *sources,
 			 size_t num_sources)
 {
@@ -1285,9 +773,8 @@ new_filler_directory(const char *name)
 	DEBUG("Creating filler directory \"%s\"", name);
 	dentry = new_dentry_with_inode(name);
 	if (dentry) {
-		/* Set the inode number to 0 for now.  The final inode number
+		/* Leave the inode number as 0 for now.  The final inode number
 		 * will be assigned later by assign_inode_numbers(). */
-		dentry->d_inode->i_ino = 0;
 		dentry->d_inode->i_resolved = 1;
 		dentry->d_inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY;
 	}
@@ -1301,6 +788,9 @@ static int do_overlay(struct wim_dentry *target, struct wim_dentry *branch)
 {
 	struct rb_root *rb_root;
 
+	DEBUG("Doing overlay %s => %s",
+	      branch->file_name_utf8, target->file_name_utf8);
+
 	if (!dentry_is_directory(target)) {
 		ERROR("Cannot overlay directory `%s' over non-directory",
 		      branch->file_name_utf8);
@@ -1322,6 +812,7 @@ static int do_overlay(struct wim_dentry *target, struct wim_dentry *branch)
 			return WIMLIB_ERR_INVALID_OVERLAY;
 		}
 	}
+	free_dentry(branch);
 	return 0;
 
 }
@@ -1344,6 +835,9 @@ static int attach_branch(struct wim_dentry **root_p,
 	char *slash;
 	struct wim_dentry *dentry, *parent, *target;
 
+	DEBUG("Attaching branch \"%s\" => \"%s\"",
+	      branch->file_name_utf8, target_path);
+
 	if (*target_path == '\0') {
 		/* Target: root directory */
 		if (*root_p) {
@@ -1438,10 +932,25 @@ WIMLIBAPI int wimlib_add_image_multisource(WIMStruct *w,
 		return WIMLIB_ERR_UNSUPPORTED;
 #endif
 	} else {
-		capture_tree = build_dentry_tree;
+	#ifdef __WIN32__
+		capture_tree = win32_build_dentry_tree;
+	#else
+		capture_tree = unix_build_dentry_tree;
+	#endif
 		extra_arg = NULL;
 	}
 
+#ifdef __WIN32__
+	if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) {
+		ERROR("Capturing UNIX-specific data is not supported on Windows");
+		return WIMLIB_ERR_INVALID_PARAM;
+	}
+	if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE) {
+		ERROR("Dereferencing symbolic links is not supported on Windows");
+		return WIMLIB_ERR_INVALID_PARAM;
+	}
+#endif
+
 	if (!name || !*name) {
 		ERROR("Must specify a non-empty string for the image name");
 		return WIMLIB_ERR_INVALID_PARAM;
@@ -1488,11 +997,17 @@ WIMLIBAPI int wimlib_add_image_multisource(WIMStruct *w,
 	DEBUG("Building dentry tree.");
 	if (num_sources == 0) {
 		root_dentry = new_filler_directory("");
-		if (!root_dentry)
+		if (!root_dentry) {
+			ret = WIMLIB_ERR_NOMEM;
 			goto out_free_security_data;
+		}
 	} else {
 		size_t i;
 
+	#ifdef __WIN32__
+		win32_acquire_capture_privileges();
+	#endif
+
 		root_dentry = NULL;
 		i = 0;
 		do {
@@ -1571,7 +1086,7 @@ WIMLIBAPI int wimlib_add_image_multisource(WIMStruct *w,
 	if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_BOOT)
 		wimlib_set_boot_idx(w, w->hdr.image_count);
 	ret = 0;
-	goto out;
+	goto out_destroy_capture_config;
 out_destroy_imd:
 	destroy_image_metadata(&w->image_metadata[w->hdr.image_count - 1],
 			       w->lookup_table);
@@ -1586,6 +1101,9 @@ out_free_security_data:
 out_destroy_capture_config:
 	destroy_capture_config(&config);
 out:
+#ifdef __WIN32__
+	win32_release_capture_privileges();
+#endif
 	return ret;
 }