X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fdentry.c;h=c17e45a38a9e1b010de4c2fe03cafdbd1c89c830;hp=08c08ab683fbc3f9c036840fd79c48d92c953296;hb=14b6656962ad607e3ab45a3ccbc57464ff4a6c6f;hpb=49893f3a5c7cd5bfe962c3b63b299ee713170b8e

diff --git a/src/dentry.c b/src/dentry.c
index 08c08ab6..c17e45a3 100644
--- a/src/dentry.c
+++ b/src/dentry.c
@@ -9,7 +9,7 @@
  */
 
 /*
- * Copyright (C) 2012 Eric Biggers
+ * Copyright (C) 2012, 2013 Eric Biggers
  *
  * This file is part of wimlib, a library for working with WIM files.
  *
@@ -36,14 +36,14 @@
 /* Calculates the unaligned length, in bytes, of an on-disk WIM dentry that has
  * a file name and short name that take the specified numbers of bytes.  This
  * excludes any alternate data stream entries that may follow the dentry. */
-static u64 __dentry_correct_length_unaligned(u16 file_name_len,
-					     u16 short_name_len)
+static u64
+__dentry_correct_length_unaligned(u16 file_name_nbytes, u16 short_name_nbytes)
 {
 	u64 length = WIM_DENTRY_DISK_SIZE;
-	if (file_name_len)
-		length += file_name_len + 2;
-	if (short_name_len)
-		length += short_name_len + 2;
+	if (file_name_nbytes)
+		length += file_name_nbytes + 2;
+	if (short_name_nbytes)
+		length += short_name_nbytes + 2;
 	return length;
 }
 
