struct wim_dentry: Remove 'length' field
authorEric Biggers <ebiggers3@gmail.com>
Mon, 26 May 2014 03:40:49 +0000 (22:40 -0500)
committerEric Biggers <ebiggers3@gmail.com>
Mon, 26 May 2014 03:50:00 +0000 (22:50 -0500)
include/wimlib/dentry.h
include/wimlib/inode.h
src/dentry.c
src/inode.c

index 2dd98fb..99b42c0 100644 (file)
@@ -102,10 +102,9 @@ struct wim_dentry {
        /* Temporary list field  */
        struct list_head tmp_list;
 
-       /* 'length' and 'subdir_offset' are only used while reading and writing
-        * this dentry; see the corresponding field in
-        * `struct wim_dentry_on_disk' for explanation.  */
-       u64 length;
+       /* 'subdir_offset' is only used while reading and writing this dentry.
+        * See the corresponding field in `struct wim_dentry_on_disk' for
+        * explanation.  */
        u64 subdir_offset;
 
        /* Full path to this dentry in the WIM, in platform-dependent tchars
index 84b4959..6f310fd 100644 (file)
@@ -514,7 +514,7 @@ inode_unnamed_stream_hash(const struct wim_inode *inode);
 
 extern int
 read_ads_entries(const u8 * restrict p, struct wim_inode * restrict inode,
-                size_t nbytes_remaining);
+                size_t *nbytes_remaining_p);
 
 extern int
 verify_inode(struct wim_inode *inode, const struct wim_security_data *sd);
index 71d70bb..9c32bcb 100644 (file)
@@ -190,9 +190,10 @@ 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)
@@ -202,26 +203,6 @@ dentry_correct_length_unaligned(u16 file_name_nbytes, u16 short_name_nbytes)
        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)
@@ -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,
+ * 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;
+
+       if (inode->i_extra_size) {
+               len += inode->i_extra_size;
+               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 (unlikely(inode->i_num_ads)) {
+               if (inode_needs_dummy_stream(inode))
+                       len += ads_entry_total_length(&(struct wim_ads_entry){});
 
-       return length;
-}
+               for (u16 i = 0; i < inode->i_num_ads; i++)
+                       len += ads_entry_total_length(&inode->i_ads_entries[i]);
+       }
 
-/* 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;
+       return len;
 }
 
 static int
@@ -1158,8 +1139,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 +1203,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 +1249,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;
        }
@@ -1312,12 +1293,14 @@ read_dentry(const u8 * restrict buf, size_t buf_len,
 
        /* 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 +1310,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;
 
@@ -1386,7 +1375,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 +1383,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 +1462,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;
 
index ae971d8..42faa19 100644 (file)
@@ -564,8 +564,9 @@ stream_not_found_error(const struct wim_inode *inode, const u8 *hash)
  *     Inode to load the alternate data streams into.  @inode->i_num_ads must
  *     have been set to the number of alternate data streams that are expected.
  *
- * @remaining_size:
+ * @nbytes_remaining_p:
  *     Number of bytes of data remaining in the buffer pointed to by @p.
+ *     On success this will be updated to point just past the ADS entries.
  *
  * On success, inode->i_ads_entries is set to an array of `struct
  * wim_ads_entry's of length inode->i_num_ads.  On failure, @inode is not
@@ -578,8 +579,9 @@ stream_not_found_error(const struct wim_inode *inode, const u8 *hash)
  */
 int
 read_ads_entries(const u8 * restrict p, struct wim_inode * restrict inode,
-                size_t nbytes_remaining)
+                size_t *nbytes_remaining_p)
 {
+       size_t nbytes_remaining = *nbytes_remaining_p;
        u16 num_ads;
        struct wim_ads_entry *ads_entries;
        int ret;
@@ -661,7 +663,7 @@ read_ads_entries(const u8 * restrict p, struct wim_inode * restrict inode,
                 * that less than @length is actually remaining in the metadata
                 * resource. We should set the remaining bytes to 0 if this
                 * happens. */
-               length = (length + 7) & ~(u64)7;
+               length = (length + 7) & ~7;
                p += length;
                if (nbytes_remaining < length)
                        nbytes_remaining = 0;
@@ -670,6 +672,7 @@ read_ads_entries(const u8 * restrict p, struct wim_inode * restrict inode,
        }
        inode->i_ads_entries = ads_entries;
        inode->i_next_stream_id = inode->i_num_ads + 1;
+       *nbytes_remaining_p = nbytes_remaining;
        ret = 0;
        goto out;
 out_of_memory: