X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fdentry.c;h=e9826b55d1e4f1ae9911e1b5dcdf0d793a1e0489;hp=ea2cdb1b611ec144f3f13fa6f79fbea29c87f4b8;hb=cf373e59a7f6ff7d1fd007c1f22defe508aa67d4;hpb=14baa6ae892debbaa18dba8119931580efd0e517

diff --git a/src/dentry.c b/src/dentry.c
index ea2cdb1b..e9826b55 100644
--- a/src/dentry.c
+++ b/src/dentry.c
@@ -76,24 +76,35 @@ 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);
-	if (name_utf16le_nbytes > 0xffff) {
-		FREE(name_utf16le);
-		ERROR("Multibyte string \"%s\" is too long!", name);
-		ret = WIMLIB_ERR_INVALID_UTF8_STRING;
+	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;
+		}
 	}
+#endif
 	if (ret == 0) {
 		FREE(*name_utf16le_ret);
 		*name_utf16le_ret = name_utf16le;
@@ -104,14 +115,14 @@ get_utf16le_name(const mbchar *name, utf16lechar **name_utf16le_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,
 			       &dentry->file_name_nbytes);
 	if (ret == 0) {
 		/* Clear the short name and recalculate the dentry length */
-		if (dentry->short_name_nbytes) {
+		if (dentry_has_short_name(dentry)) {
 			FREE(dentry->short_name);
 			dentry->short_name = NULL;
 			dentry->short_name_nbytes = 0;
@@ -263,62 +274,86 @@ for_dentry_in_tree_depth(struct wim_dentry *root,
 }
 
 /* Calculate the full path of @dentry.  The full path of its parent must have
- * already been calculated. */
+ * already been calculated, or it must be the root dentry. */
 int
-calculate_dentry_full_path(struct wim_dentry *dentry, void *ignore)
+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;
-		char *name_mbs;
-		size_t name_mbs_nbytes;
-		int ret;
-
-		ret = utf16le_to_mbs_nbytes(dentry->file_name,
-					    dentry->file_name_nbytes,
-					    &name_mbs_nbytes);
-		if (ret)
-			return ret;
+		size_t filename_nbytes;
+
 		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;
 }
 
+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)
 {
@@ -370,25 +405,36 @@ calculate_subdir_offsets(struct wim_dentry *dentry, u64 *subdir_offset_p)
 }
 
 static int
-dentry_compare_names(const struct wim_dentry *d1, const struct wim_dentry *d2)
+compare_utf16le_names(const utf16lechar *name1, size_t nbytes1,
+		      const utf16lechar *name2, size_t nbytes2)
 {
-	int result = memcmp(d1->file_name, d2->file_name,
-			    min(d1->file_name_nbytes, d2->file_name_nbytes));
+	int result = memcmp(name1, name2, min(nbytes1, nbytes2));
 	if (result)
 		return result;
 	else
-		return d1->file_name_nbytes - d2->file_name_nbytes;
+		return (int)nbytes1 - (int)nbytes2;
+}
+
+static int
+dentry_compare_names(const struct wim_dentry *d1, const struct wim_dentry *d2)
+{
+	return compare_utf16le_names(d1->file_name, d1->file_name_nbytes,
+				     d2->file_name, d2->file_name_nbytes);
 }
 
 
 struct wim_dentry *
 get_dentry_child_with_utf16le_name(const struct wim_dentry *dentry,
-				   const utf16lechar *name)
+				   const utf16lechar *name,
+				   size_t name_nbytes)
 {
 	struct rb_node *node = dentry->d_inode->i_children.rb_node;
+	struct wim_dentry *child;
 	while (node) {
-		struct wim_dentry *child = rbnode_dentry(node);
-		int result = dentry_compare_names(dentry, child);
+		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)
@@ -402,66 +448,56 @@ 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 {
 		child = get_dentry_child_with_utf16le_name(dentry,
-							   utf16le_name);
+							   utf16le_name,
+							   utf16le_name_nbytes);
 		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;
-	utf16lechar save;
-
-	ret = mbs_to_utf16le(path, strlen(path), &path_utf16le,
-			     &path_utf16le_nbytes);
-	if (ret) {
-		errno = ENOMEM;
-		return NULL;
-	}
-
-	parent_dentry = wim_root_dentry(w);
-	p = path_utf16le;
+	const utf16lechar *p, *pp;
 
+	cur_dentry = parent_dentry = wim_root_dentry(w);
+	p = path;
 	while (1) {
-		while (*p == '/')
+		while (*p == cpu_to_le16('/'))
 			p++;
-		cur_dentry = parent_dentry;
 		if (*p == '\0')
 			break;
 		pp = p;
-		while (*pp != '/' && *pp != '\0')
+		while (*pp != cpu_to_le16('/') && *pp != cpu_to_le16('\0'))
 			pp++;
 
-		save = *pp;
-		*pp = '\0';
-		cur_dentry = get_dentry_child_with_utf16le_name(parent_dentry, p);
+		cur_dentry = get_dentry_child_with_utf16le_name(parent_dentry, p,
+								(void*)pp - (void*)p);
 		if (cur_dentry == NULL)
 			break;
-		*pp = save;
 		p = pp;
+		parent_dentry = cur_dentry;
 	}
-	FREE(path_utf16le);
 	if (cur_dentry == NULL) {
 		if (dentry_is_directory(parent_dentry))
 			errno = ENOENT;
@@ -471,8 +507,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);
@@ -482,23 +541,45 @@ 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)
+struct wim_dentry *
+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)
+int
+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);
+	FREE(dentry->_full_path);
+	dentry->_full_path = NULL;
+	dentry->full_path_nbytes = 0;
 	return 0;
 }
 