@@ -51,102 +51,102 @@ static u64 __dentry_correct_length_unaligned(u16 file_name_len,
  * the file name length and short name length.  Note that dentry->length is
  * ignored; also, this excludes any alternate data stream entries that may
  * follow the dentry. */
-static u64 dentry_correct_length_unaligned(const struct wim_dentry *dentry)
+static u64
+dentry_correct_length_unaligned(const struct wim_dentry *dentry)
 {
-	return __dentry_correct_length_unaligned(dentry->file_name_len,
-						 dentry->short_name_len);
+	return __dentry_correct_length_unaligned(dentry->file_name_nbytes,
+						 dentry->short_name_nbytes);
 }
 
 /* Return the "correct" value to write in the length field of a WIM dentry,
  * based on the file name length and short name length. */
-static u64 dentry_correct_length(const struct wim_dentry *dentry)
+static u64
+dentry_correct_length(const struct wim_dentry *dentry)
 {
 	return (dentry_correct_length_unaligned(dentry) + 7) & ~7;
 }
 
-/* Return %true iff the alternate data stream entry @entry has the UTF-8 stream
- * name @name that has length @name_len bytes. */
-static inline bool ads_entry_has_name(const struct wim_ads_entry *entry,
-				      const char *name, size_t name_len)
+/* Return %true iff the alternate data stream entry @entry has the UTF-16LE
+ * stream name @name that has length @name_nbytes bytes. */
+static inline bool
+ads_entry_has_name(const struct wim_ads_entry *entry,
+		   const utf16lechar *name, size_t name_nbytes)
 {
-	if (entry->stream_name_utf8_len != name_len)
-		return false;
-	return memcmp(entry->stream_name_utf8, name, name_len) == 0;
+	return entry->stream_name_nbytes == name_nbytes &&
+	       memcmp(entry->stream_name, name, name_nbytes) == 0;
 }
 
-/* Duplicates a UTF-8 string into UTF-8 and UTF-16 strings and returns the
- * strings and their lengths in the pointer arguments.  (Frees existing strings
- * first.) */
-static int get_names(char **name_utf16_ret, char **name_utf8_ret,
-		     u16 *name_utf16_len_ret, u16 *name_utf8_len_ret,
-		     const char *name)
+/* 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 tchar *name, utf16lechar **name_utf16le_ret,
+		 u16 *name_utf16le_nbytes_ret)
 {
-	size_t utf8_len;
-	size_t utf16_len;
-	char *name_utf16, *name_utf8;
+	utf16lechar *name_utf16le;
+	size_t name_utf16le_nbytes;
 	int ret;
-
-	utf8_len = strlen(name);
-	ret = utf8_to_utf16(name, utf8_len, &name_utf16, &utf16_len);
-	if (ret != 0)
-		return ret;
-
-	name_utf8 = MALLOC(utf8_len + 1);
-	if (!name_utf8) {
-		FREE(name_utf16);
+#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 = 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 \"%"TS"\" is too long!", name);
+			ret = WIMLIB_ERR_INVALID_UTF8_STRING;
+		}
 	}
-	memcpy(name_utf8, name, utf8_len + 1);
-	FREE(*name_utf8_ret);
-	FREE(*name_utf16_ret);
-	*name_utf8_ret      = name_utf8;
-	*name_utf16_ret     = name_utf16;
-	*name_utf8_len_ret  = utf8_len;
-	*name_utf16_len_ret = utf16_len;
-	return 0;
+#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. */
-int set_dentry_name(struct wim_dentry *dentry, const char *new_name)
+/* Sets the name of a WIM dentry from a multibyte string. */
+int
+set_dentry_name(struct wim_dentry *dentry, const tchar *new_name)
 {
 	int ret;
-
-	ret = get_names(&dentry->file_name, &dentry->file_name_utf8,
-			&dentry->file_name_len, &dentry->file_name_utf8_len,
-			new_name);
+	ret = get_utf16le_name(new_name, &dentry->file_name,
+			       &dentry->file_name_nbytes);
 	if (ret == 0) {
-		if (dentry->short_name_len) {
+		/* Clear the short name and recalculate the dentry length */
+		if (dentry_has_short_name(dentry)) {
 			FREE(dentry->short_name);
-			dentry->short_name_len = 0;
+			dentry->short_name = NULL;
+			dentry->short_name_nbytes = 0;
 		}
 		dentry->length = dentry_correct_length(dentry);
 	}
 	return ret;
 }
 
-/*
- * Changes the name of an alternate data stream */
-static int change_ads_name(struct wim_ads_entry *entry, const char *new_name)
-{
-	return get_names(&entry->stream_name, &entry->stream_name_utf8,
-			 &entry->stream_name_len,
-			 &entry->stream_name_utf8_len,
-			 new_name);
-}
-
 /* Returns the total length of a WIM alternate data stream entry on-disk,
  * including the stream name, the null terminator, AND the padding after the
  * entry to align the next ADS entry or dentry on an 8-byte boundary. */
-static u64 ads_entry_total_length(const struct wim_ads_entry *entry)
+static u64
+ads_entry_total_length(const struct wim_ads_entry *entry)
 {
 	u64 len = WIM_ADS_ENTRY_DISK_SIZE;
-	if (entry->stream_name_len)
-		len += entry->stream_name_len + 2;
+	if (entry->stream_name_nbytes)
+		len += entry->stream_name_nbytes + 2;
 	return (len + 7) & ~7;
 }
 
 
-static u64 __dentry_total_length(const struct wim_dentry *dentry, u64 length)
+static u64
+__dentry_total_length(const struct wim_dentry *dentry, u64 length)
 {
 	const struct wim_inode *inode = dentry->d_inode;
 	for (u16 i = 0; i < inode->i_num_ads; i++)
@@ -156,7 +156,8 @@ static u64 __dentry_total_length(const struct wim_dentry *dentry, u64 length)
 
 /* Calculate the aligned *total* length of an on-disk WIM dentry.  This includes
  * all alternate data streams. */
-u64 dentry_correct_total_length(const struct wim_dentry *dentry)
+u64
+dentry_correct_total_length(const struct wim_dentry *dentry)
 {
 	return __dentry_total_length(dentry,
 				     dentry_correct_length_unaligned(dentry));
@@ -164,14 +165,16 @@ u64 dentry_correct_total_length(const struct wim_dentry *dentry)
 
 /* Like dentry_correct_total_length(), but use the existing dentry->length field
  * instead of calculating its "correct" value. */
-static u64 dentry_total_length(const struct wim_dentry *dentry)
+static u64
+dentry_total_length(const struct wim_dentry *dentry)
 {
 	return __dentry_total_length(dentry, dentry->length);
 }
 
-int for_dentry_in_rbtree(struct rb_node *root,
-			 int (*visitor)(struct wim_dentry *, void *),
-			 void *arg)
+int
+for_dentry_in_rbtree(struct rb_node *root,
+		     int (*visitor)(struct wim_dentry *, void *),
+		     void *arg)
 {
 	int ret;
 	struct rb_node *node = root;
@@ -197,9 +200,10 @@ int for_dentry_in_rbtree(struct rb_node *root,
 	}
 }
 
-static int for_dentry_tree_in_rbtree_depth(struct rb_node *node,
-					   int (*visitor)(struct wim_dentry*, void*),
-					   void *arg)
+static int
+for_dentry_tree_in_rbtree_depth(struct rb_node *node,
+				int (*visitor)(struct wim_dentry*, void*),
+				void *arg)
 {
 	int ret;
 	if (node) {
@@ -218,12 +222,10 @@ static int for_dentry_tree_in_rbtree_depth(struct rb_node *node,
 	return 0;
 }
 
-/*#define RECURSIVE_FOR_DENTRY_IN_TREE*/
-
-#ifdef RECURSIVE_FOR_DENTRY_IN_TREE
-static int for_dentry_tree_in_rbtree(struct rb_node *node,
-				     int (*visitor)(struct wim_dentry*, void*),
-				     void *arg)
+static int
+for_dentry_tree_in_rbtree(struct rb_node *node,
+			  int (*visitor)(struct wim_dentry*, void*),
+			  void *arg)
 {
 	int ret;
 	if (node) {
@@ -239,285 +241,140 @@ static int for_dentry_tree_in_rbtree(struct rb_node *node,
 	}
 	return 0;
 }
-#endif
 
-/*
- * Calls a function on all directory entries in a WIM dentry tree.  Logically,
+/* Calls a function on all directory entries in a WIM dentry tree.  Logically,
  * this is a pre-order traversal (the function is called on a parent dentry
  * before its children), but sibling dentries will be visited in order as well.
- *
- * In reality, the data structures are more complicated than the above might
- * suggest because there is a separate red-black tree for each dentry that
- * contains its direct children.
- */
-int for_dentry_in_tree(struct wim_dentry *root,
-		       int (*visitor)(struct wim_dentry*, void*), void *arg)
+ * */
+int
+for_dentry_in_tree(struct wim_dentry *root,
+		   int (*visitor)(struct wim_dentry*, void*), void *arg)
 {
-#ifdef RECURSIVE_FOR_DENTRY_IN_TREE
 	int ret = visitor(root, arg);
-	if (ret != 0)
-		return ret;
-	return for_dentry_tree_in_rbtree(root->d_inode->i_children.rb_node, visitor, arg);
-#else
-	int ret;
-	struct list_head main_stack;
-	struct list_head sibling_stack;
-	struct list_head *sibling_stack_bottom;
-	struct wim_dentry *main_dentry;
-	struct rb_node *node;
-	struct list_head *next_sibling;
-	struct wim_dentry *dentry;
-
-	ret = visitor(root, arg);
-	if (ret != 0)
-		return ret;
-
-	main_dentry = root;
-	sibling_stack_bottom = &sibling_stack;
-	INIT_LIST_HEAD(&main_stack);
-	INIT_LIST_HEAD(&sibling_stack);
-
-	list_add(&root->tmp_list, &main_stack);
-	node = root->d_inode->i_children.rb_node;
-
-	while (1) {
-		// Prepare for non-recursive in-order traversal of the red-black
-		// tree of this dentry's children
-
-		while (node) {
-			// Push this node to the sibling stack and examine the
-			// left neighbor, if any
-			list_add(&rbnode_dentry(node)->tmp_list, &sibling_stack);
-			node = node->rb_left;
-		}
-
-		next_sibling = sibling_stack.next;
-		if (next_sibling == sibling_stack_bottom) {
-			// Done with all siblings.  Pop the main dentry to move
-			// back up one level.
-			main_dentry = container_of(main_stack.next,
-						   struct wim_dentry,
-						   tmp_list);
-			list_del(&main_dentry->tmp_list);
-
-			if (main_dentry == root)
-				goto out;
-
-			// Restore sibling stack bottom from the previous level
-			sibling_stack_bottom = (void*)main_dentry->parent;
-
-			// Restore the just-popped main dentry's parent
-			main_dentry->parent = container_of(main_stack.next,
-							   struct wim_dentry,
-							   tmp_list);
-
-			// The next sibling to traverse in the previous level,
-			// in the in-order traversal of the red-black tree, is
-			// the one to the right.
-			node = main_dentry->rb_node.rb_right;
-		} else {
-			// The sibling stack is not empty, so there are more to
-			// go!
-
-			// Pop a sibling from the stack.
-			list_del(next_sibling);
-			dentry = container_of(next_sibling, struct wim_dentry, tmp_list);
-
-			// Visit the sibling.
-			ret = visitor(dentry, arg);
-			if (ret != 0) {
-				// Failed.  Restore parent pointers for the
-				// dentries in the main stack
-				list_for_each_entry(dentry, &main_stack, tmp_list) {
-					dentry->parent = container_of(dentry->tmp_list.next,
-								      struct wim_dentry,
-								      tmp_list);
-				}
-				goto out;
-			}
-
-			// We'd like to recursively visit the dentry tree rooted
-			// at this sibling.  To do this, add it to the main
-			// stack, save the bottom of this level's sibling stack
-			// in the dentry->parent field, re-set the bottom of the
-			// sibling stack to be its current height, and set
-			// main_dentry to the sibling so it becomes the parent
-			// dentry in the next iteration through the outer loop.
-			if (inode_has_children(dentry->d_inode)) {
-				list_add(&dentry->tmp_list, &main_stack);
-				dentry->parent = (void*)sibling_stack_bottom;
-				sibling_stack_bottom = sibling_stack.next;
-
-				main_dentry = dentry;
-				node = main_dentry->d_inode->i_children.rb_node;
-			} else {
-				node = dentry->rb_node.rb_right;
-			}
-		}
+	if (ret == 0) {
+		ret = for_dentry_tree_in_rbtree(root->d_inode->i_children.rb_node,
+						visitor,
+						arg);
 	}
-out:
-	root->parent = root;
 	return ret;
-#endif
 }
 
-/*
- * Like for_dentry_in_tree(), but the visitor function is always called on a
- * dentry's children before on itself.
- */
-int for_dentry_in_tree_depth(struct wim_dentry *root,
-			     int (*visitor)(struct wim_dentry*, void*), void *arg)
+/* Like for_dentry_in_tree(), but the visitor function is always called on a
+ * dentry's children before on itself. */
+int
+for_dentry_in_tree_depth(struct wim_dentry *root,
+			 int (*visitor)(struct wim_dentry*, void*), void *arg)
 {
-#if 1
 	int ret;
 	ret = for_dentry_tree_in_rbtree_depth(root->d_inode->i_children.rb_node,
 					      visitor, arg);
-	if (ret != 0)
-		return ret;
-	return visitor(root, arg);
+	if (ret == 0)
+		ret = visitor(root, arg);
+	return ret;
+}
 
-#else
+/* Calculate the full path of @dentry.  The full path of its parent must have
+ * already been calculated, or it must be the root dentry. */
+static int
+calculate_dentry_full_path(struct wim_dentry *dentry)
+{
+	tchar *full_path;
+	u32 full_path_nbytes;
 	int ret;
-	struct list_head main_stack;
-	struct list_head sibling_stack;
-	struct list_head *sibling_stack_bottom;
-	struct wim_dentry *main_dentry;
-	struct rb_node *node;
-	struct list_head *next_sibling;
-	struct wim_dentry *dentry;
-
-	main_dentry = root;
-	sibling_stack_bottom = &sibling_stack;
-	INIT_LIST_HEAD(&main_stack);
-	INIT_LIST_HEAD(&sibling_stack);
 
-	list_add(&main_dentry->tmp_list, &main_stack);
+	if (dentry->_full_path)
+		return 0;
 
-	while (1) {
-		node = main_dentry->d_inode->i_children.rb_node;
+	if (dentry_is_root(dentry)) {
+		full_path = TSTRDUP(T("/"));
+		if (!full_path)
+			return WIMLIB_ERR_NOMEM;
+		full_path_nbytes = 1 * sizeof(tchar);
+	} else {
+		struct wim_dentry *parent;
+		tchar *parent_full_path;
+		u32 parent_full_path_nbytes;
+		size_t filename_nbytes;
 
-		while (1) {
-			if (node->rb_left) {
-				list_add(&rbnode_dentry(node)->tmp_list, &sibling_stack);
-				node = node->rb_left;
-				continue;
-			}
-			if (node->rb_right) {
-				list_add(&rbnode_dentry(node)->tmp_list, &sibling_stack);
-				node = node->rb_right;
-				continue;
+		parent = dentry->parent;
+		if (dentry_is_root(parent)) {
+			parent_full_path = T("");
+			parent_full_path_nbytes = 0;
+		} else {
+			if (!parent->_full_path) {
+				ret = calculate_dentry_full_path(parent);
+				if (ret)
+					return ret;
 			}
-			list_add(&rbnode_dentry(node)->tmp_list, &sibling_stack);
+			parent_full_path = parent->_full_path;
+			parent_full_path_nbytes = parent->full_path_nbytes;
 		}
 
-	pop_sibling:
-		next_sibling = sibling_stack.next;
-		if (next_sibling == sibling_stack_bottom) {
-			main_dentry = container_of(main_stack.next,
-						   struct wim_dentry,
-						   tmp_list);
-			list_del(&main_dentry->tmp_list);
-
-
-			sibling_stack_bottom = (void*)main_dentry->parent;
-
-			if (main_dentry == root) {
-				main_dentry->parent = main_dentry;
-				ret = visitor(dentry, arg);
-				return ret;
-			} else {
-				main_dentry->parent = container_of(main_stack.next,
-								   struct wim_dentry,
-								   tmp_list);
-			}
-
-			ret = visitor(main_dentry, arg);
-
-			if (ret != 0) {
-				list_del(&root->tmp_list);
-				list_for_each_entry(dentry, &main_stack, tmp_list) {
-					dentry->parent = container_of(dentry->tmp_list.next,
-								      struct wim_dentry,
-								      tmp_list);
-				}
-				root->parent = root;
+		/* 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;
-			}
-			goto pop_sibling;
-		} else {
-
-			list_del(next_sibling);
-			dentry = container_of(next_sibling, struct wim_dentry, tmp_list);
-
-
-			list_add(&dentry->tmp_list, &main_stack);
-			dentry->parent = (void*)sibling_stack_bottom;
-			sibling_stack_bottom = sibling_stack.next;
-
-			main_dentry = dentry;
 		}
+	#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 / 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
 	}
-#endif
+	dentry->_full_path = full_path;
+	dentry->full_path_nbytes= full_path_nbytes;
+	return 0;
 }
 
-/*
- * Calculate the full path of @dentry, based on its parent's full path and on
- * its UTF-8 file name.
- */
-int calculate_dentry_full_path(struct wim_dentry *dentry, void *ignore)
+static int
+do_calculate_dentry_full_path(struct wim_dentry *dentry, void *_ignore)
 {
-	char *full_path;
-	u32 full_path_len;
-	if (dentry_is_root(dentry)) {
-		full_path = MALLOC(2);
-		if (!full_path)
-			goto oom;
-		full_path[0] = '/';
-		full_path[1] = '\0';
-		full_path_len = 1;
-	} else {
-		char *parent_full_path;
-		u32 parent_full_path_len;
-		const struct wim_dentry *parent = dentry->parent;
+	return calculate_dentry_full_path(dentry);
+}
 
-		if (dentry_is_root(parent)) {
-			parent_full_path = "";
-			parent_full_path_len = 0;
-		} else {
-			parent_full_path = parent->full_path_utf8;
-			parent_full_path_len = parent->full_path_utf8_len;
-		}
+int
+calculate_dentry_tree_full_paths(struct wim_dentry *root)
+{
+	return for_dentry_in_tree(root, do_calculate_dentry_full_path, NULL);
+}
 
-		full_path_len = parent_full_path_len + 1 +
-				dentry->file_name_utf8_len;
-		full_path = MALLOC(full_path_len + 1);
-		if (!full_path)
-			goto oom;
-
-		memcpy(full_path, parent_full_path, parent_full_path_len);
-		full_path[parent_full_path_len] = '/';
-		memcpy(full_path + parent_full_path_len + 1,
-		       dentry->file_name_utf8,
-		       dentry->file_name_utf8_len);
-		full_path[full_path_len] = '\0';
-	}
-	FREE(dentry->full_path_utf8);
-	dentry->full_path_utf8 = full_path;
-	dentry->full_path_utf8_len = full_path_len;
-	return 0;
-oom:
-	ERROR("Out of memory while calculating dentry full path");
-	return WIMLIB_ERR_NOMEM;
+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)
+static int
+increment_subdir_offset(struct wim_dentry *dentry, void *subdir_offset_p)
 {
 	*(u64*)subdir_offset_p += dentry_correct_total_length(dentry);
 	return 0;
 }
 
-static int call_calculate_subdir_offsets(struct wim_dentry *dentry,
-					 void *subdir_offset_p)
+static int
+call_calculate_subdir_offsets(struct wim_dentry *dentry, void *subdir_offset_p)
 {
 	calculate_subdir_offsets(dentry, subdir_offset_p);
 	return 0;
@@ -530,7 +387,8 @@ static int call_calculate_subdir_offsets(struct wim_dentry *dentry,
  * @subdir_offset_p:  The current subdirectory offset; i.e., the subdirectory
  *		      offset for @dentry.
  */
-void calculate_subdir_offsets(struct wim_dentry *dentry, u64 *subdir_offset_p)
+void
+calculate_subdir_offsets(struct wim_dentry *dentry, u64 *subdir_offset_p)
 {
 	struct rb_node *node;
 
@@ -558,96 +416,134 @@ void calculate_subdir_offsets(struct wim_dentry *dentry, u64 *subdir_offset_p)
 	}
 }
 
-static int compare_names(const char *name_1, u16 len_1,
-			 const char *name_2, u16 len_2)
+static int
+compare_utf16le_names(const utf16lechar *name1, size_t nbytes1,
+		      const utf16lechar *name2, size_t nbytes2)
 {
-	int result = strncasecmp(name_1, name_2, min(len_1, len_2));
-	if (result) {
+	int result = memcmp(name1, name2, min(nbytes1, nbytes2));
+	if (result)
 		return result;
-	} else {
-		return (int)len_1 - (int)len_2;
-	}
+	else
+		return (int)nbytes1 - (int)nbytes2;
 }
 
-static int dentry_compare_names(const struct wim_dentry *d1, const struct wim_dentry *d2)
+static int
+dentry_compare_names(const struct wim_dentry *d1, const struct wim_dentry *d2)
 {
-	return compare_names(d1->file_name_utf8, d1->file_name_utf8_len,
-			     d2->file_name_utf8, d2->file_name_utf8_len);
+	return compare_utf16le_names(d1->file_name, d1->file_name_nbytes,
+				     d2->file_name, d2->file_name_nbytes);
 }
 
 
-static struct wim_dentry *
-get_rbtree_child_with_name(const struct rb_node *node,
-			   const char *name, size_t name_len)
-{
-	do {
-		struct wim_dentry *child = rbnode_dentry(node);
-		int result = compare_names(name, name_len,
-					   child->file_name_utf8,
-					   child->file_name_utf8_len);
+struct wim_dentry *
+get_dentry_child_with_utf16le_name(const struct wim_dentry *dentry,
+				   const utf16lechar *name,
+				   size_t name_nbytes)
+{
+	struct rb_node *node = dentry->d_inode->i_children.rb_node;
+	struct wim_dentry *child;
+	while (node) {
+		child = rbnode_dentry(node);
+		int result = compare_utf16le_names(name, name_nbytes,
+						   child->file_name,
+						   child->file_name_nbytes);
 		if (result < 0)
 			node = node->rb_left;
 		else if (result > 0)
 			node = node->rb_right;
 		else
 			return child;
-	} while (node);
+	}
 	return NULL;
 }
 
-/* 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 char *name)
+/* 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 tchar *name)
 {
-	struct rb_node *node = dentry->d_inode->i_children.rb_node;
-	if (node)
-		return get_rbtree_child_with_name(node, name, strlen(name));
-	else
-		return NULL;
+#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 = tstr_to_utf16le(name, tstrlen(name) * sizeof(tchar),
+			      &utf16le_name, &utf16le_name_nbytes);
+	if (ret) {
+		child = NULL;
+	} else {
+		child = get_dentry_child_with_utf16le_name(dentry,
+							   utf16le_name,
+							   utf16le_name_nbytes);
+		FREE(utf16le_name);
+	}
+	return child;
+#endif
 }
 
-/* Retrieves the dentry that has the UTF-8 @path relative to the dentry
- * @cur_dentry.  Returns NULL if no dentry having the path is found. */
-static struct wim_dentry *get_dentry_relative_path(struct wim_dentry *cur_dentry,
-						   const char *path)
+static struct wim_dentry *
+get_dentry_utf16le(WIMStruct *w, const utf16lechar *path,
+		   size_t path_nbytes)
 {
-	if (*path == '\0')
-		return cur_dentry;
+	struct wim_dentry *cur_dentry, *parent_dentry;
+	const utf16lechar *p, *pp;
 
-	struct rb_node *node = cur_dentry->d_inode->i_children.rb_node;
-	if (node) {
-		struct wim_dentry *child;
-		size_t base_len;
-		const char *new_path;
-
-		new_path = path_next_part(path, &base_len);
+	cur_dentry = parent_dentry = wim_root_dentry(w);
+	p = path;
+	while (1) {
+		while (*p == cpu_to_le16('/'))
+			p++;
+		if (*p == '\0')
+			break;
+		pp = p;
+		while (*pp != cpu_to_le16('/') && *pp != cpu_to_le16('\0'))
+			pp++;
 
-		child = get_rbtree_child_with_name(node, path, base_len);
-		if (child)
-			return get_dentry_relative_path(child, new_path);
+		cur_dentry = get_dentry_child_with_utf16le_name(parent_dentry, p,
+								(void*)pp - (void*)p);
+		if (cur_dentry == NULL)
+			break;
+		p = pp;
+		parent_dentry = cur_dentry;
 	}
-	/* errno is set to ENOTDIR if the lookup failed due to reaching a
-	 * non-directory, or ENOENT if the lookup failed otherwise.  This maybe
-	 * should be factored out somehow. */
-	if (dentry_is_directory(cur_dentry))
-		errno = ENOENT;
-	else
-		errno = ENOTDIR;
-	return NULL;
+	if (cur_dentry == NULL) {
+		if (dentry_is_directory(parent_dentry))
+			errno = ENOENT;
+		else
+			errno = ENOTDIR;
+	}
+	return cur_dentry;
 }
 
-/* Returns the dentry corresponding to the UTF-8 @path, or NULL if there is no
- * such dentry. */
-struct wim_dentry *get_dentry(WIMStruct *w, const char *path)
+/* 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)
 {
-	struct wim_dentry *root = wim_root_dentry(w);
-	while (*path == '/')
-		path++;
-	return get_dentry_relative_path(root, 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 char *path)
+struct wim_inode *
+wim_pathname_to_inode(WIMStruct *w, const tchar *path)
 {
 	struct wim_dentry *dentry;
 	dentry = get_dentry(w, path);
@@ -657,25 +553,42 @@ struct wim_inode *wim_pathname_to_inode(WIMStruct *w, const char *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 char *path)
+struct wim_dentry *
+get_parent_dentry(WIMStruct *w, const tchar *path)
 {
-	size_t path_len = strlen(path);
-	char buf[path_len + 1];
-
-	memcpy(buf, path, path_len + 1);
+	size_t path_len = tstrlen(path);
+	tchar buf[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)
+int
+print_dentry_full_path(struct wim_dentry *dentry, void *_ignore)
 {
-	if (dentry->full_path_utf8)
-		puts(dentry->full_path_utf8);
+	int ret = calculate_dentry_full_path(dentry);
+	if (ret)
+		return ret;
+	tprintf(T("%"TS"\n"), dentry->_full_path);
 	return 0;
 }
 
@@ -683,110 +596,122 @@ int 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
  * available.  If the dentry is unresolved and the lookup table is NULL, the
  * lookup table entries will not be printed.  Otherwise, they will be. */
-int print_dentry(struct wim_dentry *dentry, void *lookup_table)
+int
+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);
-
-	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);
-	printf("Filename (UTF-8)  = \"%s\"\n", dentry->file_name_utf8);
-	/*printf("Filename (UTF-8) Length = %hu\n", dentry->file_name_utf8_len);*/
-	printf("Short Name (UTF-16LE) = \"");
-	print_string(dentry->short_name, dentry->short_name_len);
-	puts("\"");
-	/*printf("Short Name Length = %hu\n", dentry->short_name_len);*/
-	printf("Full Path (UTF-8) = \"%s\"\n", dentry->full_path_utf8);
+	tprintf(T("Last Write Time   = %"TS"\n"), buf);
+
+	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(T("Filename = \"%"WS"\"\n"), dentry->file_name);
+	if (dentry_has_short_name(dentry))
+		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) {
-		print_lookup_table_entry(lte);
+		print_lookup_table_entry(lte, stdout);
 	} 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);
-		printf("Name = \"%s\"\n", inode->i_ads_entries[i].stream_name_utf8);
-		printf("Name Length (UTF-16) = %u\n",
-			inode->i_ads_entries[i].stream_name_len);
+		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));
+		print_lookup_table_entry(inode_stream_lte(inode, i + 1, lookup_table),
+					 stdout);
 	}
 	return 0;
 }
 
 /* Initializations done on every `struct wim_dentry'. */
-static void dentry_common_init(struct wim_dentry *dentry)
+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()
 {
 	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;
+	#ifdef WITH_FUSE
 		if (pthread_mutex_init(&inode->i_mutex, NULL) != 0) {
 			ERROR_WITH_ERRNO("Error initializing mutex");
 			FREE(inode);
@@ -798,7 +723,8 @@ static struct wim_inode *new_timeless_inode()
 	return inode;
 }
 
-static struct wim_inode *new_inode()
+static struct wim_inode *
+new_inode()
 {
 	struct wim_inode *inode = new_timeless_inode();
 	if (inode) {
@@ -810,84 +736,102 @@ static struct wim_inode *new_inode()
 	return inode;
 }
 
-/*
- * Creates an unlinked directory entry.
- *
- * @name:  The UTF-8 filename of the new dentry.
- *
- * Returns a pointer to the new dentry, or NULL if out of memory.
- */
-struct wim_dentry *new_dentry(const char *name)
+/* Creates an unlinked directory entry. */
+int
+new_dentry(const tchar *name, struct wim_dentry **dentry_ret)
 {
 	struct wim_dentry *dentry;
+	int ret;
 
 	dentry = MALLOC(sizeof(struct wim_dentry));
 	if (!dentry)
-		goto err;
+		return WIMLIB_ERR_NOMEM;
 
 	dentry_common_init(dentry);
-	if (set_dentry_name(dentry, name) != 0)
-		goto err;
-
-	dentry->parent = dentry;
-
-	return dentry;
-err:
-	FREE(dentry);
-	ERROR_WITH_ERRNO("Failed to create new dentry with name \"%s\"", name);
-	return NULL;
+	ret = set_dentry_name(dentry, name);
+	if (ret == 0) {
+		dentry->parent = dentry;
+		*dentry_ret = dentry;
+	} else {
+		FREE(dentry);
+		ERROR("Failed to set name on new dentry with name \"%"TS"\"",
+		      name);
+	}
+	return ret;
 }
 
 
-static struct wim_dentry *
-__new_dentry_with_inode(const char *name, bool timeless)
+static int
+__new_dentry_with_inode(const tchar *name, struct wim_dentry **dentry_ret,
+			bool timeless)
 {
 	struct wim_dentry *dentry;
-	dentry = new_dentry(name);
-	if (dentry) {
-		if (timeless)
-			dentry->d_inode = new_timeless_inode();
-		else
-			dentry->d_inode = new_inode();
-		if (dentry->d_inode) {
-			inode_add_dentry(dentry, dentry->d_inode);
-		} else {
-			free_dentry(dentry);
-			dentry = NULL;
-		}
+	int ret;
+
+	ret = new_dentry(name, &dentry);
+	if (ret)
+		return ret;
+
+	if (timeless)
+		dentry->d_inode = new_timeless_inode();
+	else
+		dentry->d_inode = new_inode();
+	if (!dentry->d_inode) {
+		free_dentry(dentry);
+		return WIMLIB_ERR_NOMEM;
 	}
-	return dentry;
+
+	inode_add_dentry(dentry, dentry->d_inode);
+	*dentry_ret = dentry;
+	return 0;
 }
 
-struct wim_dentry *new_dentry_with_timeless_inode(const char *name)
+int
+new_dentry_with_timeless_inode(const tchar *name, struct wim_dentry **dentry_ret)
 {
-	return __new_dentry_with_inode(name, true);
+	return __new_dentry_with_inode(name, dentry_ret, true);
 }
 
-struct wim_dentry *new_dentry_with_inode(const char *name)
+int
+new_dentry_with_inode(const tchar *name, struct wim_dentry **dentry_ret)
 {
-	return __new_dentry_with_inode(name, false);
+	return __new_dentry_with_inode(name, dentry_ret, false);
 }
 
 
-static int init_ads_entry(struct wim_ads_entry *ads_entry, const char *name)
+static int
+init_ads_entry(struct wim_ads_entry *ads_entry, const void *name,
+	       size_t name_nbytes, bool is_utf16le)
 {
 	int ret = 0;
 	memset(ads_entry, 0, sizeof(*ads_entry));
-	if (name && *name)
-		ret = change_ads_name(ads_entry, name);
+
+	if (is_utf16le) {
+		utf16lechar *p = MALLOC(name_nbytes + sizeof(utf16lechar));
+		if (!p)
+			return WIMLIB_ERR_NOMEM;
+		memcpy(p, name, name_nbytes);
+		p[name_nbytes / 2] = 0;
+		ads_entry->stream_name = p;
+		ads_entry->stream_name_nbytes = name_nbytes;
+	} else {
+		if (name && *(const tchar*)name != T('\0')) {
+			ret = get_utf16le_name(name, &ads_entry->stream_name,
+					       &ads_entry->stream_name_nbytes);
+		}
+	}
 	return ret;
 }
 
-static void destroy_ads_entry(struct wim_ads_entry *ads_entry)
+static void
+destroy_ads_entry(struct wim_ads_entry *ads_entry)
 {
 	FREE(ads_entry->stream_name);
-	FREE(ads_entry->stream_name_utf8);
 }
 
-
 /* Frees an inode. */
-void free_inode(struct wim_inode *inode)
+void
+free_inode(struct wim_inode *inode)
 {
 	if (inode) {
 		if (inode->i_ads_entries) {
@@ -909,7 +853,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) {
@@ -927,27 +872,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->file_name_utf8);
 	FREE(dentry->short_name);
-	FREE(dentry->full_path_utf8);
+	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;
@@ -962,8 +901,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;
 }
 
@@ -976,26 +914,22 @@ 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)
+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)
-{
-	dentry->refcnt++;
-	return 0;
-}
-
 /*
  * Links a dentry into the directory tree.
  *
- * @dentry: The dentry to link.
  * @parent: The dentry that will be the parent of @dentry.
+ * @dentry: The dentry to link.
  */
-bool dentry_add_child(struct wim_dentry * restrict parent,
-		      struct wim_dentry * restrict child)
+struct wim_dentry *
+dentry_add_child(struct wim_dentry * restrict parent,
+		 struct wim_dentry * restrict child)
 {
 	wimlib_assert(dentry_is_directory(parent));
 
@@ -1014,64 +948,85 @@ bool 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;
 }
 
-#ifdef WITH_FUSE
 /* Unlink a WIM dentry from the directory entry tree. */
-void unlink_dentry(struct wim_dentry *dentry)
+void
+unlink_dentry(struct wim_dentry *dentry)
 {
 	struct wim_dentry *parent = dentry->parent;
 	if (parent == dentry)
 		return;
 	rb_erase(&dentry->rb_node, &parent->d_inode->i_children);
 }
-#endif
 
-#ifdef WITH_FUSE
-/* 
+/*
  * Returns the alternate data stream entry belonging to @inode that has the
  * stream name @stream_name.
  */
-struct wim_ads_entry *inode_get_ads_entry(struct wim_inode *inode,
-				      const char *stream_name,
-				      u16 *idx_ret)
+struct wim_ads_entry *
+inode_get_ads_entry(struct wim_inode *inode, const tchar *stream_name,
+		    u16 *idx_ret)
 {
-	if (inode->i_num_ads != 0) {
-		u16 i = 0;
-		size_t stream_name_len = strlen(stream_name);
+	if (inode->i_num_ads == 0) {
+		return NULL;
+	} else {
+		size_t stream_name_utf16le_nbytes;
+		u16 i;
+		struct wim_ads_entry *result;
+
+	#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 {
 			if (ads_entry_has_name(&inode->i_ads_entries[i],
-					       stream_name, stream_name_len))
+					       stream_name_utf16le,
+					       stream_name_utf16le_nbytes))
 			{
 				if (idx_ret)
 					*idx_ret = i;
-				return &inode->i_ads_entries[i];
+				result = &inode->i_ads_entries[i];
+				break;
 			}
 		} while (++i != inode->i_num_ads);
+	#if !TCHAR_IS_UTF16LE
+		FREE(stream_name_utf16le);
+	#endif
+		return result;
 	}
-	return NULL;
 }
-#endif
 
-#if defined(WITH_FUSE) || defined(WITH_NTFS_3G)
-/*
- * Add an alternate stream entry to a WIM inode and return a pointer to it, or
- * NULL if memory could not be allocated.
- */
-struct wim_ads_entry *inode_add_ads(struct wim_inode *inode, const char *stream_name)
+static struct wim_ads_entry *
+do_inode_add_ads(struct wim_inode *inode, const void *stream_name,
+		 size_t stream_name_nbytes, bool is_utf16le)
 {
 	u16 num_ads;
 	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;
@@ -1086,20 +1041,128 @@ struct wim_ads_entry *inode_add_ads(struct wim_inode *inode, const char *stream_
 	inode->i_ads_entries = ads_entries;
 
 	new_entry = &inode->i_ads_entries[num_ads - 1];
-	if (init_ads_entry(new_entry, stream_name) != 0)
+	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;
 }
-#endif
 
-#ifdef WITH_FUSE
+struct wim_ads_entry *
+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);
+}
+
+/*
+ * Add an alternate stream entry to a WIM inode and return a pointer to it, or
+ * NULL if memory could not be allocated.
+ */
+struct wim_ads_entry *
+inode_add_ads(struct wim_inode *inode, const tchar *stream_name)
+{
+	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 tchar *name,
+			const void *value, size_t size,
+			struct wim_lookup_table *lookup_table)
+{
+	int ret = WIMLIB_ERR_NOMEM;
+	struct wim_ads_entry *new_ads_entry;
+	struct wim_lookup_table_entry *existing_lte;
+	struct wim_lookup_table_entry *lte;
+	u8 value_hash[SHA1_HASH_SIZE];
+
+	wimlib_assert(inode->i_resolved);
+	new_ads_entry = inode_add_ads(inode, name);
+	if (!new_ads_entry)
+		goto out;
+	sha1_buffer((const u8*)value, size, value_hash);
+	existing_lte = __lookup_resource(lookup_table, value_hash);
+	if (existing_lte) {
+		lte = existing_lte;
+		lte->refcnt++;
+	} else {
+		u8 *value_copy;
+		lte = new_lookup_table_entry();
+		if (!lte)
+			goto out_remove_ads_entry;
+		value_copy = MALLOC(size);
+		if (!value_copy) {
+			FREE(lte);
+			goto out_remove_ads_entry;
+		}
+		memcpy(value_copy, value, size);
+		lte->resource_location            = RESOURCE_IN_ATTACHED_BUFFER;
+		lte->attached_buffer              = value_copy;
+		lte->resource_entry.original_size = size;
+		lte->resource_entry.size          = size;
+		copy_hash(lte->hash, value_hash);
+		lookup_table_insert(lookup_table, lte);
+	}
+	new_ads_entry->lte = lte;
+	ret = 0;
+	goto out;
+out_remove_ads_entry:
+	inode_remove_ads(inode, new_ads_entry - inode->i_ads_entries,
+			 lookup_table);
+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 {
+		void *buf;
+
+		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,
-		      struct wim_lookup_table *lookup_table)
+void
+inode_remove_ads(struct wim_inode *inode, u16 idx,
+		 struct wim_lookup_table *lookup_table)
 {
 	struct wim_ads_entry *ads_entry;
 	struct wim_lookup_table_entry *lte;
@@ -1109,7 +1172,7 @@ void inode_remove_ads(struct wim_inode *inode, u16 idx,
 
 	ads_entry = &inode->i_ads_entries[idx];
 
-	DEBUG("Remove alternate data stream \"%s\"", ads_entry->stream_name_utf8);
+	DEBUG("Remove alternate data stream \"%"WS"\"", ads_entry->stream_name);
 
 	lte = ads_entry->lte;
 	if (lte)
@@ -1117,14 +1180,116 @@ void inode_remove_ads(struct wim_inode *inode, u16 idx,
 
 	destroy_ads_entry(ads_entry);
 
-	memcpy(&inode->i_ads_entries[idx],
-	       &inode->i_ads_entries[idx + 1],
-	       (inode->i_num_ads - idx - 1) * sizeof(inode->i_ads_entries[0]));
+	memmove(&inode->i_ads_entries[idx],
+		&inode->i_ads_entries[idx + 1],
+		(inode->i_num_ads - idx - 1) * sizeof(inode->i_ads_entries[0]));
 	inode->i_num_ads--;
 }
-#endif
 
+#ifndef __WIN32__
+int
+inode_get_unix_data(const struct wim_inode *inode,
+		    struct wimlib_unix_data *unix_data,
+		    u16 *stream_idx_ret)
+{
+	const struct wim_ads_entry *ads_entry;
+	const struct wim_lookup_table_entry *lte;
+	size_t size;
+	int ret;
+
+	wimlib_assert(inode->i_resolved);
+
+	ads_entry = inode_get_ads_entry((struct wim_inode*)inode,
+					WIMLIB_UNIX_DATA_TAG, NULL);
+	if (!ads_entry)
+		return NO_UNIX_DATA;
 
+	if (stream_idx_ret)
+		*stream_idx_ret = ads_entry - inode->i_ads_entries;
+
+	lte = ads_entry->lte;
+	if (!lte)
+		return NO_UNIX_DATA;
+
+	size = wim_resource_size(lte);
+	if (size != sizeof(struct wimlib_unix_data))
+		return BAD_UNIX_DATA;
+
+	ret = read_full_resource_into_buf(lte, unix_data, true);
+	if (ret)
+		return ret;
+
+	if (unix_data->version != 0)
+		return BAD_UNIX_DATA;
+	return 0;
+}
+
+int
+inode_set_unix_data(struct wim_inode *inode, uid_t uid, gid_t gid, mode_t mode,
+		    struct wim_lookup_table *lookup_table, int which)
+{
+	struct wimlib_unix_data unix_data;
+	int ret;
+	bool have_good_unix_data = false;
+	bool have_unix_data = false;
+	u16 stream_idx;
+
+	if (!(which & UNIX_DATA_CREATE)) {
+		ret = inode_get_unix_data(inode, &unix_data, &stream_idx);
+		if (ret == 0 || ret == BAD_UNIX_DATA || ret > 0)
+			have_unix_data = true;
+		if (ret == 0)
+			have_good_unix_data = true;
+	}
+	unix_data.version = 0;
+	if (which & UNIX_DATA_UID || !have_good_unix_data)
+		unix_data.uid = uid;
+	if (which & UNIX_DATA_GID || !have_good_unix_data)
+		unix_data.gid = gid;
+	if (which & UNIX_DATA_MODE || !have_good_unix_data)
+		unix_data.mode = mode;
+	ret = inode_add_ads_with_data(inode, WIMLIB_UNIX_DATA_TAG,
+				      &unix_data,
+				      sizeof(struct wimlib_unix_data),
+				      lookup_table);
+	if (ret == 0 && have_unix_data)
+		inode_remove_ads(inode, stream_idx, lookup_table);
+	return ret;
+}
+#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 == '/')
+	#endif
+		{
+		#ifdef __WIN32__
+			*p = cpu_to_le16(0xfffd);
+		#else
+			*p = '?';
+		#endif
+			if (name) {
+				WARNING("File, directory, or stream name \"%"WS"\"\n"
+					"          contains forbidden characters; "
+					"substituting replacement characters.",
+					name);
+				name = NULL;
+			}
+		}
+	}
+}
 
 /*
  * Reads the alternate data stream entries of a WIM dentry.
@@ -1166,8 +1331,8 @@ void inode_remove_ads(struct wim_inode *inode, u16 idx,
  * is set to an array of `struct wim_ads_entry's of length inode->i_num_ads.  On
  * failure, @inode is not modified.
  */
-static int read_ads_entries(const u8 *p, struct wim_inode *inode,
-			    u64 remaining_size)
+static int
+read_ads_entries(const u8 *p, struct wim_inode *inode, u64 remaining_size)
 {
 	u16 num_ads;
 	struct wim_ads_entry *ads_entries;
@@ -1186,7 +1351,6 @@ static int read_ads_entries(const u8 *p, struct wim_inode *inode,
 		u64 length;
 		u64 length_no_padding;
 		u64 total_length;
-		size_t utf8_len;
 		const u8 *p_save = p;
 
 		cur_entry = &ads_entries[i];
@@ -1204,17 +1368,16 @@ static int read_ads_entries(const u8 *p, struct wim_inode *inode,
 		}
 
 		p = get_u64(p, &length);
-		p += 8; /* Skip the reserved field */
-		p = get_bytes(p, SHA1_HASH_SIZE, (u8*)cur_entry->hash);
-		p = get_u16(p, &cur_entry->stream_name_len);
+		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);
 
 		cur_entry->stream_name = NULL;
-		cur_entry->stream_name_utf8 = NULL;
 
 		/* Length including neither the null terminator nor the padding
 		 * */
 		length_no_padding = WIM_ADS_ENTRY_DISK_SIZE +
-				    cur_entry->stream_name_len;
+				    cur_entry->stream_name_nbytes;
 
 		/* Length including the null terminator and the padding */
 		total_length = ((length_no_padding + 2) + 7) & ~7;
@@ -1246,22 +1409,16 @@ static int read_ads_entries(const u8 *p, struct wim_inode *inode,
 			goto out_free_ads_entries;
 		}
 
-		if (cur_entry->stream_name_len) {
-			cur_entry->stream_name = MALLOC(cur_entry->stream_name_len);
+		if (cur_entry->stream_name_nbytes) {
+			cur_entry->stream_name = MALLOC(cur_entry->stream_name_nbytes + 2);
 			if (!cur_entry->stream_name) {
 				ret = WIMLIB_ERR_NOMEM;
 				goto out_free_ads_entries;
 			}
-			get_bytes(p, cur_entry->stream_name_len,
-				  (u8*)cur_entry->stream_name);
-
-			ret = utf16_to_utf8(cur_entry->stream_name,
-					    cur_entry->stream_name_len,
-					    &cur_entry->stream_name_utf8,
-					    &utf8_len);
-			if (ret != 0)
-				goto out_free_ads_entries;
-			cur_entry->stream_name_utf8_len = utf8_len;
+			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
@@ -1304,17 +1461,16 @@ out_free_ads_entries:
  * this was a special "end of directory" dentry and not a real dentry.  If
  * nonzero, this was a real dentry.
  */
-int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
-		u64 offset, struct wim_dentry *dentry)
+int
+read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
+	    u64 offset, struct wim_dentry *dentry)
 {
 	const u8 *p;
 	u64 calculated_size;
-	char *file_name = NULL;
-	char *file_name_utf8 = NULL;
-	char *short_name = NULL;
-	u16 short_name_len;
-	u16 file_name_len;
-	size_t file_name_utf8_len = 0;
+	utf16lechar *file_name = NULL;
+	utf16lechar *short_name = NULL;
+	u16 short_name_nbytes;
+	u16 file_name_nbytes;
 	int ret;
 	struct wim_inode *inode = NULL;
 
@@ -1369,10 +1525,8 @@ int 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);
@@ -1380,19 +1534,16 @@ int 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);
 	}
 
@@ -1401,8 +1552,8 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 
 	p = get_u16(p, &inode->i_num_ads);
 
-	p = get_u16(p, &short_name_len);
-	p = get_u16(p, &file_name_len);
+	p = get_u16(p, &short_name_nbytes);
+	p = get_u16(p, &file_name_nbytes);
 
 	/* We now know the length of the file name and short name.  Make sure
 	 * the length of the dentry is large enough to actually hold them.
@@ -1410,40 +1561,36 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 	 * The calculated length here is unaligned to allow for the possibility
 	 * that the dentry->length names an unaligned length, although this
 	 * would be unexpected. */
-	calculated_size = __dentry_correct_length_unaligned(file_name_len,
-							    short_name_len);
+	calculated_size = __dentry_correct_length_unaligned(file_name_nbytes,
+							    short_name_nbytes);
 
 	if (dentry->length < calculated_size) {
 		ERROR("Unexpected end of directory entry! (Expected "
 		      "at least %"PRIu64" bytes, got %"PRIu64" bytes. "
-		      "short_name_len = %hu, file_name_len = %hu)",
+		      "short_name_nbytes = %hu, file_name_nbytes = %hu)",
 		      calculated_size, dentry->length,
-		      short_name_len, file_name_len);
+		      short_name_nbytes, file_name_nbytes);
 		ret = WIMLIB_ERR_INVALID_DENTRY;
 		goto out_free_inode;
 	}
 
 	/* Read the filename if present.  Note: if the filename is empty, there
 	 * is no null terminator following it. */
-	if (file_name_len) {
-		file_name = MALLOC(file_name_len);
+	if (file_name_nbytes) {
+		file_name = MALLOC(file_name_nbytes + 2);
 		if (!file_name) {
-			ERROR("Failed to allocate %hu bytes for dentry file name",
-			      file_name_len);
+			ERROR("Failed to allocate %d bytes for dentry file name",
+			      file_name_nbytes + 2);
 			ret = WIMLIB_ERR_NOMEM;
 			goto out_free_inode;
 		}
-		p = get_bytes(p, file_name_len, file_name);
-
-		/* Convert filename to UTF-8. */
-		ret = utf16_to_utf8(file_name, file_name_len, &file_name_utf8,
-				    &file_name_utf8_len);
-		if (ret != 0)
-			goto out_free_file_name;
-		if (*(u16*)p)
-			WARNING("Expected two zero bytes following the file name "
-				"`%s', but found non-zero bytes", file_name_utf8);
-		p += 2;
+		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 \"%"WS"\" is not "
+				"null-terminated!", file_name);
+		}
+		replace_forbidden_characters(file_name);
 	}
 
 	/* Align the calculated size */
@@ -1473,27 +1620,28 @@ int 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
 	 * filename, there is no null terminator following it. */
-	if (short_name_len) {
-		short_name = MALLOC(short_name_len);
+	if (short_name_nbytes) {
+		short_name = MALLOC(short_name_nbytes + 2);
 		if (!short_name) {
-			ERROR("Failed to allocate %hu bytes for short filename",
-			      short_name_len);
+			ERROR("Failed to allocate %d bytes for dentry short name",
+			      short_name_nbytes + 2);
 			ret = WIMLIB_ERR_NOMEM;
-			goto out_free_file_name_utf8;
+			goto out_free_file_name;
 		}
-
-		p = get_bytes(p, short_name_len, short_name);
-		if (*(u16*)p)
-			WARNING("Expected two zero bytes following the short name of "
-				"`%s', but found non-zero bytes", file_name_utf8);
-		p += 2;
+		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 \"%"WS"\" is not "
+				"null-terminated!", file_name);
+		}
+		replace_forbidden_characters(short_name);
 	}
 
 	/*
@@ -1531,25 +1679,20 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 				goto out;
 		}
 		ERROR("Failed to read alternate data stream "
-		      "entries of `%s'", dentry->file_name_utf8);
+		      "entries of WIM dentry \"%"WS"\"", file_name);
 		goto out_free_short_name;
 	}
 out:
-
 	/* We've read all the data for this dentry.  Set the names and their
 	 * lengths, and we've done. */
-	dentry->d_inode            = inode;
-	dentry->file_name          = file_name;
-	dentry->file_name_utf8     = file_name_utf8;
-	dentry->short_name         = short_name;
-	dentry->file_name_len      = file_name_len;
-	dentry->file_name_utf8_len = file_name_utf8_len;
-	dentry->short_name_len     = short_name_len;
+	dentry->d_inode           = inode;
+	dentry->file_name         = file_name;
+	dentry->short_name        = short_name;
+	dentry->file_name_nbytes  = file_name_nbytes;
+	dentry->short_name_nbytes = short_name_nbytes;
 	return 0;
 out_free_short_name:
 	FREE(short_name);
-out_free_file_name_utf8:
-	FREE(file_name_utf8);
 out_free_file_name:
 	FREE(file_name);
 out_free_inode:
@@ -1571,10 +1714,11 @@ out_free_inode:
  *		does not need to be the real root because this procedure is
  *		called recursively.
  *
- * @return:	Zero on success, nonzero on failure.
+ * Returns zero on success; nonzero on failure.
  */
-int read_dentry_tree(const u8 metadata_resource[], u64 metadata_resource_len,
-		     struct wim_dentry *dentry)
+int
+read_dentry_tree(const u8 metadata_resource[], u64 metadata_resource_len,
+		 struct wim_dentry *dentry)
 {
 	u64 cur_offset = dentry->subdir_offset;
 	struct wim_dentry *child;
@@ -1643,7 +1787,8 @@ int read_dentry_tree(const u8 metadata_resource[], u64 metadata_resource_len,
  * @return:  Pointer to the byte after the last byte we wrote as part of the
  * 		dentry.
  */
-static u8 *write_dentry(const struct wim_dentry *dentry, u8 *p)
+static u8 *
+write_dentry(const struct wim_dentry *dentry, u8 *p)
 {
 	u8 *orig_p = p;
 	const u8 *hash;
@@ -1659,20 +1804,21 @@ static u8 *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
@@ -1680,15 +1826,15 @@ static u8 *write_dentry(const struct wim_dentry *dentry, u8 *p)
 		p = put_u64(p, link_group_id);
 	}
 	p = put_u16(p, inode->i_num_ads);
-	p = put_u16(p, dentry->short_name_len);
-	p = put_u16(p, dentry->file_name_len);
-	if (dentry->file_name_len) {
-		p = put_bytes(p, dentry->file_name_len, (u8*)dentry->file_name);
-		p = put_u16(p, 0); /* filename padding, 2 bytes. */
+	p = put_u16(p, dentry->short_name_nbytes);
+	p = put_u16(p, dentry->file_name_nbytes);
+	if (dentry_has_long_name(dentry)) {
+		p = put_bytes(p, dentry->file_name_nbytes + 2,
+			      dentry->file_name);
 	}
-	if (dentry->short_name) {
-		p = put_bytes(p, dentry->short_name_len, (u8*)dentry->short_name);
-		p = put_u16(p, 0); /* short name padding, 2 bytes */
+	if (dentry_has_short_name(dentry)) {
+		p = put_bytes(p, dentry->short_name_nbytes + 2,
+			      dentry->short_name);
 	}
 
 	/* Align to 8-byte boundary */
@@ -1700,14 +1846,14 @@ static u8 *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_len);
-		if (inode->i_ads_entries[i].stream_name_len) {
-			p = put_bytes(p, inode->i_ads_entries[i].stream_name_len,
-					 (u8*)inode->i_ads_entries[i].stream_name);
-			p = put_u16(p, 0);
+		p = put_u16(p, inode->i_ads_entries[i].stream_name_nbytes);
+		if (inode->i_ads_entries[i].stream_name_nbytes) {
+			p = put_bytes(p,
+				      inode->i_ads_entries[i].stream_name_nbytes + 2,
+				      inode->i_ads_entries[i].stream_name);
 		}
 		p = put_zeroes(p, (8 - (p - orig_p) % 8) % 8);
 	}
@@ -1715,16 +1861,19 @@ static u8 *write_dentry(const struct wim_dentry *dentry, u8 *p)
 	return p;
 }
 
-static int write_dentry_cb(struct wim_dentry *dentry, void *_p)
+static int
+write_dentry_cb(struct wim_dentry *dentry, void *_p)
 {
 	u8 **p = _p;
 	*p = write_dentry(dentry, *p);
 	return 0;
 }
 
-static u8 *write_dentry_tree_recursive(const struct wim_dentry *parent, u8 *p);
+static u8 *
+write_dentry_tree_recursive(const struct wim_dentry *parent, u8 *p);
 
-static int write_dentry_tree_recursive_cb(struct wim_dentry *dentry, void *_p)
+static int
+write_dentry_tree_recursive_cb(struct wim_dentry *dentry, void *_p)
 {
 	u8 **p = _p;
 	*p = write_dentry_tree_recursive(dentry, *p);
@@ -1733,7 +1882,8 @@ static int write_dentry_tree_recursive_cb(struct wim_dentry *dentry, void *_p)
 
 /* Recursive function that writes a dentry tree rooted at @parent, not including
  * @parent itself, which has already been written. */
-static u8 *write_dentry_tree_recursive(const struct wim_dentry *parent, u8 *p)
+static u8 *
+write_dentry_tree_recursive(const struct wim_dentry *parent, u8 *p)
 {
 	/* Nothing to do if this dentry has no children. */
 	if (parent->subdir_offset == 0)
@@ -1745,14 +1895,13 @@ static u8 *write_dentry_tree_recursive(const struct wim_dentry *parent, u8 *p)
 	 * recursively writing the directory trees rooted at each of the child
 	 * dentries, since the on-disk dentries for a dentry's children are
 	 * always located at consecutive positions in the metadata resource! */
-	for_dentry_in_rbtree(parent->d_inode->i_children.rb_node, write_dentry_cb, &p);
+	for_dentry_child(parent, write_dentry_cb, &p);
 
 	/* write end of directory entry */
 	p = put_u64(p, 0);
 
 	/* Recurse on children. */
-	for_dentry_in_rbtree(parent->d_inode->i_children.rb_node,
-			     write_dentry_tree_recursive_cb, &p);
+	for_dentry_child(parent, write_dentry_tree_recursive_cb, &p);
 	return p;
 }
 
@@ -1763,7 +1912,8 @@ static u8 *write_dentry_tree_recursive(const struct wim_dentry *parent, u8 *p)
  *
  * Returns pointer to the byte after the last byte we wrote.
  */
-u8 *write_dentry_tree(const struct wim_dentry *root, u8 *p)
+u8 *
+write_dentry_tree(const struct wim_dentry *root, u8 *p)
 {
 	DEBUG("Writing dentry tree.");
 	wimlib_assert(dentry_is_root(root));