X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fdentry.c;h=d77603feeebcf23aecbfc4c02c90d55469839818;hp=287551b9d374ebba6184e367fe3fa6cd7797e2bb;hb=e8c3ca2d1d0cac3d64985b45a9f654d2029a7518;hpb=91171817127cbce936ec3d0e9bde30b0094217b5

diff --git a/src/dentry.c b/src/dentry.c
index 287551b9..d77603fe 100644
--- a/src/dentry.c
+++ b/src/dentry.c
@@ -26,11 +26,20 @@
  * wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
-#include "buffer_io.h"
-#include "dentry.h"
-#include "lookup_table.h"
-#include "timestamp.h"
-#include "wimlib_internal.h"
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "wimlib.h"
+#include "wimlib/buffer_io.h"
+#include "wimlib/dentry.h"
+#include "wimlib/encoding.h"
+#include "wimlib/error.h"
+#include "wimlib/lookup_table.h"
+#include "wimlib/metadata.h"
+#include "wimlib/resource.h"
+#include "wimlib/timestamp.h"
+
 #include <errno.h>
 
 /* Calculates the unaligned length, in bytes, of an on-disk WIM dentry that has
@@ -76,36 +85,46 @@ ads_entry_has_name(const struct wim_ads_entry *entry,
 	       memcmp(entry->stream_name, name, name_nbytes) == 0;
 }
 
-/* Duplicates a multibyte string into a UTF-16LE string and returns the string
- * and its length, in bytes, in the pointer arguments.  Frees any existing
- * string at the return location before overwriting it. */
+/* Duplicates a string of system-dependent encoding into a UTF-16LE string and
+ * returns the string and its length, in bytes, in the pointer arguments.  Frees
+ * any existing string at the return location before overwriting it. */
 static int
