X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fdentry.c;h=68a5d925627a5ae925c2d0db40898657b4fdd80c;hb=f3581db5c61c2cb180f77784feaa2e247956dd81;hp=763198d13844131da118f343178d1b68670cb1b9;hpb=d444f2e5ddee51e7d9d0401cffcf88477c180422;p=wimlib

diff --git a/src/dentry.c b/src/dentry.c
index 763198d1..68a5d925 100644
--- a/src/dentry.c
+++ b/src/dentry.c
@@ -190,38 +190,19 @@ struct wim_dentry_on_disk {
 
 /* 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. */
+ * excludes tagged items as well as any alternate data stream entries that may
+ * follow the dentry.  */
 static u64
-dentry_correct_length_unaligned(u16 file_name_nbytes, u16 short_name_nbytes)
+dentry_min_len_with_names(u16 file_name_nbytes, u16 short_name_nbytes)
 {
 	u64 length = sizeof(struct wim_dentry_on_disk);
 	if (file_name_nbytes)
-		length += file_name_nbytes + 2;
+		length += (u32)file_name_nbytes + 2;
 	if (short_name_nbytes)
-		length += short_name_nbytes + 2;
+		length += (u32)short_name_nbytes + 2;
 	return length;
 }
 
-/* Calculates the unaligned length, in bytes, of an on-disk WIM dentry, based on
- * the file name length, short name length, and optional tagged items.  Note
- * that dentry->length is ignored; also, this excludes any alternate data stream
- * entries that may follow the dentry.  */
-static u64
-dentry_correct_length_aligned(const struct wim_dentry *dentry)
-{
-	u64 len;
-
-	len = dentry_correct_length_unaligned(dentry->file_name_nbytes,
-					      dentry->short_name_nbytes);
-
-	if (dentry->d_inode->i_extra_size) {
-		len = (len + 7) & ~7;
-		len += dentry->d_inode->i_extra_size;
-	}
-
-	return (len + 7) & ~7;
-}
-
 static void
 do_dentry_set_name(struct wim_dentry *dentry, utf16lechar *file_name,
 		   size_t file_name_nbytes)
@@ -285,7 +266,7 @@ ads_entry_total_length(const struct wim_ads_entry *entry)
 {
 	u64 len = sizeof(struct wim_ads_entry_on_disk);
 	if (entry->stream_name_nbytes)
-		len += entry->stream_name_nbytes + 2;
+		len += (u32)entry->stream_name_nbytes + 2;
 	return (len + 7) & ~7;
 }
 
@@ -315,33 +296,33 @@ inode_needs_dummy_stream(const struct wim_inode *inode)
 }
 
 /* Calculate the total number of bytes that will be consumed when a WIM dentry
- * is written.  This includes base dentry and name fields as well as all
- * alternate data stream entries and alignment bytes.  */
+ * is written.  This includes the base dentry, the name fields, any tagged items,
+ * and any alternate data stream entries.  Also includes all alignment bytes
+ * between these parts.  */
 u64
 dentry_out_total_length(const struct wim_dentry *dentry)
 {
-	u64 length = dentry_correct_length_aligned(dentry);
 	const struct wim_inode *inode = dentry->d_inode;
+	u64 len;
 
-	if (inode_needs_dummy_stream(inode))
-		length += ads_entry_total_length(&(struct wim_ads_entry){});
+	len = dentry_min_len_with_names(dentry->file_name_nbytes,
+					dentry->short_name_nbytes);
+	len = (len + 7) & ~7;
 
-	for (u16 i = 0; i < inode->i_num_ads; i++)
-		length += ads_entry_total_length(&inode->i_ads_entries[i]);
+	if (inode->i_extra_size) {
+		len += inode->i_extra_size;
+		len = (len + 7) & ~7;
+	}
 
-	return length;
-}
+	if (unlikely(inode->i_num_ads)) {
+		if (inode_needs_dummy_stream(inode))
+			len += ads_entry_total_length(&(struct wim_ads_entry){});
 
-/* Calculate the aligned, total length of a dentry, including all alternate data
- * stream entries.  Uses dentry->length.  */
-static u64
-dentry_in_total_length(const struct wim_dentry *dentry)
-{
-	u64 length = dentry->length;
-	const struct wim_inode *inode = dentry->d_inode;
-	for (u16 i = 0; i < inode->i_num_ads; i++)
-		length += ads_entry_total_length(&inode->i_ads_entries[i]);
-	return (length + 7) & ~7;
+		for (u16 i = 0; i < inode->i_num_ads; i++)
+			len += ads_entry_total_length(&inode->i_ads_entries[i]);
+	}
+
+	return len;
 }
 
 static int
