X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fdentry.c;h=27937ab42a55a933e6833e34d5325bec7fdbd757;hp=cf77adc765c6180100c43cbea5726a844ca86881;hb=01efbb02603508a2272f859c87ec259560aa823d;hpb=3489da595e09caf8d6867661c45b4dab188f6ece

diff --git a/src/dentry.c b/src/dentry.c
index cf77adc7..27937ab4 100644
--- a/src/dentry.c
+++ b/src/dentry.c
@@ -30,14 +30,17 @@
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
+#include <errno.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <unistd.h>
+
 #include "wimlib_internal.h"
 #include "dentry.h"
 #include "io.h"
 #include "timestamp.h"
 #include "lookup_table.h"
 #include "sha1.h"
-#include <unistd.h>
-#include <sys/stat.h>
 
 /*
  * Returns true if @dentry has the UTF-8 file name @name that has length
@@ -51,14 +54,6 @@ static bool dentry_has_name(const struct dentry *dentry, const char *name,
 	return memcmp(dentry->file_name_utf8, name, name_len) == 0;
 }
 
-static bool ads_entry_has_name(const struct ads_entry *entry,
-			       const char *name, size_t name_len)
-{
-	if (entry->stream_name_utf8_len != name_len)
-		return false;
-	return memcmp(entry->stream_name_utf8, name, name_len) == 0;
-}
-
 /* Real length of a dentry, including the alternate data stream entries, which
  * are not included in the dentry->length field... */
 u64 dentry_total_length(const struct dentry *dentry)
@@ -85,45 +80,17 @@ void stbuf_to_dentry(const struct stat *stbuf, struct dentry *dentry)
 	else
 		dentry->hard_link = (u64)stbuf->st_ino |
 				   ((u64)stbuf->st_dev << (sizeof(ino_t) * 8));
+	/* Set timestamps */
+	dentry->creation_time = timespec_to_wim_timestamp(&stbuf->st_mtim);
+	dentry->last_write_time = timespec_to_wim_timestamp(&stbuf->st_mtim);
+	dentry->last_access_time = timespec_to_wim_timestamp(&stbuf->st_atim);
 }
 