@@ -506,62 +587,66 @@ 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);
-	wimlib_printf("Filename = \"%W\"\n", dentry->file_name);
-	wimlib_printf("Short Name \"%W\"\n", dentry->short_name);
-	printf("Full Path = \"%s\"\n", dentry->full_path);
+	tprintf(T("Last Write Time   = %"TS"\n"), buf);
+
+	tprintf(T("Reparse Tag       = 0x%"PRIx32"\n"), inode->i_reparse_tag);
+	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) {
@@ -569,22 +654,23 @@ int 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) = %u\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);
@@ -593,20 +679,21 @@ int print_dentry(struct wim_dentry *dentry, void *lookup_table)
 }
 
 /* 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;
+	#ifdef WITH_FUSE
 		if (pthread_mutex_init(&inode->i_mutex, NULL) != 0) {
 			ERROR_WITH_ERRNO("Error initializing mutex");
 			FREE(inode);
@@ -618,7 +705,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) {
@@ -630,76 +718,89 @@ 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 mbchar *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 mbchar *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 mbchar *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 mbchar *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 mbchar *name)
+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 = get_utf16le_name(name, &ads_entry->stream_name,
-				       &ads_entry->stream_name_nbytes);
+
+	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;
 }
@@ -711,7 +812,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) {
@@ -733,7 +835,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) {
@@ -751,26 +854,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;
@@ -785,8 +883,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;
 }
 
@@ -799,18 +896,13 @@ 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.
  *
@@ -861,24 +953,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 {
@@ -892,24 +994,21 @@ 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;
 	}
 }
 
-/*
- * 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;
@@ -924,17 +1023,37 @@ inode_add_ads(struct wim_inode *inode, const char *stream_name)
 	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;
 }
 
+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 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)
 {
@@ -957,25 +1076,24 @@ inode_add_ads_with_data(struct wim_inode *inode, const mbchar *name,
 		u8 *value_copy;
 		lte = new_lookup_table_entry();
 		if (!lte)
-			goto out_free_ads_entry;
+			goto out_remove_ads_entry;
 		value_copy = MALLOC(size);
 		if (!value_copy) {
 			FREE(lte);
-			goto out_free_ads_entry;
+			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;
-		lte->resource_entry.flags         = 0;
 		copy_hash(lte->hash, value_hash);
 		lookup_table_insert(lookup_table, lte);
 	}
 	new_ads_entry->lte = lte;
 	ret = 0;
 	goto out;
-out_free_ads_entry:
+out_remove_ads_entry:
 	inode_remove_ads(inode, new_ads_entry - inode->i_ads_entries,
 			 lookup_table);
 out:
@@ -995,7 +1113,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)
@@ -1038,7 +1156,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, true);
 	if (ret)
 		return ret;
 
@@ -1072,7 +1190,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)
@@ -1141,7 +1259,6 @@ read_ads_entries(const u8 *p, struct wim_inode *inode, u64 remaining_size)
 		u64 length;
 		u64 length_no_padding;
 		u64 total_length;
-		size_t utf8_len;
 		const u8 *p_save = p;
 
 		cur_entry = &ads_entries[i];
@@ -1160,7 +1277,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_bytes(p, SHA1_HASH_SIZE, (u8*)cur_entry->hash);
+		p = get_bytes(p, SHA1_HASH_SIZE, cur_entry->hash);
 		p = get_u16(p, &cur_entry->stream_name_nbytes);
 
 		cur_entry->stream_name = NULL;
@@ -1201,8 +1318,7 @@ read_ads_entries(const u8 *p, struct wim_inode *inode, u64 remaining_size)
 		}
 
 		if (cur_entry->stream_name_nbytes) {
-			cur_entry->stream_name = MALLOC((size_t)
-							cur_entry->stream_name_nbytes + 2);
+			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;
@@ -1327,19 +1443,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_reparse_tag);
 		p += 4;
 	} else {
-		p = get_u32(p, &inode->i_reparse_tag);
+		p += 4;
+		/* i_reparse_tag is irrelevant; just leave it at 0. */
 		p = get_u64(p, &inode->i_ino);
 	}
 