@@ -419,7 +400,7 @@ calculate_dentry_full_path(struct wim_dentry *dentry)
 	do {
 		ulen += d->file_name_nbytes / sizeof(utf16lechar);
 		ulen++;
-		d = d->parent;  /* assumes d == d->parent for root  */
+		d = d->d_parent;  /* assumes d == d->d_parent for root  */
 	} while (!dentry_is_root(d));
 
 	utf16lechar ubuf[ulen];
@@ -430,7 +411,7 @@ calculate_dentry_full_path(struct wim_dentry *dentry)
 		p -= d->file_name_nbytes / sizeof(utf16lechar);
 		memcpy(p, d->file_name, d->file_name_nbytes);
 		*--p = cpu_to_le16(WIM_PATH_SEPARATOR);
-		d = d->parent;  /* assumes d == d->parent for root  */
+		d = d->d_parent;  /* assumes d == d->d_parent for root  */
 	} while (!dentry_is_root(d));
 
 	wimlib_assert(p == ubuf);
@@ -449,7 +430,6 @@ dentry_full_path(struct wim_dentry *dentry)
 static int
 dentry_calculate_subdir_offset(struct wim_dentry *dentry, void *_subdir_offset_p)
 {
-
 	if (dentry_is_directory(dentry)) {
 		u64 *subdir_offset_p = _subdir_offset_p;
 		struct wim_dentry *child;
@@ -794,72 +774,6 @@ get_parent_dentry(WIMStruct *wim, const tchar *path,
 	return get_dentry(wim, buf, case_type);
 }
 
-#ifdef WITH_FUSE
-/* Finds the dentry, lookup table entry, and stream index for a WIM file stream,
- * given a path name.
- *
- * Currently, lookups of this type are only needed if FUSE is enabled.  */
-int
-wim_pathname_to_stream(WIMStruct *wim,
-		       const tchar *path,
-		       int lookup_flags,
-		       struct wim_dentry **dentry_ret,
-		       struct wim_lookup_table_entry **lte_ret,
-		       u16 *stream_idx_ret)
-{
-	struct wim_dentry *dentry;
-	struct wim_lookup_table_entry *lte;
-	u16 stream_idx;
-	const tchar *stream_name = NULL;
-	struct wim_inode *inode;
-	tchar *p = NULL;
-
-	if (lookup_flags & LOOKUP_FLAG_ADS_OK) {
-		stream_name = path_stream_name(path);
-		if (stream_name) {
-			p = (tchar*)stream_name - 1;
-			*p = T('\0');
-		}
-	}
-
-	dentry = get_dentry(wim, path, WIMLIB_CASE_SENSITIVE);
-	if (p)
-		*p = T(':');
-	if (!dentry)
-		return -errno;
-
-	inode = dentry->d_inode;
-
-	if (!inode->i_resolved)
-		if (inode_resolve_streams(inode, wim->lookup_table, false))
-			return -EIO;
-
-	if (!(lookup_flags & LOOKUP_FLAG_DIRECTORY_OK)
-	      && inode_is_directory(inode))
-		return -EISDIR;
-
-	if (stream_name) {
-		struct wim_ads_entry *ads_entry;
-
-		ads_entry = inode_get_ads_entry(inode, stream_name);
-		if (!ads_entry)
-			return -errno;
-
-		stream_idx = ads_entry - inode->i_ads_entries + 1;
-		lte = ads_entry->lte;
-	} else {
-		lte = inode_unnamed_stream_resolved(inode, &stream_idx);
-	}
-	if (dentry_ret)
-		*dentry_ret = dentry;
-	if (lte_ret)
-		*lte_ret = lte;
-	if (stream_idx_ret)
-		*stream_idx_ret = stream_idx;
-	return 0;
-}
-#endif /* WITH_FUSE  */
-
 /* Creates an unlinked directory entry. */
 int
 new_dentry(const tchar *name, struct wim_dentry **dentry_ret)
@@ -880,7 +794,7 @@ new_dentry(const tchar *name, struct wim_dentry **dentry_ret)
 			return ret;
 		}
 	}