-get_utf16le_name(const mbchar *name, utf16lechar **name_utf16le_ret,
+get_utf16le_name(const tchar *name, utf16lechar **name_utf16le_ret,
 		 u16 *name_utf16le_nbytes_ret)
 {
 	utf16lechar *name_utf16le;
 	size_t name_utf16le_nbytes;
 	int ret;
+#if TCHAR_IS_UTF16LE
+	name_utf16le_nbytes = tstrlen(name) * sizeof(utf16lechar);
+	name_utf16le = MALLOC(name_utf16le_nbytes + sizeof(utf16lechar));
+	if (!name_utf16le)
+		return WIMLIB_ERR_NOMEM;
+	memcpy(name_utf16le, name, name_utf16le_nbytes + sizeof(utf16lechar));
+	ret = 0;
+#else
 
-	ret = mbs_to_utf16le(name, strlen(name), &name_utf16le,
-			     &name_utf16le_nbytes);
+	ret = tstr_to_utf16le(name, tstrlen(name), &name_utf16le,
+			      &name_utf16le_nbytes);
 	if (ret == 0) {
 		if (name_utf16le_nbytes > 0xffff) {
 			FREE(name_utf16le);
-			ERROR("Multibyte string \"%s\" is too long!", name);
+			ERROR("Multibyte string \"%"TS"\" is too long!", name);
 			ret = WIMLIB_ERR_INVALID_UTF8_STRING;
-		} else {
-			FREE(*name_utf16le_ret);
-			*name_utf16le_ret = name_utf16le;
-			*name_utf16le_nbytes_ret = name_utf16le_nbytes;
 		}
 	}
+#endif
+	if (ret == 0) {
+		FREE(*name_utf16le_ret);
+		*name_utf16le_ret = name_utf16le;
+		*name_utf16le_nbytes_ret = name_utf16le_nbytes;
+	}
 	return ret;
 }
 
 /* Sets the name of a WIM dentry from a multibyte string. */
 int
-set_dentry_name(struct wim_dentry *dentry, const mbchar *new_name)
+set_dentry_name(struct wim_dentry *dentry, const tchar *new_name)
 {
 	int ret;
 	ret = get_utf16le_name(new_name, &dentry->file_name,
@@ -220,13 +239,13 @@ for_dentry_tree_in_rbtree(struct rb_node *node,
 	int ret;
 	if (node) {
 		ret = for_dentry_tree_in_rbtree(node->rb_left, visitor, arg);
-		if (ret != 0)
+		if (ret)
 			return ret;
 		ret = for_dentry_in_tree(rbnode_dentry(node), visitor, arg);
-		if (ret != 0)
+		if (ret)
 			return ret;
 		ret = for_dentry_tree_in_rbtree(node->rb_right, visitor, arg);
-		if (ret != 0)
+		if (ret)
 			return ret;
 	}
 	return 0;
@@ -240,13 +259,16 @@ int
 for_dentry_in_tree(struct wim_dentry *root,
 		   int (*visitor)(struct wim_dentry*, void*), void *arg)
 {
-	int ret = visitor(root, arg);
-	if (ret == 0) {
-		ret = for_dentry_tree_in_rbtree(root->d_inode->i_children.rb_node,
-						visitor,
-						arg);
-	}
-	return ret;
+	int ret;
+
+	if (!root)
+		return 0;
+	ret = (*visitor)(root, arg);
+	if (ret)
+		return ret;
+	return for_dentry_tree_in_rbtree(root->d_inode->i_children.rb_node,
+					 visitor,
+					 arg);
 }
 
 /* Like for_dentry_in_tree(), but the visitor function is always called on a
@@ -256,69 +278,109 @@ for_dentry_in_tree_depth(struct wim_dentry *root,
 			 int (*visitor)(struct wim_dentry*, void*), void *arg)
 {
 	int ret;
+
+	if (!root)
+		return 0;
 	ret = for_dentry_tree_in_rbtree_depth(root->d_inode->i_children.rb_node,
 					      visitor, arg);
-	if (ret == 0)
-		ret = visitor(root, arg);
-	return ret;
+	if (ret)
+		return ret;
+	return (*visitor)(root, arg);
 }
 
 /* Calculate the full path of @dentry.  The full path of its parent must have
- * already been calculated. */
-int
-calculate_dentry_full_path(struct wim_dentry *dentry, void *ignore)
+ * already been calculated, or it must be the root dentry. */
+static int
+calculate_dentry_full_path(struct wim_dentry *dentry)
 {
-	char *full_path;
+	tchar *full_path;
 	u32 full_path_nbytes;
+	int ret;
 
-	wimlib_assert(dentry_is_root(dentry) ||
-		      dentry->parent->full_path != NULL);
+	if (dentry->_full_path)
+		return 0;
 
 	if (dentry_is_root(dentry)) {
-		full_path = MALLOC(2);
+		full_path = TSTRDUP(T("/"));
 		if (!full_path)
 			return WIMLIB_ERR_NOMEM;
-		full_path[0] = '/';
-		full_path[1] = '\0';
-		full_path_nbytes = 1;
+		full_path_nbytes = 1 * sizeof(tchar);
 	} else {
-		char *parent_full_path;
+		struct wim_dentry *parent;
+		tchar *parent_full_path;
 		u32 parent_full_path_nbytes;
-		const struct wim_dentry *parent;
-		size_t name_mbs_nbytes;
-		int ret;
+		size_t filename_nbytes;
 
-		ret = utf16le_to_mbs_nbytes(dentry->file_name,
-					    dentry->file_name_nbytes,
-					    &name_mbs_nbytes);
-		if (ret)
-			return ret;
 		parent = dentry->parent;
 		if (dentry_is_root(parent)) {
-			parent_full_path = "";
+			parent_full_path = T("");
 			parent_full_path_nbytes = 0;
 		} else {
-			parent_full_path = parent->full_path;
+			if (!parent->_full_path) {
+				ret = calculate_dentry_full_path(parent);
+				if (ret)
+					return ret;
+			}
+			parent_full_path = parent->_full_path;
 			parent_full_path_nbytes = parent->full_path_nbytes;
 		}
-		full_path_nbytes = parent_full_path_nbytes + 1 +
-				   name_mbs_nbytes;
-		full_path = MALLOC(full_path_nbytes + 1);
+
+		/* Append this dentry's name as a tchar string to the full path
+		 * of the parent followed by the path separator */
+	#if TCHAR_IS_UTF16LE
+		filename_nbytes = dentry->file_name_nbytes;
+	#else
+		{
+			int ret = utf16le_to_tstr_nbytes(dentry->file_name,
+							 dentry->file_name_nbytes,
+							 &filename_nbytes);
+			if (ret)
+				return ret;
+		}
+	#endif
+
+		full_path_nbytes = parent_full_path_nbytes + sizeof(tchar) +
+				   filename_nbytes;
+		full_path = MALLOC(full_path_nbytes + sizeof(tchar));
 		if (!full_path)
 			return WIMLIB_ERR_NOMEM;
 		memcpy(full_path, parent_full_path, parent_full_path_nbytes);
-		full_path[parent_full_path_nbytes] = '/';
-
-		utf16le_to_mbs_buf(dentry->file_name,
-				   dentry->file_name_nbytes,
-				   &full_path[parent_full_path_nbytes + 1]);
+		full_path[parent_full_path_nbytes / sizeof(tchar)] = T('/');
+	#if TCHAR_IS_UTF16LE
+		memcpy(&full_path[parent_full_path_nbytes / sizeof(tchar) + 1],
+		       dentry->file_name,
+		       filename_nbytes + sizeof(tchar));
+	#else
+		utf16le_to_tstr_buf(dentry->file_name,
+				    dentry->file_name_nbytes,
+				    &full_path[parent_full_path_nbytes /
+					       sizeof(tchar) + 1]);
+	#endif
 	}
-	FREE(dentry->full_path);
-	dentry->full_path = full_path;
+	dentry->_full_path = full_path;
 	dentry->full_path_nbytes= full_path_nbytes;
 	return 0;
 }
 
+static int
+do_calculate_dentry_full_path(struct wim_dentry *dentry, void *_ignore)
+{
+	return calculate_dentry_full_path(dentry);
+}
+
+int
+calculate_dentry_tree_full_paths(struct wim_dentry *root)
+{
+	return for_dentry_in_tree(root, do_calculate_dentry_full_path, NULL);
+}
+
+tchar *
+dentry_full_path(struct wim_dentry *dentry)
+{
+	calculate_dentry_full_path(dentry);
+	return dentry->_full_path;
+}
+
 static int
 increment_subdir_offset(struct wim_dentry *dentry, void *subdir_offset_p)
 {
@@ -413,15 +475,19 @@ get_dentry_child_with_utf16le_name(const struct wim_dentry *dentry,
 /* Returns the child of @dentry that has the file name @name.  Returns NULL if
  * no child has the name. */
 struct wim_dentry *
-get_dentry_child_with_name(const struct wim_dentry *dentry, const mbchar *name)
+get_dentry_child_with_name(const struct wim_dentry *dentry, const tchar *name)
 {
+#if TCHAR_IS_UTF16LE
+	return get_dentry_child_with_utf16le_name(dentry, name,
+						  tstrlen(name) * sizeof(tchar));
+#else
 	utf16lechar *utf16le_name;
 	size_t utf16le_name_nbytes;
 	int ret;
 	struct wim_dentry *child;
 
-	ret = mbs_to_utf16le(name, strlen(name),
-			     &utf16le_name, &utf16le_name_nbytes);
+	ret = tstr_to_utf16le(name, tstrlen(name) * sizeof(tchar),
+			      &utf16le_name, &utf16le_name_nbytes);
 	if (ret) {
 		child = NULL;
 	} else {
@@ -431,35 +497,29 @@ get_dentry_child_with_name(const struct wim_dentry *dentry, const mbchar *name)
 		FREE(utf16le_name);
 	}
 	return child;
+#endif
 }
 
-/* Returns the dentry corresponding to the @path, or NULL if there is no such
- * dentry. */
-struct wim_dentry *
-get_dentry(WIMStruct *w, const mbchar *path)
+static struct wim_dentry *
+get_dentry_utf16le(WIMStruct *w, const utf16lechar *path,
+		   size_t path_nbytes)
 {
-	utf16lechar *path_utf16le;
-	size_t path_utf16le_nbytes;
-	int ret;
 	struct wim_dentry *cur_dentry, *parent_dentry;
-	utf16lechar *p, *pp;
+	const utf16lechar *p, *pp;
 
-	ret = mbs_to_utf16le(path, strlen(path), &path_utf16le,
-			     &path_utf16le_nbytes);
-	if (ret)
+	cur_dentry = parent_dentry = wim_root_dentry(w);
+	if (!cur_dentry) {
+		errno = ENOENT;
 		return NULL;
-
-	parent_dentry = wim_root_dentry(w);
-	p = path_utf16le;
-
+	}
+	p = path;
 	while (1) {
 		while (*p == cpu_to_le16('/'))
 			p++;
-		cur_dentry = parent_dentry;
 		if (*p == '\0')
 			break;
 		pp = p;
-		while (*pp != cpu_to_le16('/') && *pp != '\0')
+		while (*pp != cpu_to_le16('/') && *pp != cpu_to_le16('\0'))
 			pp++;
 
 		cur_dentry = get_dentry_child_with_utf16le_name(parent_dentry, p,
@@ -469,7 +529,6 @@ get_dentry(WIMStruct *w, const mbchar *path)
 		p = pp;
 		parent_dentry = cur_dentry;
 	}
-	FREE(path_utf16le);
 	if (cur_dentry == NULL) {
 		if (dentry_is_directory(parent_dentry))
 			errno = ENOENT;
@@ -479,8 +538,31 @@ get_dentry(WIMStruct *w, const mbchar *path)
 	return cur_dentry;
 }
 
+/* Returns the dentry corresponding to the @path, or NULL if there is no such
+ * dentry. */
+struct wim_dentry *
+get_dentry(WIMStruct *w, const tchar *path)
+{
+#if TCHAR_IS_UTF16LE
+	return get_dentry_utf16le(w, path, tstrlen(path) * sizeof(tchar));
+#else
+	utf16lechar *path_utf16le;
+	size_t path_utf16le_nbytes;
+	int ret;
+	struct wim_dentry *dentry;
+
+	ret = tstr_to_utf16le(path, tstrlen(path) * sizeof(tchar),
+			      &path_utf16le, &path_utf16le_nbytes);
+	if (ret)
+		return NULL;
+	dentry = get_dentry_utf16le(w, path_utf16le, path_utf16le_nbytes);
+	FREE(path_utf16le);
+	return dentry;
+#endif
+}
+
 struct wim_inode *
-wim_pathname_to_inode(WIMStruct *w, const mbchar *path)
+wim_pathname_to_inode(WIMStruct *w, const tchar *path)
 {
 	struct wim_dentry *dentry;
 	dentry = get_dentry(w, path);
@@ -490,25 +572,42 @@ wim_pathname_to_inode(WIMStruct *w, const mbchar *path)
 		return NULL;
 }
 
+/* Takes in a path of length @len in @buf, and transforms it into a string for
+ * the path of its parent directory. */
+static void
+to_parent_name(tchar *buf, size_t len)
+{
+	ssize_t i = (ssize_t)len - 1;
+	while (i >= 0 && buf[i] == T('/'))
+		i--;
+	while (i >= 0 && buf[i] != T('/'))
+		i--;
+	while (i >= 0 && buf[i] == T('/'))
+		i--;
+	buf[i + 1] = T('\0');
+}
+
 /* Returns the dentry that corresponds to the parent directory of @path, or NULL
  * if the dentry is not found. */
 struct wim_dentry *
-get_parent_dentry(WIMStruct *w, const mbchar *path)
+get_parent_dentry(WIMStruct *w, const tchar *path)
 {
-	size_t path_len = strlen(path);
-	mbchar buf[path_len + 1];
+	size_t path_len = tstrlen(path);
+	tchar buf[path_len + 1];
 
-	memcpy(buf, path, path_len + 1);
+	tmemcpy(buf, path, path_len + 1);
 	to_parent_name(buf, path_len);
 	return get_dentry(w, buf);
 }
 
 /* Prints the full path of a dentry. */
 int
-print_dentry_full_path(struct wim_dentry *dentry, void *ignore)
+print_dentry_full_path(struct wim_dentry *dentry, void *_ignore)
 {
-	if (dentry->full_path)
-		puts(dentry->full_path);
+	int ret = calculate_dentry_full_path(dentry);
+	if (ret)
+		return ret;
+	tprintf(T("%"TS"\n"), dentry->_full_path);
 	return 0;
 }
 
@@ -516,24 +615,24 @@ print_dentry_full_path(struct wim_dentry *dentry, void *ignore)
  * set. */
 struct file_attr_flag {
 	u32 flag;
-	const char *name;
+	const tchar *name;
 };
 struct file_attr_flag file_attr_flags[] = {
-	{FILE_ATTRIBUTE_READONLY,	    "READONLY"},
-	{FILE_ATTRIBUTE_HIDDEN,		    "HIDDEN"},
-	{FILE_ATTRIBUTE_SYSTEM,		    "SYSTEM"},
-	{FILE_ATTRIBUTE_DIRECTORY,	    "DIRECTORY"},
-	{FILE_ATTRIBUTE_ARCHIVE,	    "ARCHIVE"},
-	{FILE_ATTRIBUTE_DEVICE,		    "DEVICE"},
-	{FILE_ATTRIBUTE_NORMAL,		    "NORMAL"},
-	{FILE_ATTRIBUTE_TEMPORARY,	    "TEMPORARY"},
-	{FILE_ATTRIBUTE_SPARSE_FILE,	    "SPARSE_FILE"},
-	{FILE_ATTRIBUTE_REPARSE_POINT,	    "REPARSE_POINT"},
-	{FILE_ATTRIBUTE_COMPRESSED,	    "COMPRESSED"},
-	{FILE_ATTRIBUTE_OFFLINE,	    "OFFLINE"},
-	{FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,"NOT_CONTENT_INDEXED"},
-	{FILE_ATTRIBUTE_ENCRYPTED,	    "ENCRYPTED"},
-	{FILE_ATTRIBUTE_VIRTUAL,	    "VIRTUAL"},
+	{FILE_ATTRIBUTE_READONLY,	    T("READONLY")},
+	{FILE_ATTRIBUTE_HIDDEN,		    T("HIDDEN")},
+	{FILE_ATTRIBUTE_SYSTEM,		    T("SYSTEM")},
+	{FILE_ATTRIBUTE_DIRECTORY,	    T("DIRECTORY")},
+	{FILE_ATTRIBUTE_ARCHIVE,	    T("ARCHIVE")},
+	{FILE_ATTRIBUTE_DEVICE,		    T("DEVICE")},
+	{FILE_ATTRIBUTE_NORMAL,		    T("NORMAL")},
+	{FILE_ATTRIBUTE_TEMPORARY,	    T("TEMPORARY")},
+	{FILE_ATTRIBUTE_SPARSE_FILE,	    T("SPARSE_FILE")},
+	{FILE_ATTRIBUTE_REPARSE_POINT,	    T("REPARSE_POINT")},
+	{FILE_ATTRIBUTE_COMPRESSED,	    T("COMPRESSED")},
+	{FILE_ATTRIBUTE_OFFLINE,	    T("OFFLINE")},
+	{FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,T("NOT_CONTENT_INDEXED")},
+	{FILE_ATTRIBUTE_ENCRYPTED,	    T("ENCRYPTED")},
+	{FILE_ATTRIBUTE_VIRTUAL,	    T("VIRTUAL")},
 };
 
 /* Prints a directory entry.  @lookup_table is a pointer to the lookup table, if
@@ -545,37 +644,45 @@ print_dentry(struct wim_dentry *dentry, void *lookup_table)
 	const u8 *hash;
 	struct wim_lookup_table_entry *lte;
 	const struct wim_inode *inode = dentry->d_inode;
-	char buf[50];
+	tchar buf[50];
 
-	printf("[DENTRY]\n");
-	printf("Length            = %"PRIu64"\n", dentry->length);
-	printf("Attributes        = 0x%x\n", inode->i_attributes);
+	tprintf(T("[DENTRY]\n"));
+	tprintf(T("Length            = %"PRIu64"\n"), dentry->length);
+	tprintf(T("Attributes        = 0x%x\n"), inode->i_attributes);
 	for (size_t i = 0; i < ARRAY_LEN(file_attr_flags); i++)
 		if (file_attr_flags[i].flag & inode->i_attributes)
-			printf("    FILE_ATTRIBUTE_%s is set\n",
+			tprintf(T("    FILE_ATTRIBUTE_%"TS" is set\n"),
 				file_attr_flags[i].name);
-	printf("Security ID       = %d\n", inode->i_security_id);
-	printf("Subdir offset     = %"PRIu64"\n", dentry->subdir_offset);
+	tprintf(T("Security ID       = %d\n"), inode->i_security_id);
+	tprintf(T("Subdir offset     = %"PRIu64"\n"), dentry->subdir_offset);
 
 	wim_timestamp_to_str(inode->i_creation_time, buf, sizeof(buf));
-	printf("Creation Time     = %s\n", buf);
+	tprintf(T("Creation Time     = %"TS"\n"), buf);
 
 	wim_timestamp_to_str(inode->i_last_access_time, buf, sizeof(buf));
-	printf("Last Access Time  = %s\n", buf);
+	tprintf(T("Last Access Time  = %"TS"\n"), buf);
 
 	wim_timestamp_to_str(inode->i_last_write_time, buf, sizeof(buf));
-	printf("Last Write Time   = %s\n", buf);
+	tprintf(T("Last Write Time   = %"TS"\n"), buf);
 
-	printf("Reparse Tag       = 0x%"PRIx32"\n", inode->i_reparse_tag);
-	printf("Hard Link Group   = 0x%"PRIx64"\n", inode->i_ino);
-	printf("Hard Link Group Size = %"PRIu32"\n", inode->i_nlink);
-	printf("Number of Alternate Data Streams = %hu\n", inode->i_num_ads);
+	if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+		tprintf(T("Reparse Tag       = 0x%"PRIx32"\n"), inode->i_reparse_tag);
+		tprintf(T("Reparse Point Flags = 0x%"PRIx16"\n"),
+			inode->i_not_rpfixed);
+		tprintf(T("Reparse Point Unknown 2 = 0x%"PRIx32"\n"),
+			inode->i_rp_unknown_2);
+	}
+	tprintf(T("Reparse Point Unknown 1 = 0x%"PRIx32"\n"),
+		inode->i_rp_unknown_1);
+	tprintf(T("Hard Link Group   = 0x%"PRIx64"\n"), inode->i_ino);
+	tprintf(T("Hard Link Group Size = %"PRIu32"\n"), inode->i_nlink);
+	tprintf(T("Number of Alternate Data Streams = %hu\n"), inode->i_num_ads);
 	if (dentry_has_long_name(dentry))
-		wimlib_printf("Filename = \"%W\"\n", dentry->file_name);
+		wimlib_printf(T("Filename = \"%"WS"\"\n"), dentry->file_name);
 	if (dentry_has_short_name(dentry))
-		wimlib_printf("Short Name \"%W\"\n", dentry->short_name);
-	if (dentry->full_path)
-		printf("Full Path = \"%s\"\n", dentry->full_path);
+		wimlib_printf(T("Short Name \"%"WS"\"\n"), dentry->short_name);
+	if (dentry->_full_path)
+		tprintf(T("Full Path = \"%"TS"\"\n"), dentry->_full_path);
 
 	lte = inode_stream_lte(dentry->d_inode, 0, lookup_table);
 	if (lte) {
@@ -583,22 +690,23 @@ print_dentry(struct wim_dentry *dentry, void *lookup_table)
 	} else {
 		hash = inode_stream_hash(inode, 0);
 		if (hash) {
-			printf("Hash              = 0x");
-			print_hash(hash);
-			putchar('\n');
-			putchar('\n');
+			tprintf(T("Hash              = 0x"));
+			print_hash(hash, stdout);
+			tputchar(T('\n'));
+			tputchar(T('\n'));
 		}
 	}
 	for (u16 i = 0; i < inode->i_num_ads; i++) {
-		printf("[Alternate Stream Entry %u]\n", i);
-		wimlib_printf("Name = \"%W\"\n", inode->i_ads_entries[i].stream_name);
-		printf("Name Length (UTF16 bytes) = %hu\n",
+		tprintf(T("[Alternate Stream Entry %u]\n"), i);
+		wimlib_printf(T("Name = \"%"WS"\"\n"),
+			      inode->i_ads_entries[i].stream_name);
+		tprintf(T("Name Length (UTF16 bytes) = %hu\n"),
 		       inode->i_ads_entries[i].stream_name_nbytes);
 		hash = inode_stream_hash(inode, i + 1);
 		if (hash) {
-			printf("Hash              = 0x");
-			print_hash(hash);
-			putchar('\n');
+			tprintf(T("Hash              = 0x"));
+			print_hash(hash, stdout);
+			tputchar(T('\n'));
 		}
 		print_lookup_table_entry(inode_stream_lte(inode, i + 1, lookup_table),
 					 stdout);
@@ -611,18 +719,19 @@ static void
 dentry_common_init(struct wim_dentry *dentry)
 {
 	memset(dentry, 0, sizeof(struct wim_dentry));
-	dentry->refcnt = 1;
 }
 
-static struct wim_inode *
-new_timeless_inode()
+struct wim_inode *
+new_timeless_inode(void)
 {
 	struct wim_inode *inode = CALLOC(1, sizeof(struct wim_inode));
 	if (inode) {
 		inode->i_security_id = -1;
 		inode->i_nlink = 1;
-	#ifdef WITH_FUSE
 		inode->i_next_stream_id = 1;
+		inode->i_not_rpfixed = 1;
+		INIT_LIST_HEAD(&inode->i_list);
+	#ifdef WITH_FUSE
 		if (pthread_mutex_init(&inode->i_mutex, NULL) != 0) {
 			ERROR_WITH_ERRNO("Error initializing mutex");
 			FREE(inode);
@@ -635,7 +744,7 @@ new_timeless_inode()
 }
 
 static struct wim_inode *
-new_inode()
+new_inode(void)
 {
 	struct wim_inode *inode = new_timeless_inode();
 	if (inode) {
@@ -648,7 +757,8 @@ new_inode()
 }
 
 /* Creates an unlinked directory entry. */
-int new_dentry(const mbchar *name, struct wim_dentry **dentry_ret)
+int
+new_dentry(const tchar *name, struct wim_dentry **dentry_ret)
 {
 	struct wim_dentry *dentry;
 	int ret;
@@ -664,14 +774,15 @@ int new_dentry(const mbchar *name, struct wim_dentry **dentry_ret)
 		*dentry_ret = dentry;
 	} else {
 		FREE(dentry);
-		ERROR("Failed to set name on new dentry with name \"%s\"", name);
+		ERROR("Failed to set name on new dentry with name \"%"TS"\"",
+		      name);
 	}
 	return ret;
 }
 
 
 static int
-__new_dentry_with_inode(const mbchar *name, struct wim_dentry **dentry_ret,
+__new_dentry_with_inode(const tchar *name, struct wim_dentry **dentry_ret,
 			bool timeless)
 {
 	struct wim_dentry *dentry;
@@ -696,17 +807,36 @@ __new_dentry_with_inode(const mbchar *name, struct wim_dentry **dentry_ret,
 }
 
 int
-new_dentry_with_timeless_inode(const mbchar *name, struct wim_dentry **dentry_ret)
+new_dentry_with_timeless_inode(const tchar *name, struct wim_dentry **dentry_ret)
 {
 	return __new_dentry_with_inode(name, dentry_ret, true);
 }
 
 int
-new_dentry_with_inode(const mbchar *name, struct wim_dentry **dentry_ret)
+new_dentry_with_inode(const tchar *name, struct wim_dentry **dentry_ret)
 {
 	return __new_dentry_with_inode(name, dentry_ret, false);
 }
 
+int
+new_filler_directory(const tchar *name, struct wim_dentry **dentry_ret)
+{
+	int ret;
+	struct wim_dentry *dentry;
+
+	DEBUG("Creating filler directory \"%"TS"\"", name);
+	ret = new_dentry_with_inode(name, &dentry);
+	if (ret)
+		goto out;
+	/* Leave the inode number as 0; this is allowed for non
+	 * hard-linked files. */
+	dentry->d_inode->i_resolved = 1;
+	dentry->d_inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY;
+	*dentry_ret = dentry;
+	ret = 0;
+out:
+	return ret;
+}
 
 static int
 init_ads_entry(struct wim_ads_entry *ads_entry, const void *name,
@@ -724,7 +854,7 @@ init_ads_entry(struct wim_ads_entry *ads_entry, const void *name,
 		ads_entry->stream_name = p;
 		ads_entry->stream_name_nbytes = name_nbytes;
 	} else {
-		if (name && *(const char*)name) {
+		if (name && *(const tchar*)name != T('\0')) {
 			ret = get_utf16le_name(name, &ads_entry->stream_name,
 					       &ads_entry->stream_name_nbytes);
 		}
@@ -739,7 +869,8 @@ destroy_ads_entry(struct wim_ads_entry *ads_entry)
 }
 
 /* Frees an inode. */
-void free_inode(struct wim_inode *inode)
+void
+free_inode(struct wim_inode *inode)
 {
 	if (inode) {
 		if (inode->i_ads_entries) {
@@ -751,9 +882,10 @@ void free_inode(struct wim_inode *inode)
 		wimlib_assert(inode->i_num_opened_fds == 0);
 		FREE(inode->i_fds);
 		pthread_mutex_destroy(&inode->i_mutex);
-		if (inode->i_hlist.pprev)
-			hlist_del(&inode->i_hlist);
 	#endif
+		/* HACK: This may instead delete the inode from i_list, but the
+		 * hlist_del() behaves the same as list_del(). */
+		hlist_del(&inode->i_hlist);
 		FREE(inode->i_extracted_file);
 		FREE(inode);
 	}
@@ -761,7 +893,8 @@ void free_inode(struct wim_inode *inode)
 
 /* Decrements link count on an inode and frees it if the link count reaches 0.
  * */
-static void put_inode(struct wim_inode *inode)
+static void
+put_inode(struct wim_inode *inode)
 {
 	wimlib_assert(inode->i_nlink != 0);
 	if (--inode->i_nlink == 0) {
@@ -779,26 +912,21 @@ static void put_inode(struct wim_inode *inode)
  * The corresponding inode (if any) is freed only if its link count is
  * decremented to 0.
  */
-void free_dentry(struct wim_dentry *dentry)
+void
+free_dentry(struct wim_dentry *dentry)
 {
 	FREE(dentry->file_name);
 	FREE(dentry->short_name);
-	FREE(dentry->full_path);
+	FREE(dentry->_full_path);
 	if (dentry->d_inode)
 		put_inode(dentry->d_inode);
 	FREE(dentry);
 }
 
-void put_dentry(struct wim_dentry *dentry)
-{
-	wimlib_assert(dentry->refcnt != 0);
-	if (--dentry->refcnt == 0)
-		free_dentry(dentry);
-}
-
 /* This function is passed as an argument to for_dentry_in_tree_depth() in order
  * to free a directory tree. */
-static int do_free_dentry(struct wim_dentry *dentry, void *__lookup_table)
+static int
+do_free_dentry(struct wim_dentry *dentry, void *__lookup_table)
 {
 	struct wim_lookup_table *lookup_table = __lookup_table;
 	unsigned i;
@@ -813,8 +941,7 @@ static int do_free_dentry(struct wim_dentry *dentry, void *__lookup_table)
 				lte_decrement_refcnt(lte, lookup_table);
 		}
 	}
-
-	put_dentry(dentry);
+	free_dentry(dentry);
 	return 0;
 }
 
@@ -827,16 +954,10 @@ static int do_free_dentry(struct wim_dentry *dentry, void *__lookup_table)
  * 			table entries corresponding to the dentries will be
  * 			decremented.
  */
-void free_dentry_tree(struct wim_dentry *root, struct wim_lookup_table *lookup_table)
-{
-	if (root)
-		for_dentry_in_tree_depth(root, do_free_dentry, lookup_table);
-}
-
-int increment_dentry_refcnt(struct wim_dentry *dentry, void *ignore)
+void
+free_dentry_tree(struct wim_dentry *root, struct wim_lookup_table *lookup_table)
 {
-	dentry->refcnt++;
-	return 0;
+	for_dentry_in_tree_depth(root, do_free_dentry, lookup_table);
 }
 
 /*
@@ -845,7 +966,7 @@ int increment_dentry_refcnt(struct wim_dentry *dentry, void *ignore)
  * @parent: The dentry that will be the parent of @dentry.
  * @dentry: The dentry to link.
  */
-bool
+struct wim_dentry *
 dentry_add_child(struct wim_dentry * restrict parent,
 		 struct wim_dentry * restrict child)
 {
@@ -866,12 +987,12 @@ dentry_add_child(struct wim_dentry * restrict parent,
 		else if (result > 0)
 			new = &((*new)->rb_right);
 		else
-			return false;
+			return this;
 	}
 	child->parent = parent;
 	rb_link_node(&child->rb_node, rb_parent, new);
 	rb_insert_color(&child->rb_node, root);
-	return true;
+	return NULL;
 }
 
 /* Unlink a WIM dentry from the directory entry tree. */
@@ -889,24 +1010,34 @@ unlink_dentry(struct wim_dentry *dentry)
  * stream name @stream_name.
  */
 struct wim_ads_entry *
-inode_get_ads_entry(struct wim_inode *inode, const mbchar *stream_name,
+inode_get_ads_entry(struct wim_inode *inode, const tchar *stream_name,
 		    u16 *idx_ret)
 {
 	if (inode->i_num_ads == 0) {
 		return NULL;
 	} else {
-		int ret;
-		utf16lechar *stream_name_utf16le;
 		size_t stream_name_utf16le_nbytes;
 		u16 i;
 		struct wim_ads_entry *result;
 
-		ret = mbs_to_utf16le(stream_name, strlen(stream_name),
-				     &stream_name_utf16le,
-				     &stream_name_utf16le_nbytes);
-		if (ret)
-			return NULL;
+	#if TCHAR_IS_UTF16LE
+		const utf16lechar *stream_name_utf16le;
+
+		stream_name_utf16le = stream_name;
+		stream_name_utf16le_nbytes = tstrlen(stream_name) * sizeof(tchar);
+	#else
+		utf16lechar *stream_name_utf16le;
 
+		{
+			int ret = tstr_to_utf16le(stream_name,
+						  tstrlen(stream_name) *
+						      sizeof(tchar),
+						  &stream_name_utf16le,
+						  &stream_name_utf16le_nbytes);
+			if (ret)
+				return NULL;
+		}
+	#endif
 		i = 0;
 		result = NULL;
 		do {
@@ -920,7 +1051,9 @@ inode_get_ads_entry(struct wim_inode *inode, const mbchar *stream_name,
 				break;
 			}
 		} while (++i != inode->i_num_ads);
+	#if !TCHAR_IS_UTF16LE
 		FREE(stream_name_utf16le);
+	#endif
 		return result;
 	}
 }
@@ -933,8 +1066,6 @@ do_inode_add_ads(struct wim_inode *inode, const void *stream_name,
 	struct wim_ads_entry *ads_entries;
 	struct wim_ads_entry *new_entry;
 
-	DEBUG("Add alternate data stream \"%s\"", stream_name);
-
 	if (inode->i_num_ads >= 0xfffe) {
 		ERROR("Too many alternate data streams in one inode!");
 		return NULL;
@@ -951,9 +1082,7 @@ do_inode_add_ads(struct wim_inode *inode, const void *stream_name,
 	new_entry = &inode->i_ads_entries[num_ads - 1];
 	if (init_ads_entry(new_entry, stream_name, stream_name_nbytes, is_utf16le))
 		return NULL;
-#ifdef WITH_FUSE
 	new_entry->stream_id = inode->i_next_stream_id++;
-#endif
 	inode->i_num_ads = num_ads;
 	return new_entry;
 }
@@ -963,6 +1092,7 @@ inode_add_ads_utf16le(struct wim_inode *inode,
 		      const utf16lechar *stream_name,
 		      size_t stream_name_nbytes)
 {
+	DEBUG("Add alternate data stream \"%"WS"\"", stream_name);
 	return do_inode_add_ads(inode, stream_name, stream_name_nbytes, true);
 }
 
@@ -971,13 +1101,16 @@ inode_add_ads_utf16le(struct wim_inode *inode,
  * NULL if memory could not be allocated.
  */
 struct wim_ads_entry *
-inode_add_ads(struct wim_inode *inode, const char *stream_name)
+inode_add_ads(struct wim_inode *inode, const tchar *stream_name)
 {
-	return do_inode_add_ads(inode, stream_name, strlen(stream_name), false);
+	DEBUG("Add alternate data stream \"%"TS"\"", stream_name);
+	return do_inode_add_ads(inode, stream_name,
+				tstrlen(stream_name) * sizeof(tchar),
+				TCHAR_IS_UTF16LE);
 }
 
 int
-inode_add_ads_with_data(struct wim_inode *inode, const mbchar *name,
+inode_add_ads_with_data(struct wim_inode *inode, const tchar *name,
 			const void *value, size_t size,
 			struct wim_lookup_table *lookup_table)
 {
@@ -1024,6 +1157,43 @@ out:
 	return ret;
 }
 
+/* Set the unnamed stream of a WIM inode, given a data buffer containing the
+ * stream contents. */
+int
+inode_set_unnamed_stream(struct wim_inode *inode, const void *data, size_t len,
+			 struct wim_lookup_table *lookup_table)
+{
+	struct wim_lookup_table_entry *lte, *existing_lte;
+	u8 hash[SHA1_HASH_SIZE];
+	void *buf;
+
+	sha1_buffer(data, len, hash);
+	existing_lte = __lookup_resource(lookup_table, hash);
+	if (existing_lte) {
+		wimlib_assert(wim_resource_size(existing_lte) == len);
+		lte = existing_lte;
+		lte->refcnt++;
+	} else {
+		lte = new_lookup_table_entry();
+		if (!lte)
+			return WIMLIB_ERR_NOMEM;
+		buf = MALLOC(len);
+		if (!buf) {
+			free_lookup_table_entry(lte);
+			return WIMLIB_ERR_NOMEM;
+		}
+		memcpy(buf, data, len);
+		lte->resource_location = RESOURCE_IN_ATTACHED_BUFFER;
+		lte->attached_buffer = buf;
+		lte->resource_entry.original_size = len;
+		copy_hash(lte->hash, hash);
+		lookup_table_insert(lookup_table, lte);
+	}
+	inode->i_lte = lte;
+	inode->i_resolved = 1;
+	return 0;
+}
+
 /* Remove an alternate data stream from a WIM inode  */
 void
 inode_remove_ads(struct wim_inode *inode, u16 idx,
@@ -1037,7 +1207,7 @@ inode_remove_ads(struct wim_inode *inode, u16 idx,
 
 	ads_entry = &inode->i_ads_entries[idx];
 
-	DEBUG("Remove alternate data stream \"%W\"", ads_entry->stream_name);
+	DEBUG("Remove alternate data stream \"%"WS"\"", ads_entry->stream_name);
 
 	lte = ads_entry->lte;
 	if (lte)
@@ -1080,7 +1250,7 @@ inode_get_unix_data(const struct wim_inode *inode,
 	if (size != sizeof(struct wimlib_unix_data))
 		return BAD_UNIX_DATA;
 
-	ret = read_full_wim_resource(lte, (u8*)unix_data, 0);
+	ret = read_full_resource_into_buf(lte, unix_data);
 	if (ret)
 		return ret;
 
@@ -1114,7 +1284,7 @@ inode_set_unix_data(struct wim_inode *inode, uid_t uid, gid_t gid, mode_t mode,
 	if (which & UNIX_DATA_MODE || !have_good_unix_data)
 		unix_data.mode = mode;
 	ret = inode_add_ads_with_data(inode, WIMLIB_UNIX_DATA_TAG,
-				      (const u8*)&unix_data,
+				      &unix_data,
 				      sizeof(struct wimlib_unix_data),
 				      lookup_table);
 	if (ret == 0 && have_unix_data)
@@ -1123,6 +1293,39 @@ inode_set_unix_data(struct wim_inode *inode, uid_t uid, gid_t gid, mode_t mode,
 }
 #endif /* !__WIN32__ */
 
+/* Replace weird characters in filenames and alternate data stream names.
+ *
+ * In particular we do not want the path separator to appear in any names, as
+ * that would make it possible for a "malicious" WIM to extract itself to any
+ * location it wanted to. */
+static void
+replace_forbidden_characters(utf16lechar *name)
+{
+	utf16lechar *p;
+
+	for (p = name; *p; p++) {
+	#ifdef __WIN32__
+		if (wcschr(L"<>:\"/\\|?*", (wchar_t)*p))
+	#else
+		if (*p == cpu_to_le16('/'))
+	#endif
+		{
+			if (name) {
+				WARNING("File, directory, or stream name \"%"WS"\"\n"
+					"          contains forbidden characters; "
+					"substituting replacement characters.",
+					name);
+				name = NULL;
+			}
+		#ifdef __WIN32__
+			*p = cpu_to_le16(0xfffd);
+		#else
+			*p = cpu_to_le16('?');
+		#endif
+		}
+	}
+}
+
 /*
  * Reads the alternate data stream entries of a WIM dentry.
  *
@@ -1200,7 +1403,7 @@ read_ads_entries(const u8 *p, struct wim_inode *inode, u64 remaining_size)
 		}
 
 		p = get_u64(p, &length);
-		p += 8; /* Skip the reserved field */
+		p = get_u64(p, &cur_entry->unused);
 		p = get_bytes(p, SHA1_HASH_SIZE, cur_entry->hash);
 		p = get_u16(p, &cur_entry->stream_name_nbytes);
 
@@ -1250,6 +1453,7 @@ read_ads_entries(const u8 *p, struct wim_inode *inode, u64 remaining_size)
 			get_bytes(p, cur_entry->stream_name_nbytes,
 				  cur_entry->stream_name);
 			cur_entry->stream_name[cur_entry->stream_name_nbytes / 2] = 0;
+			replace_forbidden_characters(cur_entry->stream_name);
 		}
 		/* It's expected that the size of every ADS entry is a multiple
 		 * of 8.  However, to be safe, I'm allowing the possibility of
@@ -1356,10 +1560,8 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 	p = get_u32(p, (u32*)&inode->i_security_id);
 	p = get_u64(p, &dentry->subdir_offset);
 
-	/* 2 unused fields */
-	p += 2 * sizeof(u64);
-	/*p = get_u64(p, &dentry->unused1);*/
-	/*p = get_u64(p, &dentry->unused2);*/
+	p = get_u64(p, &inode->i_unused_1);
+	p = get_u64(p, &inode->i_unused_2);
 
 	p = get_u64(p, &inode->i_creation_time);
 	p = get_u64(p, &inode->i_last_access_time);
@@ -1367,19 +1569,16 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 
 	p = get_bytes(p, SHA1_HASH_SIZE, inode->i_hash);
 
-	/*
-	 * I don't know what's going on here.  It seems like M$ screwed up the
+	/* I don't know what's going on here.  It seems like M$ screwed up the
 	 * reparse points, then put the fields in the same place and didn't
-	 * document it.  The WIM_HDR_FLAG_RP_FIX flag in the WIM header might
-	 * have something to do with this, but it's not documented.
-	 */
+	 * document it.  */
 	if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
-		/* ??? */
-		p += 4;
+		p = get_u32(p, &inode->i_rp_unknown_1);
 		p = get_u32(p, &inode->i_reparse_tag);
-		p += 4;
+		p = get_u16(p, &inode->i_rp_unknown_2);
+		p = get_u16(p, &inode->i_not_rpfixed);
 	} else {
-		p = get_u32(p, &inode->i_reparse_tag);
+		p = get_u32(p, &inode->i_rp_unknown_1);
 		p = get_u64(p, &inode->i_ino);
 	}
 
@@ -1423,9 +1622,10 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 		p = get_bytes(p, file_name_nbytes + 2, file_name);
 		if (file_name[file_name_nbytes / 2] != 0) {
 			file_name[file_name_nbytes / 2] = 0;
-			WARNING("File name in WIM dentry \"%W\" is not "
+			WARNING("File name in WIM dentry \"%"WS"\" is not "
 				"null-terminated!", file_name);
 		}
+		replace_forbidden_characters(file_name);
 	}
 
 	/* Align the calculated size */
@@ -1455,9 +1655,9 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 		 * 	u64 reserved1; (always 0)
 		 * 	u64 reserved2; (always 0)
 		 * };*/
-		/*DEBUG("Dentry for file or directory `%s' has %"PRIu64" extra "*/
-		      /*"bytes of data",*/
-		      /*file_name_utf8, dentry->length - calculated_size);*/
+		/*DEBUG("Dentry for file or directory `%"WS"' has %"PRIu64" "*/
+		      /*"extra bytes of data", file_name,*/
+		      /*dentry->length - calculated_size);*/
 	}
 
 	/* Read the short filename if present.  Note: if there is no short
@@ -1473,9 +1673,10 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 		p = get_bytes(p, short_name_nbytes + 2, short_name);
 		if (short_name[short_name_nbytes / 2] != 0) {
 			short_name[short_name_nbytes / 2] = 0;
-			WARNING("Short name in WIM dentry \"%W\" is not "
+			WARNING("Short name in WIM dentry \"%"WS"\" is not "
 				"null-terminated!", file_name);
 		}
+		replace_forbidden_characters(short_name);
 	}
 
 	/*
@@ -1513,7 +1714,7 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 				goto out;
 		}
 		ERROR("Failed to read alternate data stream "
-		      "entries of WIM dentry \"%W\"", file_name);
+		      "entries of WIM dentry \"%"WS"\"", file_name);
 		goto out_free_short_name;
 	}
 out:
@@ -1638,20 +1839,21 @@ write_dentry(const struct wim_dentry *dentry, u8 *p)
 	p = put_u32(p, inode->i_attributes);
 	p = put_u32(p, inode->i_security_id);
 	p = put_u64(p, dentry->subdir_offset);
-	p = put_u64(p, 0); /* unused1 */
-	p = put_u64(p, 0); /* unused2 */
+	p = put_u64(p, inode->i_unused_1);
+	p = put_u64(p, inode->i_unused_2);
 	p = put_u64(p, inode->i_creation_time);
 	p = put_u64(p, inode->i_last_access_time);
 	p = put_u64(p, inode->i_last_write_time);
 	hash = inode_stream_hash(inode, 0);
 	p = put_bytes(p, SHA1_HASH_SIZE, hash);
 	if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
-		p = put_zeroes(p, 4);
+		p = put_u32(p, inode->i_rp_unknown_1);
 		p = put_u32(p, inode->i_reparse_tag);
-		p = put_zeroes(p, 4);
+		p = put_u16(p, inode->i_rp_unknown_2);
+		p = put_u16(p, inode->i_not_rpfixed);
 	} else {
 		u64 link_group_id;
-		p = put_u32(p, 0);
+		p = put_u32(p, inode->i_rp_unknown_1);
 		if (inode->i_nlink == 1)
 			link_group_id = 0;
 		else
@@ -1679,7 +1881,7 @@ write_dentry(const struct wim_dentry *dentry, u8 *p)
 	 * alternate data stream entries. */
 	for (u16 i = 0; i < inode->i_num_ads; i++) {
 		p = put_u64(p, ads_entry_total_length(&inode->i_ads_entries[i]));
-		p = put_u64(p, 0); /* Unused */
+		p = put_u64(p, inode->i_ads_entries[i].unused);
 		hash = inode_stream_hash(inode, i + 1);
 		p = put_bytes(p, SHA1_HASH_SIZE, hash);
 		p = put_u16(p, inode->i_ads_entries[i].stream_name_nbytes);