@@ -1373,17 +1486,17 @@ read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 	/* Read the filename if present.  Note: if the filename is empty, there
 	 * is no null terminator following it. */
 	if (file_name_nbytes) {
-		file_name = MALLOC((size_t)file_name_nbytes + 2);
+		file_name = MALLOC(file_name_nbytes + 2);
 		if (!file_name) {
-			ERROR("Failed to allocate %zu bytes for dentry file name",
-			      (size_t)file_name_nbytes + 2);
+			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, (size_t)file_name_nbytes + 2, file_name);
+		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);
 		}
 	}
@@ -1415,25 +1528,25 @@ 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_nbytes) {
-		short_name = MALLOC((size_t)short_name_nbytes + 2);
+		short_name = MALLOC(short_name_nbytes + 2);
 		if (!short_name) {
-			ERROR("Failed to allocate %zu bytes for dentry short name",
-			      (size_t)short_name_nbytes + 2);
+			ERROR("Failed to allocate %d bytes for dentry short name",
+			      short_name_nbytes + 2);
 			ret = WIMLIB_ERR_NOMEM;
 			goto out_free_file_name;
 		}
-		p = get_bytes(p, (size_t)short_name_nbytes + 2, short_name);
+		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);
 		}
 	}
@@ -1473,7 +1586,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:
@@ -1621,11 +1734,11 @@ write_dentry(const struct wim_dentry *dentry, u8 *p)
 	p = put_u16(p, inode->i_num_ads);
 	p = put_u16(p, dentry->short_name_nbytes);
 	p = put_u16(p, dentry->file_name_nbytes);
-	if (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_nbytes) {
+	if (dentry_has_short_name(dentry)) {
 		p = put_bytes(p, dentry->short_name_nbytes + 2,
 			      dentry->short_name);
 	}