-	dentry->parent = dentry;
+	dentry->d_parent = dentry;
 	*dentry_ret = dentry;
 	return 0;
 }
@@ -1102,7 +1016,7 @@ dentry_add_child(struct wim_dentry *parent, struct wim_dentry *child)
 	} else {
 		INIT_LIST_HEAD(&child->d_ci_conflict_list);
 	}
-	child->parent = parent;
+	child->d_parent = parent;
 	return NULL;
 }
 
@@ -1115,7 +1029,7 @@ unlink_dentry(struct wim_dentry *dentry)
 	if (dentry_is_root(dentry))
 		return;
 
-	dir = dentry->parent->d_inode;
+	dir = dentry->d_parent->d_inode;
 
 	dir_unindex_child(dir, dentry);
 
@@ -1158,8 +1072,9 @@ read_extra_data(const u8 *p, const u8 *end, struct wim_inode *inode)
  * follow it, from the WIM image's metadata resource.  */
 static int
 read_dentry(const u8 * restrict buf, size_t buf_len,
-	    u64 offset, struct wim_dentry **dentry_ret)
+	    u64 *offset_p, struct wim_dentry **dentry_ret)
 {
+	u64 offset = *offset_p;
 	u64 length;
 	const u8 *p;
 	const struct wim_dentry_on_disk *disk_dentry;
@@ -1221,7 +1136,6 @@ read_dentry(const u8 * restrict buf, size_t buf_len,
 	if (ret)
 		return ret;
 
-	dentry->length = length;
 	inode = dentry->d_inode;
 
 	/* Read more fields: some into the dentry, and some into the inode.  */
@@ -1268,15 +1182,15 @@ read_dentry(const u8 * restrict buf, size_t buf_len,
 	 * the length of the dentry is large enough to actually hold them.
 	 *
 	 * 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_nbytes,
-							  short_name_nbytes);
+	 * that the dentry's length is unaligned, although this would be
+	 * unexpected.  */
+	calculated_size = dentry_min_len_with_names(file_name_nbytes,
+						    short_name_nbytes);
 
-	if (unlikely(dentry->length < calculated_size)) {
+	if (unlikely(length < calculated_size)) {
 		ERROR("Unexpected end of directory entry! (Expected "
 		      "at least %"PRIu64" bytes, got %"PRIu64" bytes.)",
-		      calculated_size, dentry->length);
+		      calculated_size, length);
 		ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE;
 		goto err_free_dentry;
 	}
@@ -1294,7 +1208,7 @@ read_dentry(const u8 * restrict buf, size_t buf_len,
 			goto err_free_dentry;
 		}
 		dentry->file_name_nbytes = file_name_nbytes;
-		p += file_name_nbytes + 2;
+		p += (u32)file_name_nbytes + 2;
 	}
 
 	/* Read the short filename if present.  Note: if there is no short
@@ -1307,17 +1221,19 @@ read_dentry(const u8 * restrict buf, size_t buf_len,
 			goto err_free_dentry;
 		}
 		dentry->short_name_nbytes = short_name_nbytes;
-		p += short_name_nbytes + 2;
+		p += (u32)short_name_nbytes + 2;
 	}
 
 	/* Read extra data at end of dentry (but before alternate data stream
 	 * entries).  This may contain tagged items.  */
-	ret = read_extra_data(p, &buf[offset + dentry->length], inode);
+	ret = read_extra_data(p, &buf[offset + length], inode);
 	if (ret)
 		goto err_free_dentry;
 
 	/* Align the dentry length.  */
-	dentry->length = (dentry->length + 7) & ~7;
+	length = (length + 7) & ~7;
+
+	offset += length;
 
 	/* Read the alternate data streams, if present.  inode->i_num_ads tells
 	 * us how many they are, and they will directly follow the dentry in the
@@ -1327,16 +1243,22 @@ read_dentry(const u8 * restrict buf, size_t buf_len,
 	 * aligned boundary, and the alternate data stream entries seem to NOT
 	 * be included in the dentry->length field for some reason.  */
 	if (unlikely(inode->i_num_ads != 0)) {
-		ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE;
-		if (offset + dentry->length > buf_len ||
-		    (ret = read_ads_entries(&buf[offset + dentry->length],
-					    inode,
-					    buf_len - offset - dentry->length)))
-		{
+		size_t orig_bytes_remaining;
+		size_t bytes_remaining;
+
+		if (offset > buf_len) {
+			ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE;
 			goto err_free_dentry;
 		}
+		bytes_remaining = buf_len - offset;
+		orig_bytes_remaining = bytes_remaining;
+		ret = read_ads_entries(&buf[offset], inode, &bytes_remaining);
+		if (ret)
+			goto err_free_dentry;
+		offset += (orig_bytes_remaining - bytes_remaining);
 	}
 
+	*offset_p = offset;  /* Sets offset of next dentry in directory  */
 	*dentry_ret = dentry;
 	return 0;
 
@@ -1369,8 +1291,8 @@ read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len,
 
 	/* Check for cyclic directory structure, which would cause infinite
 	 * recursion if not handled.  */
-	for (struct wim_dentry *d = dir->parent;
-	     !dentry_is_root(d); d = d->parent)
+	for (struct wim_dentry *d = dir->d_parent;
+	     !dentry_is_root(d); d = d->d_parent)
 	{
 		if (unlikely(d->subdir_offset == cur_offset)) {
 			ERROR("Cyclic directory structure detected: children "
@@ -1386,7 +1308,7 @@ read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len,
 		int ret;
 
 		/* Read next child of @dir.  */
-		ret = read_dentry(buf, buf_len, cur_offset, &child);
+		ret = read_dentry(buf, buf_len, &cur_offset, &child);
 		if (ret)
 			return ret;
 
@@ -1394,13 +1316,6 @@ read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len,
 		if (child == NULL)
 			return 0;
 
-		/* Advance to the offset of the next child.  Note: We need to
-		 * advance by the TOTAL length of the dentry, not by the length
-		 * child->length, which although it does take into account the
-		 * padding, it DOES NOT take into account alternate stream
-		 * entries.  */
-		cur_offset += dentry_in_total_length(child);
-
 		/* All dentries except the root should be named.  */
 		if (unlikely(!dentry_has_long_name(child))) {
 			WARNING("Ignoring unnamed dentry in "
@@ -1480,7 +1395,7 @@ read_dentry_tree(const u8 *buf, size_t buf_len,
 
 	DEBUG("Reading dentry tree (root_offset=%"PRIu64")", root_offset);
 
-	ret = read_dentry(buf, buf_len, root_offset, &root);
+	ret = read_dentry(buf, buf_len, &root_offset, &root);
 	if (ret)
 		return ret;
 
@@ -1490,12 +1405,7 @@ read_dentry_tree(const u8 *buf, size_t buf_len,
 		{
 			WARNING("The root directory has a nonempty name; "
 				"removing it.");
-			FREE(root->file_name);
-			FREE(root->short_name);
-			root->file_name = NULL;
-			root->short_name = NULL;
-			root->file_name_nbytes = 0;
-			root->short_name_nbytes = 0;
+			dentry_set_name(root, NULL);
 		}
 
 		if (unlikely(!dentry_is_directory(root))) {
@@ -1544,7 +1454,7 @@ write_ads_entry(const struct wim_ads_entry *ads_entry,
 	p += sizeof(struct wim_ads_entry_on_disk);
 	if (ads_entry->stream_name_nbytes) {
 		p = mempcpy(p, ads_entry->stream_name,
-			    ads_entry->stream_name_nbytes + 2);
+			    (u32)ads_entry->stream_name_nbytes + 2);
 	}
 	/* Align to 8-byte boundary */
 	while ((uintptr_t)p & 7)
@@ -1617,10 +1527,10 @@ write_dentry(const struct wim_dentry * restrict dentry, u8 * restrict p)
 	wimlib_assert(dentry_is_root(dentry) != dentry_has_long_name(dentry));
 
 	if (dentry_has_long_name(dentry))
-		p = mempcpy(p, dentry->file_name, dentry->file_name_nbytes + 2);
+		p = mempcpy(p, dentry->file_name, (u32)dentry->file_name_nbytes + 2);
 
 	if (dentry_has_short_name(dentry))
-		p = mempcpy(p, dentry->short_name, dentry->short_name_nbytes + 2);
+		p = mempcpy(p, dentry->short_name, (u32)dentry->short_name_nbytes + 2);
 
 	/* Align to 8-byte boundary */
 	while ((uintptr_t)p & 7)