-/* Transfers file attributes from a struct dentry to a `stat' buffer. */
-void dentry_to_stbuf(const struct dentry *dentry, struct stat *stbuf, 
-		     const struct lookup_table *table)
-{
-	struct lookup_table_entry *lte;
-
-	if (dentry_is_symlink(dentry))
-		stbuf->st_mode = S_IFLNK | 0777;
-	else if (dentry_is_directory(dentry))
-		stbuf->st_mode = S_IFDIR | 0755;
-	else
-		stbuf->st_mode = S_IFREG | 0644;
-
-	if (table)
-		lte = __lookup_resource(table, dentry_hash(dentry));
-	else
-		lte = NULL;
-
-	if (lte) {
-		stbuf->st_nlink = lte->refcnt;
-		stbuf->st_size = lte->resource_entry.original_size;
-	} else {
-		stbuf->st_nlink = 1;
-		stbuf->st_size = 0;
-	}
-	stbuf->st_uid     = getuid();
-	stbuf->st_gid     = getgid();
-	stbuf->st_atime   = ms_timestamp_to_unix(dentry->last_access_time);
-	stbuf->st_mtime   = ms_timestamp_to_unix(dentry->last_write_time);
-	stbuf->st_ctime   = ms_timestamp_to_unix(dentry->creation_time);
-	stbuf->st_blocks  = (stbuf->st_size + 511) / 512;
-}
 
 /* Makes all timestamp fields for the dentry be the current time. */
 void dentry_update_all_timestamps(struct dentry *dentry)
 {
-	u64 now = get_timestamp();
+	u64 now = get_wim_timestamp();
 	dentry->creation_time    = now;
 	dentry->last_access_time = now;
 	dentry->last_write_time  = now;
@@ -142,39 +109,66 @@ struct ads_entry *dentry_get_ads_entry(struct dentry *dentry,
 	return NULL;
 }
 
+static void ads_entry_init(struct ads_entry *ads_entry)
+{
+	memset(ads_entry, 0, sizeof(struct ads_entry));
+	INIT_LIST_HEAD(&ads_entry->lte_group_list.list);
+	ads_entry->lte_group_list.type = STREAM_TYPE_ADS;
+}
+
 /* Add an alternate stream entry to a dentry and return a pointer to it, or NULL
  * on failure. */
 struct ads_entry *dentry_add_ads(struct dentry *dentry, const char *stream_name)
 {
-	u16 num_ads = dentry->num_ads + 1;
+	u16 num_ads;
 	struct ads_entry *ads_entries;
 	struct ads_entry *new_entry;
-	if (num_ads == 0xffff)
+
+	if (dentry->num_ads == 0xffff)
 		return NULL;
-	ads_entries = MALLOC(num_ads * sizeof(struct ads_entry));
+ 	num_ads = dentry->num_ads + 1;
+	ads_entries = REALLOC(dentry->ads_entries,
+			      num_ads * sizeof(struct ads_entry));
 	if (!ads_entries)
 		return NULL;
+	if (ads_entries != dentry->ads_entries) {
+		/* We moved the ADS entries.  Adjust the stream lists. */
+		for (u16 i = 0; i < dentry->num_ads; i++) {
+			struct list_head *cur = &ads_entries[i].lte_group_list.list;
+			cur->prev->next = cur;
+			cur->next->prev = cur;
+		}
+	}
+	dentry->ads_entries = ads_entries;
 
 	new_entry = &ads_entries[num_ads - 1];
-	if (change_ads_name(new_entry, stream_name) != 0) {
-		FREE(ads_entries);
+	if (change_ads_name(new_entry, stream_name) != 0)
 		return NULL;
-	}
-
-	memcpy(ads_entries, dentry->ads_entries,
-	       (num_ads - 1) * sizeof(struct ads_entry));
-	FREE(dentry->ads_entries);
-	dentry->ads_entries = ads_entries;
 	dentry->num_ads = num_ads;
-	return memset(new_entry, 0, sizeof(struct ads_entry));
+	ads_entry_init(new_entry);
+	return new_entry;
 }
 
-void dentry_remove_ads(struct dentry *dentry, struct ads_entry *sentry)
+void dentry_remove_ads(struct dentry *dentry, struct ads_entry *ads_entry)
 {
-	destroy_ads_entry(sentry);
-	memcpy(sentry, sentry + 1,
-	       (dentry->num_ads - (sentry - dentry->ads_entries))
-		 * sizeof(struct ads_entry));
+	u16 idx;
+	u16 following;
+
+	wimlib_assert(dentry->num_ads);
+	idx = ads_entry - dentry->ads_entries;
+	wimlib_assert(idx < dentry->num_ads);
+ 	following = dentry->num_ads - idx - 1;
+
+	destroy_ads_entry(ads_entry);
+	memcpy(ads_entry, ads_entry + 1, following * sizeof(struct ads_entry));
+
+	/* We moved the ADS entries.  Adjust the stream lists. */
+	for (u16 i = 0; i < following; i++) {
+		struct list_head *cur = &ads_entry[i].lte_group_list.list;
+		cur->prev->next = cur;
+		cur->next->prev = cur;
+	}
+
 	dentry->num_ads--;
 }
 
@@ -424,26 +418,35 @@ struct file_attr_flag file_attr_flags[] = {
  * NULL if the resource entry for the dentry is not to be printed. */
 int print_dentry(struct dentry *dentry, void *lookup_table)
 {
+	const u8 *hash;
 	struct lookup_table_entry *lte;
-	unsigned i;
 
 	printf("[DENTRY]\n");
 	printf("Length            = %"PRIu64"\n", dentry->length);
 	printf("Attributes        = 0x%x\n", dentry->attributes);
-	for (i = 0; i < ARRAY_LEN(file_attr_flags); i++)
+	for (unsigned i = 0; i < ARRAY_LEN(file_attr_flags); i++)
 		if (file_attr_flags[i].flag & dentry->attributes)
 			printf("    FILE_ATTRIBUTE_%s is set\n",
 				file_attr_flags[i].name);
 	printf("Security ID       = %d\n", dentry->security_id);
 	printf("Subdir offset     = %"PRIu64"\n", dentry->subdir_offset);
-	/*printf("Unused1           = 0x%"PRIu64"\n", dentry->unused1);*/
-	/*printf("Unused2           = %"PRIu64"\n", dentry->unused2);*/
-	printf("Creation Time     = 0x%"PRIx64"\n", dentry->creation_time);
-	printf("Last Access Time  = 0x%"PRIx64"\n", dentry->last_access_time);
-	printf("Last Write Time   = 0x%"PRIx64"\n", dentry->last_write_time);
-	printf("Hash              = 0x"); 
-	print_hash(dentry->hash); 
-	putchar('\n');
+#if 0
+	printf("Unused1           = 0x%"PRIu64"\n", dentry->unused1);
+	printf("Unused2           = %"PRIu64"\n", dentry->unused2);
+#endif
+#if 0
+	printf("Creation Time     = 0x%"PRIx64"\n");
+	printf("Last Access Time  = 0x%"PRIx64"\n");
+	printf("Last Write Time   = 0x%"PRIx64"\n");
+#endif
+
+	time_t creat_time = wim_timestamp_to_unix(dentry->creation_time);
+	time_t access_time = wim_timestamp_to_unix(dentry->last_access_time);
+	time_t mod_time = wim_timestamp_to_unix(dentry->last_write_time);
+	printf("Creation Time     = %s", asctime(localtime(&creat_time)));
+	printf("Last Access Time  = %s", asctime(localtime(&access_time)));
+	printf("Last Write Time   = %s", asctime(localtime(&mod_time)));
+
 	printf("Reparse Tag       = 0x%"PRIx32"\n", dentry->reparse_tag);
 	printf("Hard Link Group   = 0x%"PRIx64"\n", dentry->hard_link);
 	printf("Number of Alternate Data Streams = %hu\n", dentry->num_ads);
@@ -458,25 +461,30 @@ int print_dentry(struct dentry *dentry, void *lookup_table)
 	puts("\"");
 	printf("Short Name Length = %hu\n", dentry->short_name_len);
 	printf("Full Path (UTF-8) = \"%s\"\n", dentry->full_path_utf8);
-	if (lookup_table && (lte = __lookup_resource(lookup_table, dentry->hash)))
-		print_lookup_table_entry(lte, NULL);
-	else
-		putchar('\n');
+	lte = dentry_stream_lte(dentry, 0, lookup_table);
+	if (lte) {
+		print_lookup_table_entry(lte);
+	} else {
+		hash = dentry_stream_hash(dentry, 0);
+		if (hash) {
+			printf("Hash              = 0x"); 
+			print_hash(hash);
+			putchar('\n');
+		}
+	}
 	for (u16 i = 0; i < dentry->num_ads; i++) {
 		printf("[Alternate Stream Entry %u]\n", i);
 		printf("Name = \"%s\"\n", dentry->ads_entries[i].stream_name_utf8);
 		printf("Name Length (UTF-16) = %u\n",
 				dentry->ads_entries[i].stream_name_len);
-		printf("Hash              = 0x"); 
-		print_hash(dentry->ads_entries[i].hash); 
-		if (lookup_table &&
-		     (lte = __lookup_resource(lookup_table,
-					      dentry->ads_entries[i].hash)))
-		{
-			print_lookup_table_entry(lte, NULL);
-		} else {
+		hash = dentry_stream_hash(dentry, i + 1);
+		if (hash) {
+			printf("Hash              = 0x"); 
+			print_hash(hash);
 			putchar('\n');
 		}
+		print_lookup_table_entry(dentry_stream_lte(dentry, i + 1,
+							   lookup_table));
 	}
 	return 0;
 }
@@ -486,6 +494,8 @@ static inline void dentry_common_init(struct dentry *dentry)
 	memset(dentry, 0, sizeof(struct dentry));
 	dentry->refcnt = 1;
 	dentry->security_id = -1;
+	dentry->ads_entries_status = ADS_ENTRIES_DEFAULT;
+	dentry->lte_group_list.type = STREAM_TYPE_NORMAL;
 }
 
 /* 
@@ -510,6 +520,7 @@ struct dentry *new_dentry(const char *name)
 	dentry->next   = dentry;
 	dentry->prev   = dentry;
 	dentry->parent = dentry;
+	INIT_LIST_HEAD(&dentry->link_group_list);
 	return dentry;
 err:
 	FREE(dentry);
@@ -517,7 +528,7 @@ err:
 	return NULL;
 }
 
-static void dentry_free_ads_entries(struct dentry *dentry)
+void dentry_free_ads_entries(struct dentry *dentry)
 {
 	for (u16 i = 0; i < dentry->num_ads; i++)
 		destroy_ads_entry(&dentry->ads_entries[i]);
@@ -526,37 +537,85 @@ static void dentry_free_ads_entries(struct dentry *dentry)
 	dentry->num_ads = 0;
 }
 
-
-void free_dentry(struct dentry *dentry)
+static void __destroy_dentry(struct dentry *dentry)
 {
 	FREE(dentry->file_name);
 	FREE(dentry->file_name_utf8);
 	FREE(dentry->short_name);
 	FREE(dentry->full_path_utf8);
-	dentry_free_ads_entries(dentry);
+	FREE(dentry->extracted_file);
+}
+
+void free_dentry(struct dentry *dentry)
+{
+	wimlib_assert(dentry);
+	__destroy_dentry(dentry);
+	if (dentry->ads_entries_status != ADS_ENTRIES_USER)
+		dentry_free_ads_entries(dentry);
 	FREE(dentry);
 }
 
-/* Arguments for do_free_dentry(). */
-struct free_dentry_args {
-	struct lookup_table *lookup_table;
-	bool lt_decrement_refcnt;
-};
+/* Like free_dentry(), but assigns a new ADS entries owner if this dentry was
+ * the previous owner, and also deletes the dentry from its link_group_list */
+void put_dentry(struct dentry *dentry)
+{
+	if (dentry->ads_entries_status == ADS_ENTRIES_OWNER) {
+		struct dentry *new_owner;
+		list_for_each_entry(new_owner, &dentry->link_group_list,
+				    link_group_list)
+		{
+			if (new_owner->ads_entries_status == ADS_ENTRIES_USER) {
+				new_owner->ads_entries_status = ADS_ENTRIES_OWNER;
+				break;
+			}
+		}
+		dentry->ads_entries_status = ADS_ENTRIES_USER;
+	}
+	struct list_head *next;
+	list_del(&dentry->link_group_list);
+	free_dentry(dentry);
+}
+
+
+/* clones a dentry.
+ *
+ * Beware:
+ * 	- memory for file names is not cloned
+ * 	- next, prev, and children pointers and not touched
+ * 	- stream entries are not cloned.
+ */
+struct dentry *clone_dentry(struct dentry *old)
+{
+	struct dentry *new = MALLOC(sizeof(struct dentry));
+	if (!new)
+		return NULL;
+	memcpy(new, old, sizeof(struct dentry));
+	new->file_name          = NULL;
+	new->file_name_len      = 0;
+	new->file_name_utf8     = NULL;
+	new->file_name_utf8_len = 0;
+	new->short_name         = NULL;
+	new->short_name_len     = 0;
+	return new;
+}
 
 /* 
  * This function is passed as an argument to for_dentry_in_tree_depth() in order
  * to free a directory tree.  __args is a pointer to a `struct free_dentry_args'.
  */
-static int do_free_dentry(struct dentry *dentry, void *__args)
+static int do_free_dentry(struct dentry *dentry, void *__lookup_table)
 {
-	struct free_dentry_args *args = (struct free_dentry_args*)__args;
-
-	if (args->lt_decrement_refcnt && !dentry_is_directory(dentry)) {
-		lookup_table_decrement_refcnt(args->lookup_table, 
-					      dentry->hash);
+	struct lookup_table *lookup_table = __lookup_table;
+	if (lookup_table) {
+		struct lookup_table_entry *lte;
+		if (dentry->resolved)
+			lte = dentry->lte;
+		else
+			lte = __lookup_resource(lookup_table, dentry->hash);
+		lte_decrement_refcnt(lte, lookup_table);
 	}
 
-	wimlib_assert(dentry->refcnt >= 1);
+	wimlib_assert(dentry->refcnt != 0);
 	if (--dentry->refcnt == 0)
 		free_dentry(dentry);
 	return 0;
@@ -566,20 +625,16 @@ static int do_free_dentry(struct dentry *dentry, void *__args)
  * Unlinks and frees a dentry tree.
  *
  * @root: 		The root of the tree.
- * @lookup_table:  	The lookup table for dentries.
- * @decrement_refcnt:  	True if the dentries in the tree are to have their 
- * 			reference counts in the lookup table decremented.
+ * @lookup_table:  	The lookup table for dentries.  If non-NULL, the
+ * 			reference counts in the lookup table for the lookup
+ * 			table entries corresponding to the dentries will be
+ * 			decremented.
  */
-void free_dentry_tree(struct dentry *root, struct lookup_table *lookup_table, 
-		      bool lt_decrement_refcnt)
+void free_dentry_tree(struct dentry *root, struct lookup_table *lookup_table)
 {
 	if (!root || !root->parent)
 		return;
-
-	struct free_dentry_args args;
-	args.lookup_table        = lookup_table;
-	args.lt_decrement_refcnt = lt_decrement_refcnt;
-	for_dentry_in_tree_depth(root, do_free_dentry, &args);
+	for_dentry_in_tree_depth(root, do_free_dentry, lookup_table);
 }
 
 int increment_dentry_refcnt(struct dentry *dentry, void *ignore)
@@ -596,6 +651,7 @@ int increment_dentry_refcnt(struct dentry *dentry, void *ignore)
  */
 void link_dentry(struct dentry *dentry, struct dentry *parent)
 {
+	wimlib_assert(dentry_is_directory(parent));
 	dentry->parent = parent;
 	if (parent->children) {
 		/* Not an only child; link to siblings. */
@@ -611,7 +667,13 @@ void link_dentry(struct dentry *dentry, struct dentry *parent)
 	}
 }
 
-/* Unlink a dentry from the directory tree. */
+
+/* Unlink a dentry from the directory tree. 
+ *
+ * Note: This merely removes it from the in-memory tree structure.  See
+ * remove_dentry() in mount.c for a function implemented on top of this one that
+ * frees the dentry and implements reference counting for the lookup table
+ * entries. */
 void unlink_dentry(struct dentry *dentry)
 {
 	if (dentry_is_root(dentry))
@@ -637,36 +699,35 @@ static inline void recalculate_dentry_size(struct dentry *dentry)
 	dentry->length = (dentry->length + 7) & ~7;
 }
 
-static int do_name_change(char **file_name_ret,
-			  char **file_name_utf8_ret,
-			  u16 *file_name_len_ret,
-			  u16 *file_name_utf8_len_ret,
-			  const char *new_name)
+/* Duplicates a UTF-8 name into UTF-8 and UTF-16 strings and returns the strings
+ * and their lengths in the pointer arguments */
+int get_names(char **name_utf16_ret, char **name_utf8_ret,
+	      u16 *name_utf16_len_ret, u16 *name_utf8_len_ret,
+	      const char *name)
 {
 	size_t utf8_len;
 	size_t utf16_len;
-	char *file_name, *file_name_utf8;
+	char *name_utf16, *name_utf8;
 
-	utf8_len = strlen(new_name);
+	utf8_len = strlen(name);
 
-	file_name = utf8_to_utf16(new_name, utf8_len, &utf16_len);
+	name_utf16 = utf8_to_utf16(name, utf8_len, &utf16_len);
 
-	if (!file_name)
+	if (!name_utf16)
 		return WIMLIB_ERR_NOMEM;
 
-	file_name_utf8 = MALLOC(utf8_len + 1);
-	if (!file_name_utf8) {
-		FREE(file_name);
+	name_utf8 = MALLOC(utf8_len + 1);
+	if (!name_utf8) {
+		FREE(name_utf8);
 		return WIMLIB_ERR_NOMEM;
 	}
-	memcpy(file_name_utf8, new_name, utf8_len + 1);
-
-	FREE(*file_name_ret);
-	FREE(*file_name_utf8_ret);
-	*file_name_ret          = file_name;
-	*file_name_utf8_ret     = file_name_utf8;
-	*file_name_len_ret      = utf16_len;
-	*file_name_utf8_len_ret = utf8_len;
+	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;
 }
 
@@ -677,9 +738,9 @@ int change_dentry_name(struct dentry *dentry, const char *new_name)
 {
 	int ret;
 
-	ret = do_name_change(&dentry->file_name, &dentry->file_name_utf8,
-			     &dentry->file_name_len, &dentry->file_name_utf8_len,
-			     new_name);
+	ret = get_names(&dentry->file_name, &dentry->file_name_utf8,
+			&dentry->file_name_len, &dentry->file_name_utf8_len,
+			 new_name);
 	if (ret == 0)
 		recalculate_dentry_size(dentry);
 	return ret;
@@ -687,10 +748,10 @@ int change_dentry_name(struct dentry *dentry, const char *new_name)
 
 int change_ads_name(struct ads_entry *entry, const char *new_name)
 {
-	return do_name_change(&entry->stream_name, &entry->stream_name_utf8,
-			      &entry->stream_name_len,
-			      &entry->stream_name_utf8_len,
-			      new_name);
+	return get_names(&entry->stream_name, &entry->stream_name_utf8,
+			 &entry->stream_name_len,
+			 &entry->stream_name_utf8_len,
+			  new_name);
 }
 
 /* Parameters for calculate_dentry_statistics(). */
@@ -715,7 +776,10 @@ static int calculate_dentry_statistics(struct dentry *dentry, void *arg)
 	else
 		++*stats->file_count;
 
-	lte = __lookup_resource(stats->lookup_table, dentry->hash);
+	if (dentry->resolved)
+		lte = dentry->lte;
+	else
+		lte = __lookup_resource(stats->lookup_table, dentry->hash);
 	i = 0;
 	while (1) {
 		if (lte) {
@@ -786,7 +850,7 @@ static int read_ads_entries(const u8 *p, struct dentry *dentry,
 		DEBUG2("ADS length = %"PRIu64, length);
 
 		p += 8; /* Unused */
-		p = get_bytes(p, WIM_HASH_SIZE, (u8*)cur_entry->hash);
+		p = get_bytes(p, SHA1_HASH_SIZE, (u8*)cur_entry->hash);
 		p = get_u16(p, &cur_entry->stream_name_len);
 
 		DEBUG2("Stream name length = %u", cur_entry->stream_name_len);
@@ -902,7 +966,7 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 	p = get_u64(p, &dentry->last_access_time);
 	p = get_u64(p, &dentry->last_write_time);
 
-	p = get_bytes(p, WIM_HASH_SIZE, dentry->hash);
+	p = get_bytes(p, SHA1_HASH_SIZE, dentry->hash);
 	
 	/*
 	 * I don't know what's going on here.  It seems like M$ screwed up the
@@ -912,13 +976,9 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 	 */
 	if (dentry->attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
 		/* ??? */
-		u32 u1, u2;
-		p = get_u32(p, &u1);
-		/*p += 4;*/
+		p += 4;
 		p = get_u32(p, &dentry->reparse_tag);
-		p = get_u32(p, &u2);
-		/*p += 4;*/
-		dentry->hard_link = (u64)(u1) | ((u64)(u2) << 32);
+		p += 4;
 	} else {
 		p = get_u32(p, &dentry->reparse_tag);
 		p = get_u64(p, &dentry->hard_link);
@@ -985,19 +1045,15 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
 	 * aligned on the next 8-byte boundary.  Here's an example of the
 	 * aligned data:
 	 *
-	 * 01000000400000006c786bbac58ede11b0bb00261870892ab6adb76fe63a3
-	 * e468fca86530d2effa16c786bbac58ede11b0bb00261870892a0000000000
-	 * 0000000000000000000000
+	 * 01000000 40000000 6c786bba c58ede11 b0bb0026 1870892a b6adb76f
+	 * e63a3e46 8fca8653 0d2effa1 6c786bba c58ede11 b0bb0026 1870892a
+	 * 00000000 00000000 00000000 00000000
 	 *
 	 * Here's one interpretation of how the data is laid out.
 	 *
 	 * struct unknown {
 	 * 	u32 field1; (always 0x00000001)
 	 * 	u32 field2; (always 0x40000000)
-	 * 	u16 field3;
-	 * 	u32 field4;
-	 * 	u32 field5;
-	 * 	u32 field6;
 	 * 	u8  data[48]; (???)
 	 * 	u64 reserved1; (always 0)
 	 * 	u64 reserved2; (always 0)
@@ -1056,7 +1112,8 @@ static u8 *write_dentry(const struct dentry *dentry, u8 *p)
 {
 	u8 *orig_p = p;
 	unsigned padding;
-	memset(p, 0, dentry->length);
+	const u8 *hash;
+
 	p = put_u64(p, dentry->length);
 	p = put_u32(p, dentry->attributes);
 	p = put_u32(p, dentry->security_id);
@@ -1066,11 +1123,25 @@ static u8 *write_dentry(const struct dentry *dentry, u8 *p)
 	p = put_u64(p, dentry->creation_time);
 	p = put_u64(p, dentry->last_access_time);
 	p = put_u64(p, dentry->last_write_time);
-	memcpy(p, dentry->hash, WIM_HASH_SIZE);
-	p += WIM_HASH_SIZE;
-	p = put_u32(p, dentry->reparse_tag);
-	p = put_u64(p, dentry->hard_link);
-	p = put_u16(p, dentry->num_ads); /*streams */
+	if (dentry->resolved && dentry->lte)
+		hash = dentry->lte->hash;
+	else
+		hash = dentry->hash;
+	p = put_bytes(p, SHA1_HASH_SIZE, hash);
+	if (dentry->attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+		p = put_zeroes(p, 4);
+		p = put_u32(p, dentry->reparse_tag);
+		p = put_zeroes(p, 4);
+	} else {
+		u64 hard_link;
+		p = put_u32(p, dentry->reparse_tag);
+		if (dentry->link_group_list.next == &dentry->link_group_list)
+			hard_link = 0;
+		else
+			hard_link = dentry->hard_link;
+		p = put_u64(p, hard_link);
+	}
+	p = put_u16(p, dentry->num_ads);
 	p = put_u16(p, dentry->short_name_len);
 	p = put_u16(p, dentry->file_name_len);
 	p = put_bytes(p, dentry->file_name_len, (u8*)dentry->file_name);
@@ -1086,7 +1157,11 @@ static u8 *write_dentry(const struct dentry *dentry, u8 *p)
 	for (u16 i = 0; i < dentry->num_ads; i++) {
 		p = put_u64(p, ads_entry_length(&dentry->ads_entries[i]));
 		p = put_u64(p, 0); /* Unused */
-		p = put_bytes(p, WIM_HASH_SIZE, dentry->ads_entries[i].hash);
+		if (dentry->resolved && dentry->ads_entries[i].lte)
+			hash = dentry->ads_entries[i].lte->hash;
+		else
+			hash = dentry->ads_entries[i].hash;
+		p = put_bytes(p, SHA1_HASH_SIZE, hash);
 		p = put_u16(p, dentry->ads_entries[i].stream_name_len);
 		p = put_bytes(p, dentry->ads_entries[i].stream_name_len,
 				 (u8*)dentry->ads_entries[i].stream_name);
@@ -1108,8 +1183,8 @@ u8 *write_dentry_tree(const struct dentry *tree, u8 *p)
 		/* write end of directory entry */
 		p = put_u64(p, 0);
 	} else {
-		/* Nothing to do for a regular file. */
-		if (dentry_is_regular_file(tree))
+		/* Nothing to do for non-directories */
+		if (!dentry_is_directory(tree))
 			return p;
 	}
 
@@ -1221,17 +1296,3 @@ int read_dentry_tree(const u8 metadata_resource[], u64 metadata_resource_len,
 	dentry->children = first_child;
 	return ret;
 }
-
-int dentry_set_symlink_buf(struct dentry *dentry, const u8 symlink_buf_hash[])
-{
-	struct ads_entry *ads_entries;
-
-	ads_entries = CALLOC(2, sizeof(struct ads_entry));
-	if (!ads_entries)
-		return WIMLIB_ERR_NOMEM;
-	memcpy(ads_entries[1].hash, symlink_buf_hash, WIM_HASH_SIZE);
-	dentry_free_ads_entries(dentry);
-	dentry->num_ads = 2;
-	dentry->ads_entries = ads_entries;
-	return 0;
-}