Rename _full_path => d_full_path
[wimlib] / src / dentry.c
index 402c780..49c0cdf 100644 (file)
@@ -1,70 +1,93 @@
 /*
- * dentry.c
+ * dentry.c - see description below
+ */
+
+/*
+ * Copyright (C) 2012, 2013, 2014, 2015 Eric Biggers
+ *
+ * This file is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * This file is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
  *
- * In the WIM file format, the dentries are stored in the "metadata resource"
- * section right after the security data.  Each image in the WIM file has its
- * own metadata resource with its own security data and dentry tree.  Dentries
- * in different images may share file resources by referring to the same lookup
- * table entries.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this file; if not, see http://www.gnu.org/licenses/.
  */
 
 /*
- * Copyright (C) 2012, 2013, 2014 Eric Biggers
+ * This file contains logic to deal with WIM directory entries, or "dentries":
  *
- * This file is part of wimlib, a library for working with WIM files.
+ *  - Reading a dentry tree from a metadata resource in a WIM file
+ *  - Writing a dentry tree to a metadata resource in a WIM file
+ *  - Iterating through a tree of WIM dentries
+ *  - Path lookup: translating a path into a WIM dentry or inode
+ *  - Creating, modifying, and deleting WIM dentries
  *
- * wimlib is free software; you can redistribute it and/or modify it under the
- * terms of the GNU General Public License as published by the Free Software
- * Foundation; either version 3 of the License, or (at your option) any later
- * version.
+ * Notes:
  *
- * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *  - A WIM file can contain multiple images, each of which has an independent
+ *    tree of dentries.  "On disk", the dentry tree for an image is stored in
+ *    the "metadata resource" for that image.
  *
- * You should have received a copy of the GNU General Public License along with
- * wimlib; if not, see http://www.gnu.org/licenses/.
+ *  - Multiple dentries in an image may correspond to the same inode, or "file".
+ *    When this occurs, it means that the file has multiple names, or "hard
+ *    links".  A dentry is not a file, but rather the name of a file!
+ *
+ *  - Inodes are not represented explicitly in the WIM file format.  Instead,
+ *    the metadata resource provides a "hard link group ID" for each dentry.
+ *    wimlib handles pulling out actual inodes from this information, but this
+ *    occurs in inode_fixup.c and not in this file.
+ *
+ *  - wimlib does not allow *directory* hard links, so a WIM image really does
+ *    have a *tree* of dentries (and not an arbitrary graph of dentries).
+ *
+ *  - wimlib indexes dentries both case-insensitively and case-sensitively,
+ *    allowing either behavior to be used for path lookup.
+ *
+ *  - Multiple dentries in a directory might have the same case-insensitive
+ *    name.  But wimlib enforces that at most one dentry in a directory can have
+ *    a given case-sensitive name.
  */
 
 #ifdef HAVE_CONFIG_H
 #  include "config.h"
 #endif
 
-#include "wimlib.h"
-#include "wimlib/case.h"
+#include <errno.h>
+
+#include "wimlib/assert.h"
 #include "wimlib/dentry.h"
+#include "wimlib/inode.h"
 #include "wimlib/encoding.h"
 #include "wimlib/endianness.h"
-#include "wimlib/error.h"
-#include "wimlib/lookup_table.h"
 #include "wimlib/metadata.h"
 #include "wimlib/paths.h"
-#include "wimlib/resource.h"
-#include "wimlib/security.h"
-#include "wimlib/sha1.h"
-#include "wimlib/timestamp.h"
-
-#include <errno.h>
 
 /* On-disk format of a WIM dentry (directory entry), located in the metadata
  * resource for a WIM image.  */
 struct wim_dentry_on_disk {
 
-       /* Length of this directory entry in bytes, not including any alternate
-        * data stream entries.  Should be a multiple of 8 so that the following
-        * dentry or alternate data stream entry is aligned on an 8-byte
-        * boundary.  (If not, wimlib will round it up.)  It must be at least as
-        * long as the fixed-length fields of the dentry (WIM_DENTRY_DISK_SIZE),
-        * plus the lengths of the file name and/or short name if present.
+       /* Length of this directory entry in bytes, not including any extra
+        * stream entries.  Should be a multiple of 8 so that the following
+        * dentry or extra stream entry is aligned on an 8-byte boundary.  (If
+        * not, wimlib will round it up.)  It must be at least as long as the
+        * fixed-length fields of the dentry (WIM_DENTRY_DISK_SIZE), plus the
+        * lengths of the file name and/or short name if present, plus the size
+        * of any "extra" data.
         *
-        * It is also possible for this field to be 0.  This situation, which is
-        * undocumented, indicates the end of a list of sibling nodes in a
-        * directory.  It also means the real length is 8, because the dentry
-        * included only the length field, but that takes up 8 bytes.  */
+        * It is also possible for this field to be 0.  This case indicates the
+        * end of a list of sibling entries in a directory.  It also means the
+        * real length is 8, because the dentry included only the length field,
+        * but that takes up 8 bytes.  */
        le64 length;
 
-       /* Attributes of the file or directory.  This is a bitwise OR of the
-        * FILE_ATTRIBUTE_* constants and should correspond to the value
+       /* File attributes for the file or directory.  This is a bitwise OR of
+        * the FILE_ATTRIBUTE_* constants and should correspond to the value
         * retrieved by GetFileAttributes() on Windows. */
        le32 attributes;
 
@@ -84,7 +107,6 @@ struct wim_dentry_on_disk {
        le64 unused_1;
        le64 unused_2;
 
-
        /* Creation time, last access time, and last write time, in
         * 100-nanosecond intervals since 12:00 a.m UTC January 1, 1601.  They
         * should correspond to the times gotten by calling GetFileTime() on
@@ -93,250 +115,285 @@ struct wim_dentry_on_disk {
        le64 last_access_time;
        le64 last_write_time;
 
-       /* Vaguely, the SHA-1 message digest ("hash") of the file's contents.
-        * More specifically, this is for the "unnamed data stream" rather than
-        * any "alternate data streams".  This hash value is used to look up the
-        * corresponding entry in the WIM's stream lookup table to actually find
-        * the file contents within the WIM.
-        *
-        * If the file has no unnamed data stream (e.g. is a directory), then
-        * this field will be all zeroes.  If the unnamed data stream is empty
-        * (i.e. an "empty file"), then this field is also expected to be all
-        * zeroes.  (It will be if wimlib created the WIM image, at least;
-        * otherwise it can't be ruled out that the SHA-1 message digest of 0
-        * bytes of data is given explicitly.)
+       /*
+        * Usually this is the SHA-1 message digest of the file's "contents"
+        * (the unnamed data stream).
         *
-        * If the file has reparse data, then this field will instead specify
-        * the SHA-1 message digest of the reparse data.  If it is somehow
-        * possible for a file to have both an unnamed data stream and reparse
-        * data, then this is not handled by wimlib.
+        * If the file has FILE_ATTRIBUTE_REPARSE_POINT set, then this is
+        * instead usually the SHA-1 message digest of the uncompressed reparse
+        * point data.
         *
-        * As a further special case, if this field is all zeroes but there is
-        * an alternate data stream entry with no name and a nonzero SHA-1
-        * message digest field, then that hash must be used instead of this
-        * one.  In fact, when named data streams are present, some versions of
-        * Windows PE contain a bug where they only look in the alternate data
-        * stream entries for the unnamed data stream, not here.
+        * However, there are some special rules that need to be applied to
+        * interpret this field correctly when extra stream entries are present.
+        * See the code for details.
         */
-       u8 unnamed_stream_hash[SHA1_HASH_SIZE];
+       u8 default_hash[SHA1_HASH_SIZE];
 
-       /* The format of the following data is not yet completely known and they
-        * do not correspond to Microsoft's documentation.
+       /* Unknown field (maybe accidental padding)  */
+       le32 unknown_0x54;
+
+       /*
+        * The following 8-byte union contains either information about the
+        * reparse point (for files with FILE_ATTRIBUTE_REPARSE_POINT set), or
+        * the "hard link group ID" (for other files).
+        *
+        * The reparse point information contains ReparseTag and ReparseReserved
+        * from the header of the reparse point buffer.  It also contains a flag
+        * that indicates whether a reparse point fixup (for the target of an
+        * absolute symbolic link or junction) was done or not.
         *
-        * If this directory entry is for a reparse point (has
-        * FILE_ATTRIBUTE_REPARSE_POINT set in the attributes field), then the
-        * version of the following fields containing the reparse tag is valid.
-        * Furthermore, the field notated as not_rpfixed, as far as I can tell,
-        * is supposed to be set to 1 if reparse point fixups (a.k.a. fixing the
-        * targets of absolute symbolic links) were *not* done, and otherwise 0.
+        * The "hard link group ID" is like an inode number; all dentries for
+        * the same inode share the same value.  See inode_fixup.c for more
+        * information.
         *
-        * If this directory entry is not for a reparse point, then the version
-        * of the following fields containing the hard_link_group_id is valid.
-        * All MS says about this field is that "If this file is part of a hard
-        * link set, all the directory entries in the set will share the same
-        * value in this field.".  However, more specifically I have observed
-        * the following:
-        *    - If the file is part of a hard link set of size 1, then the
-        *    hard_link_group_id should be set to either 0, which is treated
-        *    specially as indicating "not hardlinked", or any unique value.
-        *    - The specific nonzero values used to identity hard link sets do
-        *    not matter, as long as they are unique.
-        *    - However, due to bugs in Microsoft's software, it is actually NOT
-        *    guaranteed that directory entries that share the same hard link
-        *    group ID are actually hard linked to each either.  We have to
-        *    handle this by using special code to use distinguishing features
-        *    (which is possible because some information about the underlying
-        *    inode is repeated in each dentry) to split up these fake hard link
-        *    groups into what they actually are supposed to be.
+        * Note that this union creates the limitation that reparse point files
+        * cannot have multiple names (hard links).
         */
        union {
                struct {
-                       le32 rp_unknown_1;
                        le32 reparse_tag;
-                       le16 rp_unknown_2;
-                       le16 not_rpfixed;
+                       le16 rp_reserved;
+                       le16 rp_flags;
                } _packed_attribute reparse;
                struct {
-                       le32 rp_unknown_1;
                        le64 hard_link_group_id;
                } _packed_attribute nonreparse;
        };
 
-       /* Number of alternate data stream entries that directly follow this
-        * dentry on-disk. */
-       le16 num_alternate_data_streams;
+       /* Number of extra stream entries that directly follow this dentry
+        * on-disk.  */
+       le16 num_extra_streams;
 
-       /* Length of this file's UTF-16LE encoded short name (8.3 DOS-compatible
-        * name), if present, in bytes, excluding the null terminator.  If this
-        * file has no short name, then this field should be 0.  */
+       /* If nonzero, this is the length, in bytes, of this dentry's UTF-16LE
+        * encoded short name (8.3 DOS-compatible name), excluding the null
+        * terminator.  If zero, then the long name of this dentry does not have
+        * a corresponding short name (but this does not exclude the possibility
+        * that another dentry for the same file has a short name).  */
        le16 short_name_nbytes;
 
-       /* Length of this file's UTF-16LE encoded "long" name, excluding the
-        * null terminator.  If this file has no short name, then this field
-        * should be 0.  It's expected that only the root dentry has this field
-        * set to 0.  */
-       le16 file_name_nbytes;
+       /* If nonzero, this is the length, in bytes, of this dentry's UTF-16LE
+        * encoded "long" name, excluding the null terminator.  If zero, then
+        * this file has no long name.  The root dentry should not have a long
+        * name, but all other dentries in the image should have long names.  */
+       le16 name_nbytes;
+
+       /* Beginning of optional, variable-length fields  */
 
-       /* Followed by variable length file name, in UTF16-LE, if
-        * file_name_nbytes != 0.  Includes null terminator. */
-       /*utf16lechar file_name[];*/
+       /* If name_nbytes != 0, the next field will be the UTF-16LE encoded long
+        * name.  This will be null-terminated, so the size of this field will
+        * really be name_nbytes + 2.  */
+       /*utf16lechar name[];*/
 
-       /* Followed by variable length short name, in UTF16-LE, if
-        * short_name_nbytes != 0.  Includes null terminator. */
+       /* If short_name_nbytes != 0, the next field will be the UTF-16LE
+        * encoded short name.  This will be null-terminated, so the size of
+        * this field will really be short_name_nbytes + 2.  */
        /*utf16lechar short_name[];*/
+
+       /* If there is still space in the dentry (according to the 'length'
+        * field) after 8-byte alignment, then the remaining space will be a
+        * variable-length list of tagged metadata items.  See tagged_items.c
+        * for more information.  */
+       /* u8 tagged_items[] _aligned_attribute(8); */
+
 } _packed_attribute;
+       /* If num_extra_streams != 0, then there are that many extra stream
+        * entries following the dentry, starting on the next 8-byte aligned
+        * boundary.  They are not counted in the 'length' field of the dentry.
+        */
 
-/* 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_nbytes, u16 short_name_nbytes)
-{
-       u64 length = sizeof(struct wim_dentry_on_disk);
-       if (file_name_nbytes)
-               length += file_name_nbytes + 2;
-       if (short_name_nbytes)
-               length += short_name_nbytes + 2;
-       return length;
-}
+/* On-disk format of an extra stream entry.  This represents an extra NTFS-style
+ * "stream" associated with the file, such as a named data stream.  */
+struct wim_extra_stream_entry_on_disk {
 
-/* Calculates the unaligned length, in bytes, of an on-disk WIM dentry, based on
- * 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_aligned(const struct wim_dentry *dentry)
-{
-       u64 len;
+       /* Length of this extra stream entry, in bytes.  This includes all
+        * fixed-length fields, plus the name and null terminator if present,
+        * and any needed padding such that the length is a multiple of 8.  */
+       le64 length;
 
-       len = dentry_correct_length_unaligned(dentry->file_name_nbytes,
-                                             dentry->short_name_nbytes);
-       return (len + 7) & ~7;
-}
+       /* Reserved field  */
+       le64 reserved;
 
-static int
-dentry_clear_short_name(struct wim_dentry *dentry)
+       /* SHA-1 message digest of this stream's uncompressed data, or all
+        * zeroes if this stream's data is of zero length.  */
+       u8 hash[SHA1_HASH_SIZE];
+
+       /* Length of this stream's name, in bytes and excluding the null
+        * terminator; or 0 if this stream is unnamed.  */
+       le16 name_nbytes;
+
+       /* Stream name in UTF-16LE.  It is @name_nbytes bytes long, excluding
+        * the null terminator.  There is a null terminator character if
+        * @name_nbytes != 0; i.e., if this stream is named.  */
+       utf16lechar name[];
+} _packed_attribute;
+
+static void
+do_dentry_set_name(struct wim_dentry *dentry, utf16lechar *name,
+                  size_t name_nbytes)
 {
+       FREE(dentry->d_name);
+       dentry->d_name = name;
+       dentry->d_name_nbytes = name_nbytes;
+
        if (dentry_has_short_name(dentry)) {
-               FREE(dentry->short_name);
-               dentry->short_name = NULL;
-               dentry->short_name_nbytes = 0;
+               FREE(dentry->d_short_name);
+               dentry->d_short_name = NULL;
+               dentry->d_short_name_nbytes = 0;
        }
-       return 0;
 }
 
-/* Sets the name of a WIM dentry from a multibyte string.
- * Only use this on dentries not inserted into the tree.  Use rename_wim_path()
- * to do a real rename.  */
+/*
+ * Set the name of a WIM dentry from a UTF-16LE string.
+ *
+ * This sets the long name of the dentry.  The short name will automatically be
+ * removed, since it may not be appropriate for the new long name.
+ *
+ * The @name string need not be null-terminated, since its length is specified
+ * in @name_nbytes.
+ *
+ * If @name_nbytes is 0, both the long and short names of the dentry will be
+ * removed.
+ *
+ * Only use this function on unlinked dentries, since it doesn't update the name
+ * indices.  For dentries that are currently linked into the tree, use
+ * rename_wim_path().
+ *
+ * Returns 0 or WIMLIB_ERR_NOMEM.
+ */
 int
-dentry_set_name(struct wim_dentry *dentry, const tchar *new_name)
+dentry_set_name_utf16le(struct wim_dentry *dentry, const utf16lechar *name,
+                       size_t name_nbytes)
 {
-       int ret;
+       utf16lechar *dup = NULL;
 
-       ret = get_utf16le_string(new_name, &dentry->file_name,
-                                &dentry->file_name_nbytes);
-       if (ret)
-               return ret;
-
-       return dentry_clear_short_name(dentry);
+       if (name_nbytes) {
+               dup = utf16le_dupz(name, name_nbytes);
+               if (!dup)
+                       return WIMLIB_ERR_NOMEM;
+       }
+       do_dentry_set_name(dentry, dup, name_nbytes);
+       return 0;
 }
 
-/* Sets the name of a WIM dentry from a UTF-16LE string.
- * Only use this on dentries not inserted into the tree.  Use rename_wim_path()
- * to do a real rename.  */
+
+/*
+ * Set the name of a WIM dentry from a 'tchar' string.
+ *
+ * This sets the long name of the dentry.  The short name will automatically be
+ * removed, since it may not be appropriate for the new long name.
+ *
+ * If @name is NULL or empty, both the long and short names of the dentry will
+ * be removed.
+ *
+ * Only use this function on unlinked dentries, since it doesn't update the name
+ * indices.  For dentries that are currently linked into the tree, use
+ * rename_wim_path().
+ *
+ * Returns 0 or an error code resulting from a failed string conversion.
+ */
 int
-dentry_set_name_utf16le(struct wim_dentry *dentry, const utf16lechar *new_name)
+dentry_set_name(struct wim_dentry *dentry, const tchar *name)
 {
-       utf16lechar *name = NULL;
-       size_t name_nbytes = 0;
-
-       if (new_name && *new_name) {
-               const utf16lechar *tmp;
-
-               tmp = new_name;
-               do {
-                       name_nbytes += sizeof(utf16lechar);
-               } while (*++tmp);
+       utf16lechar *name_utf16le = NULL;
+       size_t name_utf16le_nbytes = 0;
+       int ret;
 
-               name = memdup(new_name, name_nbytes + sizeof(utf16lechar));
-               if (!name)
-                       return WIMLIB_ERR_NOMEM;
+       if (name && *name) {
+               ret = tstr_to_utf16le(name, tstrlen(name) * sizeof(tchar),
+                                     &name_utf16le, &name_utf16le_nbytes);
+               if (ret)
+                       return ret;
        }
 
-       FREE(dentry->file_name);
-       dentry->file_name = name;
-       dentry->file_name_nbytes = name_nbytes;
-
-       return dentry_clear_short_name(dentry);
+       do_dentry_set_name(dentry, name_utf16le, name_utf16le_nbytes);
+       return 0;
 }
 
-/* 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)
+/* Calculate the minimum unaligned length, in bytes, of an on-disk WIM dentry
+ * that has names of the specified lengths.  (Zero length means the
+ * corresponding name actually does not exist.)  The returned value excludes
+ * tagged metadata items as well as any extra stream entries that may need to
+ * follow the dentry.  */
+static size_t
+dentry_min_len_with_names(u16 name_nbytes, u16 short_name_nbytes)
 {
-       u64 len = sizeof(struct wim_ads_entry_on_disk);
-       if (entry->stream_name_nbytes)
-               len += entry->stream_name_nbytes + 2;
-       return (len + 7) & ~7;
+       size_t length = sizeof(struct wim_dentry_on_disk);
+       if (name_nbytes)
+               length += (u32)name_nbytes + 2;
+       if (short_name_nbytes)
+               length += (u32)short_name_nbytes + 2;
+       return length;
 }
 
-/*
- * Determine whether to include a "dummy" stream when writing a WIM dentry:
- *
- * Some versions of Microsoft's WIM software (the boot driver(s) in WinPE 3.0,
- * for example) contain a bug where they assume the first alternate data stream
- * (ADS) entry of a dentry with a nonzero ADS count specifies the unnamed
- * stream, even if it has a name and the unnamed stream is already specified in
- * the hash field of the dentry itself.
- *
- * wimlib has to work around this behavior by carefully emulating the behavior
- * of (most versions of) ImageX/WIMGAPI, which move the unnamed stream reference
- * into the alternate stream entries whenever there are named data streams, even
- * though there is already a field in the dentry itself for the unnamed stream
- * reference, which then goes to waste.
- */
-static inline bool
-inode_needs_dummy_stream(const struct wim_inode *inode)
-{
-       return (inode->i_num_ads > 0 &&
-               inode->i_num_ads < 0xffff && /* overflow check */
-               inode->i_canonical_streams); /* assume the dentry is okay if it
-                                               already had an unnamed ADS entry
-                                               when it was read in  */
-}
 
-/* 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.  */
-u64
-dentry_out_total_length(const struct wim_dentry *dentry)
+/* Return the length, in bytes, required for the specified stream on-disk, when
+ * represented as an extra stream entry.  */
+static size_t
+stream_out_total_length(const struct wim_inode_stream *strm)
 {
-       u64 length = dentry_correct_length_aligned(dentry);
-       const struct wim_inode *inode = dentry->d_inode;
+       /* Account for the fixed length portion  */
+       size_t len = sizeof(struct wim_extra_stream_entry_on_disk);
 
-       if (inode_needs_dummy_stream(inode))
-               length += ads_entry_total_length(&(struct wim_ads_entry){});
+       /* For named streams, account for the variable-length name.  */
+       if (stream_is_named(strm))
+               len += utf16le_len_bytes(strm->stream_name) + 2;
 
-       for (u16 i = 0; i < inode->i_num_ads; i++)
-               length += ads_entry_total_length(&inode->i_ads_entries[i]);
-
-       return length;
+       /* Account for any necessary padding to the next 8-byte boundary.  */
+       return ALIGN(len, 8);
 }
 
-/* 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)
+/*
+ * Calculate the total number of bytes that will be consumed when a dentry is
+ * written.  This includes the fixed-length portion of the dentry, the name
+ * fields, any tagged metadata items, and any extra stream entries.  This also
+ * includes all alignment bytes.
+ */
+size_t
+dentry_out_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;
+       size_t len;
+
+       len = dentry_min_len_with_names(dentry->d_name_nbytes,
+                                       dentry->d_short_name_nbytes);
+       len = ALIGN(len, 8);
+
+       len += ALIGN(inode->i_extra_size, 8);
+
+       if (!(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED)) {
+               /*
+                * Extra stream entries:
+                *
+                * - Use one extra stream entry for each named data stream
+                * - Use one extra stream entry for the unnamed data stream when there is either:
+                *      - a reparse point stream
+                *      - at least one named data stream (for Windows PE bug workaround)
+                * - Use one extra stream entry for the reparse point stream if there is one
+                */
+               bool have_named_data_stream = false;
+               bool have_reparse_point_stream = false;
+               for (unsigned i = 0; i < inode->i_num_streams; i++) {
+                       const struct wim_inode_stream *strm = &inode->i_streams[i];
+                       if (stream_is_named_data_stream(strm)) {
+                               len += stream_out_total_length(strm);
+                               have_named_data_stream = true;
+                       } else if (strm->stream_type == STREAM_TYPE_REPARSE_POINT) {
+                               wimlib_assert(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT);
+                               have_reparse_point_stream = true;
+                       }
+               }
+
+               if (have_named_data_stream || have_reparse_point_stream) {
+                       if (have_reparse_point_stream)
+                               len += ALIGN(sizeof(struct wim_extra_stream_entry_on_disk), 8);
+                       len += ALIGN(sizeof(struct wim_extra_stream_entry_on_disk), 8);
+               }
+       }
+
+       return len;
 }
 
+/* Internal version of for_dentry_in_tree() that omits the NULL check  */
 static int
 do_for_dentry_in_tree(struct wim_dentry *dentry,
                      int (*visitor)(struct wim_dentry *, void *), void *arg)
@@ -356,7 +413,7 @@ do_for_dentry_in_tree(struct wim_dentry *dentry,
        return 0;
 }
 
-
+/* Internal version of for_dentry_in_tree_depth() that omits the NULL check  */
 static int
 do_for_dentry_in_tree_depth(struct wim_dentry *dentry,
                            int (*visitor)(struct wim_dentry *, void *), void *arg)
@@ -372,10 +429,25 @@ do_for_dentry_in_tree_depth(struct wim_dentry *dentry,
        return unlikely((*visitor)(dentry, arg));
 }
 
-/* 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.
- * */
+/*
+ * Call a function on all dentries in a tree.
+ *
+ * @arg will be passed as the second argument to each invocation of @visitor.
+ *
+ * This function does a pre-order traversal --- that is, a parent will be
+ * visited before its children.  It also will visit siblings in order of
+ * case-sensitive filename.  Equivalently, this function visits the entire tree
+ * in the case-sensitive lexicographic order of the full paths.
+ *
+ * It is safe to pass NULL for @root, which means that the dentry tree is empty.
+ * In this case, this function does nothing.
+ *
+ * @visitor must not modify the structure of the dentry tree during the
+ * traversal.
+ *
+ * The return value will be 0 if all calls to @visitor returned 0.  Otherwise,
+ * the return value will be the first nonzero value returned by @visitor.
+ */
 int
 for_dentry_in_tree(struct wim_dentry *root,
                   int (*visitor)(struct wim_dentry *, void *), void *arg)
@@ -385,9 +457,10 @@ for_dentry_in_tree(struct wim_dentry *root,
        return do_for_dentry_in_tree(root, visitor, arg);
 }
 
-/* Like for_dentry_in_tree(), but the visitor function is always called on a
- * dentry's children before on itself. */
-int
+/* Like for_dentry_in_tree(), but do a depth-first traversal of the dentry tree.
+ * That is, the visitor function will be called on a dentry's children before
+ * itself.  It will be safe to free a dentry when visiting it.  */
+static int
 for_dentry_in_tree_depth(struct wim_dentry *root,
                         int (*visitor)(struct wim_dentry *, void *), void *arg)
 {
@@ -396,97 +469,74 @@ for_dentry_in_tree_depth(struct wim_dentry *root,
        return do_for_dentry_in_tree_depth(root, visitor, arg);
 }
 
-/* Calculate the full path of @dentry.  */
+/*
+ * Calculate the full path to @dentry within the WIM image, if not already done.
+ *
+ * The full name will be saved in the cached value 'dentry->d_full_path'.
+ *
+ * Whenever possible, use dentry_full_path() instead of calling this and
+ * accessing d_full_path directly.
+ *
+ * Returns 0 or an error code resulting from a failed string conversion.
+ */
 int
 calculate_dentry_full_path(struct wim_dentry *dentry)
 {
-       tchar *full_path;
-       u32 full_path_nbytes;
-       int ret;
+       size_t ulen;
+       size_t dummy;
+       const struct wim_dentry *d;
 
-       if (dentry->_full_path)
+       if (dentry->d_full_path)
                return 0;
 
-       if (dentry_is_root(dentry)) {
-               static const tchar _root_path[] = {WIM_PATH_SEPARATOR, T('\0')};
-               full_path = TSTRDUP(_root_path);
-               if (full_path == NULL)
-                       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;
-
-               parent = dentry->parent;
-               if (dentry_is_root(parent)) {
-                       parent_full_path = T("");
-                       parent_full_path_nbytes = 0;
-               } else {
-                       if (parent->_full_path == NULL) {
-                               ret = calculate_dentry_full_path(parent);
-                               if (ret)
-                                       return ret;
-                       }
-                       parent_full_path = parent->_full_path;
-                       parent_full_path_nbytes = parent->full_path_nbytes;
-               }
+       ulen = 0;
+       d = dentry;
+       do {
+               ulen += d->d_name_nbytes / sizeof(utf16lechar);
+               ulen++;
+               d = d->d_parent;  /* assumes d == d->d_parent for root  */
+       } while (!dentry_is_root(d));
 
-               /* 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
+       utf16lechar ubuf[ulen];
+       utf16lechar *p = &ubuf[ulen];
 
-               full_path_nbytes = parent_full_path_nbytes + sizeof(tchar) +
-                                  filename_nbytes;
-               full_path = MALLOC(full_path_nbytes + sizeof(tchar));
-               if (full_path == NULL)
-                       return WIMLIB_ERR_NOMEM;
-               memcpy(full_path, parent_full_path, parent_full_path_nbytes);
-               full_path[parent_full_path_nbytes / sizeof(tchar)] = WIM_PATH_SEPARATOR;
-       #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
-       }
-       dentry->_full_path = full_path;
-       dentry->full_path_nbytes= full_path_nbytes;
-       return 0;
+       d = dentry;
+       do {
+               p -= d->d_name_nbytes / sizeof(utf16lechar);
+               memcpy(p, d->d_name, d->d_name_nbytes);
+               *--p = cpu_to_le16(WIM_PATH_SEPARATOR);
+               d = d->d_parent;  /* assumes d == d->d_parent for root  */
+       } while (!dentry_is_root(d));
+
+       wimlib_assert(p == ubuf);
+
+       return utf16le_to_tstr(ubuf, ulen * sizeof(utf16lechar),
+                              &dentry->d_full_path, &dummy);
 }
 
+/*
+ * Return the full path to the @dentry within the WIM image, or NULL if the full
+ * path could not be determined due to a string conversion error.
+ *
+ * The returned memory will be cached in the dentry, so the caller is not
+ * responsible for freeing it.
+ */
 tchar *
 dentry_full_path(struct wim_dentry *dentry)
 {
        calculate_dentry_full_path(dentry);
-       return dentry->_full_path;
+       return dentry->d_full_path;
 }
 
 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;
 
                /* Set offset of directory's child dentries  */
-               dentry->subdir_offset = *subdir_offset_p;
+               dentry->d_subdir_offset = *subdir_offset_p;
 
                /* Account for child dentries  */
                for_dentry_child(child, dentry)
@@ -495,14 +545,25 @@ dentry_calculate_subdir_offset(struct wim_dentry *dentry, void *_subdir_offset_p
                /* Account for end-of-directory entry  */
                *subdir_offset_p += 8;
        } else {
-               /* Not a directory; set subdir_offset to 0  */
-               dentry->subdir_offset = 0;
+               /* Not a directory; set the subdir offset to 0  */
+               dentry->d_subdir_offset = 0;
        }
        return 0;
 }
 
 /*
- * Calculates the subdir offsets for a directory tree.
+ * Calculate the subdir offsets for a dentry tree, in preparation of writing
+ * that dentry tree to a metadata resource.
+ *
+ * The subdir offset of each dentry is the offset in the uncompressed metadata
+ * resource at which its child dentries begin, or 0 if that dentry has no
+ * children.
+ *
+ * The caller must initialize *subdir_offset_p to the first subdir offset that
+ * is available to use after the root dentry is written.
+ *
+ * When this function returns, *subdir_offset_p will have been advanced past the
+ * size needed for the dentry tree within the uncompressed metadata resource.
  */
 void
 calculate_subdir_offsets(struct wim_dentry *root, u64 *subdir_offset_p)
@@ -515,10 +576,10 @@ static int
 dentry_compare_names_case_insensitive(const struct wim_dentry *d1,
                                      const struct wim_dentry *d2)
 {
-       return cmp_utf16le_strings(d1->file_name,
-                                  d1->file_name_nbytes / 2,
-                                  d2->file_name,
-                                  d2->file_name_nbytes / 2,
+       return cmp_utf16le_strings(d1->d_name,
+                                  d1->d_name_nbytes / 2,
+                                  d2->d_name,
+                                  d2->d_name_nbytes / 2,
                                   true);
 }
 
@@ -527,10 +588,10 @@ static int
 dentry_compare_names_case_sensitive(const struct wim_dentry *d1,
                                    const struct wim_dentry *d2)
 {
-       return cmp_utf16le_strings(d1->file_name,
-                                  d1->file_name_nbytes / 2,
-                                  d2->file_name,
-                                  d2->file_name_nbytes / 2,
+       return cmp_utf16le_strings(d1->d_name,
+                                  d1->d_name_nbytes / 2,
+                                  d2->d_name,
+                                  d2->d_name_nbytes / 2,
                                   false);
 }
 
@@ -557,8 +618,9 @@ _avl_dentry_compare_names(const struct avl_tree_node *n1,
 }
 
 /* Default case sensitivity behavior for searches with
- * WIMLIB_CASE_PLATFORM_DEFAULT specified.  This can be modified by
- * wimlib_global_init().  */
+ * WIMLIB_CASE_PLATFORM_DEFAULT specified.  This can be modified by passing
+ * WIMLIB_INIT_FLAG_DEFAULT_CASE_SENSITIVE or
+ * WIMLIB_INIT_FLAG_DEFAULT_CASE_INSENSITIVE to wimlib_global_init().  */
 bool default_ignore_case =
 #ifdef __WIN32__
        true
@@ -567,8 +629,8 @@ bool default_ignore_case =
 #endif
 ;
 
-/* Case-sensitive dentry lookup.  Only @file_name and @file_name_nbytes of
- * @dummy must be valid.  */
+/* Case-sensitive dentry lookup.  Only @d_name and @d_name_nbytes of @dummy must
+ * be valid.  */
 static struct wim_dentry *
 dir_lookup(const struct wim_inode *dir, const struct wim_dentry *dummy)
 {
@@ -582,8 +644,8 @@ dir_lookup(const struct wim_inode *dir, const struct wim_dentry *dummy)
        return avl_tree_entry(node, struct wim_dentry, d_index_node);
 }
 
-/* Case-insensitive dentry lookup.  Only @file_name and @file_name_nbytes of
- * @dummy must be valid.  */
+/* Case-insensitive dentry lookup.  Only @d_name and @d_name_nbytes of @dummy
+ * must be valid.  */
 static struct wim_dentry *
 dir_lookup_ci(const struct wim_inode *dir, const struct wim_dentry *dummy)
 {
@@ -598,8 +660,8 @@ dir_lookup_ci(const struct wim_inode *dir, const struct wim_dentry *dummy)
 }
 
 /* Given a UTF-16LE filename and a directory, look up the dentry for the file.
- * Return it if found, otherwise NULL.  This is case-sensitive on UNIX and
- * case-insensitive on Windows. */
+ * Return it if found, otherwise NULL.  This has configurable case sensitivity,
+ * and @name need not be null-terminated.  */
 struct wim_dentry *
 get_dentry_child_with_utf16le_name(const struct wim_dentry *dentry,
                                   const utf16lechar *name,
@@ -611,8 +673,8 @@ get_dentry_child_with_utf16le_name(const struct wim_dentry *dentry,
        struct wim_dentry dummy;
        struct wim_dentry *child;
 
-       dummy.file_name = (utf16lechar*)name;
-       dummy.file_name_nbytes = name_nbytes;
+       dummy.d_name = (utf16lechar*)name;
+       dummy.d_name_nbytes = name_nbytes;
 
        if (!ignore_case)
                /* Case-sensitive lookup.  */
@@ -654,37 +716,34 @@ get_dentry_child_with_utf16le_name(const struct wim_dentry *dentry,
        return child;
 }
 
-/* Returns the child of @dentry that has the file name @name.  Returns NULL if
- * no child has the name. */
+/* Given a 'tchar' filename and a directory, look up the dentry for the file.
+ * If the filename was successfully converted to UTF-16LE and the dentry was
+ * found, return it; otherwise return NULL.  This has configurable case
+ * sensitivity.  */
 struct wim_dentry *
 get_dentry_child_with_name(const struct wim_dentry *dentry, const tchar *name,
                           CASE_SENSITIVITY_TYPE case_type)
 {
-#if TCHAR_IS_UTF16LE
-       return get_dentry_child_with_utf16le_name(dentry, name,
-                                                 tstrlen(name) * sizeof(tchar),
-                                                 case_type);
-#else
-       utf16lechar *utf16le_name;
-       size_t utf16le_name_nbytes;
        int ret;
+       const utf16lechar *name_utf16le;
+       size_t name_utf16le_nbytes;
        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,
-                                                          case_type);
-               FREE(utf16le_name);
-       }
+       ret = tstr_get_utf16le_and_len(name, &name_utf16le,
+                                      &name_utf16le_nbytes);
+       if (ret)
+               return NULL;
+
+       child = get_dentry_child_with_utf16le_name(dentry,
+                                                  name_utf16le,
+                                                  name_utf16le_nbytes,
+                                                  case_type);
+       tstr_put_utf16le(name_utf16le);
        return child;
-#endif
 }
 
+/* This is the UTF-16LE version of get_dentry(), currently private to this file
+ * because no one needs it besides get_dentry().  */
 static struct wim_dentry *
 get_dentry_utf16le(WIMStruct *wim, const utf16lechar *path,
                   CASE_SENSITIVITY_TYPE case_type)
@@ -695,7 +754,7 @@ get_dentry_utf16le(WIMStruct *wim, const utf16lechar *path,
        /* Start with the root directory of the image.  Note: this will be NULL
         * if an image has been added directly with wimlib_add_empty_image() but
         * no files have been added yet; in that case we fail with ENOENT.  */
-       cur_dentry = wim_root_dentry(wim);
+       cur_dentry = wim_get_current_root_dentry(wim);
 
        name_start = path;
        for (;;) {
@@ -789,37 +848,31 @@ get_dentry_utf16le(WIMStruct *wim, const utf16lechar *path,
 struct wim_dentry *
 get_dentry(WIMStruct *wim, const tchar *path, CASE_SENSITIVITY_TYPE case_type)
 {
-#if TCHAR_IS_UTF16LE
-       return get_dentry_utf16le(wim, path, case_type);
-#else
-       utf16lechar *path_utf16le;
-       size_t path_utf16le_nbytes;
        int ret;
+       const utf16lechar *path_utf16le;
        struct wim_dentry *dentry;
 
-       ret = tstr_to_utf16le(path, tstrlen(path) * sizeof(tchar),
-                             &path_utf16le, &path_utf16le_nbytes);
+       ret = tstr_get_utf16le(path, &path_utf16le);
        if (ret)
                return NULL;
        dentry = get_dentry_utf16le(wim, path_utf16le, case_type);
-       FREE(path_utf16le);
+       tstr_put_utf16le(path_utf16le);
        return dentry;
-#endif
 }
 
-/* Takes in a path of length @len in @buf, and transforms it into a string for
- * the path of its parent directory. */
+/* Modify @path, which is a null-terminated string @len 'tchars' in length,
+ * in-place to produce the path to its parent directory.  */
 static void
-to_parent_name(tchar *buf, size_t len)
+to_parent_name(tchar *path, size_t len)
 {
        ssize_t i = (ssize_t)len - 1;
-       while (i >= 0 && buf[i] == WIM_PATH_SEPARATOR)
+       while (i >= 0 && path[i] == WIM_PATH_SEPARATOR)
                i--;
-       while (i >= 0 && buf[i] != WIM_PATH_SEPARATOR)
+       while (i >= 0 && path[i] != WIM_PATH_SEPARATOR)
                i--;
-       while (i >= 0 && buf[i] == WIM_PATH_SEPARATOR)
+       while (i >= 0 && path[i] == WIM_PATH_SEPARATOR)
                i--;
-       buf[i + 1] = T('\0');
+       path[i + 1] = T('\0');
 }
 
 /* Similar to get_dentry(), but returns the dentry named by @path with the last
@@ -838,159 +891,92 @@ 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.
+/*
+ * Create an unlinked dentry.
  *
- * 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;
-               u16 ads_idx;
-               ads_entry = inode_get_ads_entry(inode, stream_name,
-                                               &ads_idx);
-               if (ads_entry) {
-                       stream_idx = ads_idx + 1;
-                       lte = ads_entry->lte;
-                       goto out;
-               } else {
-                       return -ENOENT;
-               }
-       } else {
-               lte = inode_unnamed_stream_resolved(inode, &stream_idx);
-       }
-out:
-       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  */
-
-/* Initializations done on every `struct wim_dentry'. */
-static void
-dentry_common_init(struct wim_dentry *dentry)
-{
-       memset(dentry, 0, sizeof(struct wim_dentry));
-}
-
-/* Creates an unlinked directory entry. */
-int
+ * @name specifies the long name to give the new dentry.  If NULL or empty, the
+ * new dentry will be given no long name.
+ *
+ * The new dentry will have no short name and no associated inode.
+ *
+ * On success, returns 0 and a pointer to the new, allocated dentry is stored in
+ * *dentry_ret.  On failure, returns WIMLIB_ERR_NOMEM or an error code resulting
+ * from a failed string conversion.
+ */
+static 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 == NULL)
+       dentry = CALLOC(1, sizeof(struct wim_dentry));
+       if (!dentry)
                return WIMLIB_ERR_NOMEM;
 
-       dentry_common_init(dentry);
-       if (*name) {
+       if (name && *name) {
                ret = dentry_set_name(dentry, name);
                if (ret) {
                        FREE(dentry);
-                       ERROR("Failed to set name on new dentry with name \"%"TS"\"",
-                             name);
                        return ret;
                }
        }
-       dentry->parent = dentry;
+       dentry->d_parent = dentry;
        *dentry_ret = dentry;
        return 0;
 }
 
-static int
-_new_dentry_with_inode(const tchar *name, struct wim_dentry **dentry_ret,
-                       bool timeless)
+/* Like new_dentry(), but also allocate an inode and associate it with the
+ * dentry.  If set_timestamps=true, the timestamps for the inode will be set to
+ * the current time; otherwise, they will be left 0.  */
+int
+new_dentry_with_new_inode(const tchar *name, bool set_timestamps,
+                         struct wim_dentry **dentry_ret)
 {
        struct wim_dentry *dentry;
+       struct wim_inode *inode;
        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 == NULL) {
+       inode = new_inode(dentry, set_timestamps);
+       if (!inode) {
                free_dentry(dentry);
                return WIMLIB_ERR_NOMEM;
        }
 
-       inode_add_dentry(dentry, dentry->d_inode);
        *dentry_ret = dentry;
        return 0;
 }
 
+/* Like new_dentry(), but also associate the new dentry with the specified inode
+ * and acquire a reference to each of the inode's blobs.  */
 int
-new_dentry_with_timeless_inode(const tchar *name, struct wim_dentry **dentry_ret)
-{
-       return _new_dentry_with_inode(name, dentry_ret, true);
-}
-
-int
-new_dentry_with_inode(const tchar *name, struct wim_dentry **dentry_ret)
+new_dentry_with_existing_inode(const tchar *name, struct wim_inode *inode,
+                              struct wim_dentry **dentry_ret)
 {
-       return _new_dentry_with_inode(name, dentry_ret, false);
+       int ret = new_dentry(name, dentry_ret);
+       if (ret)
+               return ret;
+       d_associate(*dentry_ret, inode);
+       inode_ref_blobs(inode);
+       return 0;
 }
 
+/* Create an unnamed dentry with a new inode for a directory with the default
+ * metadata.  */
 int
-new_filler_directory(const tchar *name, struct wim_dentry **dentry_ret)
+new_filler_directory(struct wim_dentry **dentry_ret)
 {
        int ret;
        struct wim_dentry *dentry;
 
-       DEBUG("Creating filler directory \"%"TS"\"", name);
-       ret = new_dentry_with_inode(name, &dentry);
+       ret = new_dentry_with_new_inode(NULL, true, &dentry);
        if (ret)
                return ret;
        /* Leave the inode number as 0; this is allowed for non
         * hard-linked files. */
-       dentry->d_inode->i_resolved = 1;
        dentry->d_inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY;
        *dentry_ret = dentry;
        return 0;
@@ -1009,63 +995,68 @@ dentry_tree_clear_inode_visited(struct wim_dentry *root)
        for_dentry_in_tree(root, dentry_clear_inode_visited, NULL);
 }
 
-/* Frees a WIM dentry.
+/*
+ * Free a WIM dentry.
  *
- * The corresponding inode (if any) is freed only if its link count is
- * decremented to 0.  */
+ * In addition to freeing the dentry itself, this disassociates the dentry from
+ * its inode.  If the inode is no longer in use, it will be freed as well.
+ */
 void
 free_dentry(struct wim_dentry *dentry)
 {
        if (dentry) {
-               FREE(dentry->file_name);
-               FREE(dentry->short_name);
-               FREE(dentry->_full_path);
-               if (dentry->d_inode)
-                       put_inode(dentry->d_inode);
+               d_disassociate(dentry);
+               FREE(dentry->d_name);
+               FREE(dentry->d_short_name);
+               FREE(dentry->d_full_path);
                FREE(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)
+do_free_dentry(struct wim_dentry *dentry, void *_ignore)
 {
-       struct wim_lookup_table *lookup_table = _lookup_table;
-
-       if (lookup_table) {
-               struct wim_inode *inode = dentry->d_inode;
-               for (unsigned i = 0; i <= inode->i_num_ads; i++) {
-                       struct wim_lookup_table_entry *lte;
+       free_dentry(dentry);
+       return 0;
+}
 
-                       lte = inode_stream_lte(inode, i, lookup_table);
-                       if (lte)
-                               lte_decrement_refcnt(lte, lookup_table);
-               }
-       }
+static int
+do_free_dentry_and_unref_blobs(struct wim_dentry *dentry, void *blob_table)
+{
+       inode_unref_blobs(dentry->d_inode, blob_table);
        free_dentry(dentry);
        return 0;
 }
 
 /*
- * Recursively frees all directory entries in the specified tree.
+ * Free all dentries in a tree.
  *
  * @root:
- *     The root of the tree.
+ *     The root of the dentry tree to free.  If NULL, this function has no
+ *     effect.
  *
- * @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.
+ * @blob_table:
+ *     A pointer to the blob table for the WIM, or NULL if not specified.  If
+ *     specified, this function will decrement the reference counts of the
+ *     blobs referenced by the dentries.
  *
- * This also puts references to the corresponding inodes.
+ * This function also releases references to the corresponding inodes.
  *
- * This does *not* unlink @root from its parent directory (if it has one).
+ * This function does *not* unlink @root from its parent directory, if it has
+ * one.  If @root has a parent, the caller must unlink @root before calling this
+ * function.
  */
 void
-free_dentry_tree(struct wim_dentry *root, struct wim_lookup_table *lookup_table)
+free_dentry_tree(struct wim_dentry *root, struct blob_table *blob_table)
 {
-       for_dentry_in_tree_depth(root, do_free_dentry, lookup_table);
+       int (*f)(struct wim_dentry *, void *);
+
+       if (blob_table)
+               f = do_free_dentry_and_unref_blobs;
+       else
+               f = do_free_dentry;
+
+       for_dentry_in_tree_depth(root, f, blob_table);
 }
 
 /* Insert the @child dentry into the case sensitive index of the @dir directory.
@@ -1100,21 +1091,21 @@ dir_index_child_ci(struct wim_inode *dir, struct wim_dentry *child)
        return avl_tree_entry(duplicate, struct wim_dentry, d_index_node_ci);
 }
 
-/* Removes the specified dentry from its directory's case-sensitive index.  */
+/* Remove the specified dentry from its directory's case-sensitive index.  */
 static void
 dir_unindex_child(struct wim_inode *dir, struct wim_dentry *child)
 {
        avl_tree_remove(&dir->i_children, &child->d_index_node);
 }
 
-/* Removes the specified dentry from its directory's case-insensitive index.  */
+/* Remove the specified dentry from its directory's case-insensitive index.  */
 static void
 dir_unindex_child_ci(struct wim_inode *dir, struct wim_dentry *child)
 {
        avl_tree_remove(&dir->i_children_ci, &child->d_index_node_ci);
 }
 
-/* Returns true iff the specified dentry is in its parent directory's
+/* Return true iff the specified dentry is in its parent directory's
  * case-insensitive index.  */
 static bool
 dentry_in_ci_index(const struct wim_dentry *dentry)
@@ -1123,10 +1114,13 @@ dentry_in_ci_index(const struct wim_dentry *dentry)
 }
 
 /*
- * Links a dentry into the directory tree.
+ * Link a dentry into the tree.
+ *
+ * @parent:
+ *     The dentry that will be the parent of @child.  It must name a directory.
  *
- * @parent: The dentry that will be the parent of @child.
- * @child: The dentry to link.
+ * @child:
+ *     The dentry to link.  It must be currently unlinked.
  *
  * Returns NULL if successful.  If @parent already contains a dentry with the
  * same case-sensitive name as @child, returns a pointer to this duplicate
@@ -1155,20 +1149,23 @@ 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;
 }
 
-/* Unlink a WIM dentry from the directory entry tree.  */
+/* Unlink a dentry from the tree.  */
 void
 unlink_dentry(struct wim_dentry *dentry)
 {
        struct wim_inode *dir;
 
-       if (dentry_is_root(dentry))
+       /* Do nothing if the dentry is root or it's already unlinked.  Not
+        * actually necessary based on the current callers, but we do the check
+        * here to be safe.  */
+       if (unlikely(dentry->d_parent == dentry))
                return;
 
-       dir = dentry->parent->d_inode;
+       dir = dentry->d_parent->d_inode;
 
        dir_unindex_child(dir, dentry);
 
@@ -1178,7 +1175,7 @@ unlink_dentry(struct wim_dentry *dentry)
 
                if (!list_empty(&dentry->d_ci_conflict_list)) {
                        /* Make a different case-insensitively-the-same dentry
-                        * be the "representative" in the search index. */
+                        * be the "representative" in the search index.  */
                        struct list_head *next;
                        struct wim_dentry *other;
                        struct wim_dentry *existing;
@@ -1190,21 +1187,210 @@ unlink_dentry(struct wim_dentry *dentry)
                }
        }
        list_del(&dentry->d_ci_conflict_list);
+
+       /* Not actually necessary, but to be safe don't retain the now-obsolete
+        * parent pointer.  */
+       dentry->d_parent = dentry;
+}
+
+static int
+read_extra_data(const u8 *p, const u8 *end, struct wim_inode *inode)
+{
+       while (((uintptr_t)p & 7) && p < end)
+               p++;
+
+       if (unlikely(p < end)) {
+               inode->i_extra = memdup(p, end - p);
+               if (!inode->i_extra)
+                       return WIMLIB_ERR_NOMEM;
+               inode->i_extra_size = end - p;
+       }
+       return 0;
+}
+
+/*
+ * Set the type of each stream for an encrypted file.
+ *
+ * All data streams of the encrypted file should have been packed into a single
+ * stream in the format provided by ReadEncryptedFileRaw() on Windows.  We
+ * assign this stream type STREAM_TYPE_EFSRPC_RAW_DATA.
+ *
+ * Encrypted files can't have a reparse point stream.  In the on-disk NTFS
+ * format they can, but as far as I know the reparse point stream of an
+ * encrypted file can't be stored in the WIM format in a way that's compatible
+ * with WIMGAPI, nor is there even any way for it to be read or written on
+ * Windows when the process does not have access to the file encryption key.
+ */
+static void
+assign_stream_types_encrypted(struct wim_inode *inode)
+{
+       for (unsigned i = 0; i < inode->i_num_streams; i++) {
+               struct wim_inode_stream *strm = &inode->i_streams[i];
+               if (!stream_is_named(strm) && !is_zero_hash(strm->_stream_hash))
+               {
+                       strm->stream_type = STREAM_TYPE_EFSRPC_RAW_DATA;
+                       return;
+               }
+       }
+}
+
+/*
+ * Set the type of each stream for an unencrypted file.
+ *
+ * There will be an unnamed data stream, a reparse point stream, or both an
+ * unnamed data stream and a reparse point stream.  In addition, there may be
+ * named data streams.
+ */
+static void
+assign_stream_types_unencrypted(struct wim_inode *inode)
+{
+       bool found_reparse_point_stream = false;
+       bool found_unnamed_data_stream = false;
+       struct wim_inode_stream *unnamed_stream_with_zero_hash = NULL;
+
+       for (unsigned i = 0; i < inode->i_num_streams; i++) {
+               struct wim_inode_stream *strm = &inode->i_streams[i];
+
+               if (stream_is_named(strm)) {
+                       /* Named data stream  */
+                       strm->stream_type = STREAM_TYPE_DATA;
+               } else if (!is_zero_hash(strm->_stream_hash)) {
+                       if ((inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) &&
+                           !found_reparse_point_stream) {
+                               found_reparse_point_stream = true;
+                               strm->stream_type = STREAM_TYPE_REPARSE_POINT;
+                       } else if (!found_unnamed_data_stream) {
+                               found_unnamed_data_stream = true;
+                               strm->stream_type = STREAM_TYPE_DATA;
+                       }
+               } else {
+                       /* If no stream name is specified and the hash is zero,
+                        * then remember this stream for later so that we can
+                        * assign it to the unnamed data stream if we don't find
+                        * a better candidate.  */
+                       unnamed_stream_with_zero_hash = strm;
+               }
+       }
+
+       if (!found_unnamed_data_stream && unnamed_stream_with_zero_hash != NULL)
+               unnamed_stream_with_zero_hash->stream_type = STREAM_TYPE_DATA;
+}
+
+/*
+ * Read and interpret the collection of streams for the specified inode.
+ */
+static int
+setup_inode_streams(const u8 *p, const u8 *end, struct wim_inode *inode,
+                   unsigned num_extra_streams, const u8 *default_hash,
+                   u64 *offset_p)
+{
+       const u8 *orig_p = p;
+
+       inode->i_num_streams = 1 + num_extra_streams;
+
+       if (unlikely(inode->i_num_streams > ARRAY_LEN(inode->i_embedded_streams))) {
+               inode->i_streams = CALLOC(inode->i_num_streams,
+                                         sizeof(inode->i_streams[0]));
+               if (!inode->i_streams)
+                       return WIMLIB_ERR_NOMEM;
+       }
+
+       /* Use the default hash field for the first stream  */
+       inode->i_streams[0].stream_name = (utf16lechar *)NO_STREAM_NAME;
+       copy_hash(inode->i_streams[0]._stream_hash, default_hash);
+       inode->i_streams[0].stream_type = STREAM_TYPE_UNKNOWN;
+       inode->i_streams[0].stream_id = 0;
+
+       /* Read the extra stream entries  */
+       for (unsigned i = 1; i < inode->i_num_streams; i++) {
+               struct wim_inode_stream *strm;
+               const struct wim_extra_stream_entry_on_disk *disk_strm;
+               u64 length;
+               u16 name_nbytes;
+
+               strm = &inode->i_streams[i];
+
+               strm->stream_id = i;
+
+               /* Do we have at least the size of the fixed-length data we know
+                * need?  */
+               if ((end - p) < sizeof(struct wim_extra_stream_entry_on_disk))
+                       return WIMLIB_ERR_INVALID_METADATA_RESOURCE;
+
+               disk_strm = (const struct wim_extra_stream_entry_on_disk *)p;
+
+               /* Read the length field  */
+               length = ALIGN(le64_to_cpu(disk_strm->length), 8);
+
+               /* Make sure the length field is neither so small it doesn't
+                * include all the fixed-length data nor so large it overflows
+                * the metadata resource buffer. */
+               if (length < sizeof(struct wim_extra_stream_entry_on_disk) ||
+                   length > (end - p))
+                       return WIMLIB_ERR_INVALID_METADATA_RESOURCE;
+
+               /* Read the rest of the fixed-length data. */
+
+               copy_hash(strm->_stream_hash, disk_strm->hash);
+               name_nbytes = le16_to_cpu(disk_strm->name_nbytes);
+
+               /* If stream_name_nbytes != 0, the stream is named.  */
+               if (name_nbytes != 0) {
+                       /* The name is encoded in UTF16-LE, which uses 2-byte
+                        * coding units, so the length of the name had better be
+                        * an even number of bytes.  */
+                       if (name_nbytes & 1)
+                               return WIMLIB_ERR_INVALID_METADATA_RESOURCE;
+
+                       /* Add the length of the stream name to get the length
+                        * we actually need to read.  Make sure this isn't more
+                        * than the specified length of the entry.  */
+                       if (sizeof(struct wim_extra_stream_entry_on_disk) +
+                           name_nbytes > length)
+                               return WIMLIB_ERR_INVALID_METADATA_RESOURCE;
+
+                       strm->stream_name = utf16le_dupz(disk_strm->name,
+                                                        name_nbytes);
+                       if (!strm->stream_name)
+                               return WIMLIB_ERR_NOMEM;
+               } else {
+                       strm->stream_name = (utf16lechar *)NO_STREAM_NAME;
+               }
+
+               strm->stream_type = STREAM_TYPE_UNKNOWN;
+
+               p += length;
+       }
+
+       inode->i_next_stream_id = inode->i_num_streams;
+
+       /* Now, assign a type to each stream.  Unfortunately this requires
+        * various hacks because stream types aren't explicitly provided in the
+        * WIM on-disk format.  */
+
+       if (unlikely(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED))
+               assign_stream_types_encrypted(inode);
+       else
+               assign_stream_types_unencrypted(inode);
+
+       *offset_p += p - orig_p;
+       return 0;
 }
 
-/* Reads a WIM directory entry, including all alternate data stream entries that
- * follow it, from the WIM image's metadata resource.  */
+/* Read a dentry, including all extra stream entries that follow it, from an
+ * uncompressed metadata resource buffer.  */
 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;
        struct wim_dentry *dentry;
        struct wim_inode *inode;
        u16 short_name_nbytes;
-       u16 file_name_nbytes;
+       u16 name_nbytes;
        u64 calculated_size;
        int ret;
 
@@ -1217,22 +1403,14 @@ read_dentry(const u8 * restrict buf, size_t buf_len,
        /* Check for buffer overrun.  */
        if (unlikely(offset + sizeof(u64) > buf_len ||
                     offset + sizeof(u64) < offset))
-       {
-               ERROR("Directory entry starting at %"PRIu64" ends past the "
-                     "end of the metadata resource (size %zu)",
-                     offset, buf_len);
                return WIMLIB_ERR_INVALID_METADATA_RESOURCE;
-       }
 
        /* Get pointer to the dentry data.  */
        p = &buf[offset];
        disk_dentry = (const struct wim_dentry_on_disk*)p;
 
-       if (unlikely((uintptr_t)p & 7))
-               WARNING("WIM dentry is not 8-byte aligned");
-
        /* Get dentry length.  */
-       length = le64_to_cpu(disk_dentry->length);
+       length = ALIGN(le64_to_cpu(disk_dentry->length), 8);
 
        /* Check for end-of-directory.  */
        if (length <= 8) {
@@ -1241,83 +1419,57 @@ read_dentry(const u8 * restrict buf, size_t buf_len,
        }
 
        /* Validate dentry length.  */
-       if (unlikely(length < sizeof(struct wim_dentry_on_disk))) {
-               ERROR("Directory entry has invalid length of %"PRIu64" bytes",
-                     length);
+       if (unlikely(length < sizeof(struct wim_dentry_on_disk)))
                return WIMLIB_ERR_INVALID_METADATA_RESOURCE;
-       }
 
        /* Check for buffer overrun.  */
        if (unlikely(offset + length > buf_len ||
                     offset + length < offset))
-       {
-               ERROR("Directory entry at offset %"PRIu64" and with size "
-                     "%"PRIu64" ends past the end of the metadata resource "
-                     "(size %zu)", offset, length, buf_len);
                return WIMLIB_ERR_INVALID_METADATA_RESOURCE;
-       }
 
        /* Allocate new dentry structure, along with a preliminary inode.  */
-       ret = new_dentry_with_timeless_inode(T(""), &dentry);
+       ret = new_dentry_with_new_inode(NULL, false, &dentry);
        if (ret)
                return ret;
 
-       dentry->length = length;
        inode = dentry->d_inode;
 
        /* Read more fields: some into the dentry, and some into the inode.  */
        inode->i_attributes = le32_to_cpu(disk_dentry->attributes);
        inode->i_security_id = le32_to_cpu(disk_dentry->security_id);
-       dentry->subdir_offset = le64_to_cpu(disk_dentry->subdir_offset);
+       dentry->d_subdir_offset = le64_to_cpu(disk_dentry->subdir_offset);
        inode->i_creation_time = le64_to_cpu(disk_dentry->creation_time);
        inode->i_last_access_time = le64_to_cpu(disk_dentry->last_access_time);
        inode->i_last_write_time = le64_to_cpu(disk_dentry->last_write_time);
-       copy_hash(inode->i_hash, disk_dentry->unnamed_stream_hash);
+       inode->i_unknown_0x54 = le32_to_cpu(disk_dentry->unknown_0x54);
 
-       /* 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.  So we have some fields we read for reparse points, and
-        * some fields in the same place for non-reparse-points.  */
        if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
-               inode->i_rp_unknown_1 = le32_to_cpu(disk_dentry->reparse.rp_unknown_1);
                inode->i_reparse_tag = le32_to_cpu(disk_dentry->reparse.reparse_tag);
-               inode->i_rp_unknown_2 = le16_to_cpu(disk_dentry->reparse.rp_unknown_2);
-               inode->i_not_rpfixed = le16_to_cpu(disk_dentry->reparse.not_rpfixed);
-               /* Leave inode->i_ino at 0.  Note that this means the WIM file
-                * cannot archive hard-linked reparse points.  Such a thing
-                * doesn't really make sense anyway, although I believe it's
-                * theoretically possible to have them on NTFS.  */
+               inode->i_rp_reserved = le16_to_cpu(disk_dentry->reparse.rp_reserved);
+               inode->i_rp_flags = le16_to_cpu(disk_dentry->reparse.rp_flags);
+               /* Leave inode->i_ino at 0.  Note: this means that WIM cannot
+                * represent multiple hard links to a reparse point file.  */
        } else {
-               inode->i_rp_unknown_1 = le32_to_cpu(disk_dentry->nonreparse.rp_unknown_1);
                inode->i_ino = le64_to_cpu(disk_dentry->nonreparse.hard_link_group_id);
        }
-       inode->i_num_ads = le16_to_cpu(disk_dentry->num_alternate_data_streams);
 
        /* Now onto reading the names.  There are two of them: the (long) file
         * name, and the short name.  */
 
        short_name_nbytes = le16_to_cpu(disk_dentry->short_name_nbytes);
-       file_name_nbytes = le16_to_cpu(disk_dentry->file_name_nbytes);
+       name_nbytes = le16_to_cpu(disk_dentry->name_nbytes);
 
-       if (unlikely((short_name_nbytes & 1) | (file_name_nbytes & 1))) {
-               ERROR("Dentry name is not valid UTF-16 (odd number of bytes)!");
+       if (unlikely((short_name_nbytes & 1) | (name_nbytes & 1))) {
                ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE;
                goto err_free_dentry;
        }
 
        /* 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.
-        *
-        * 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);
-
-       if (unlikely(dentry->length < calculated_size)) {
-               ERROR("Unexpected end of directory entry! (Expected "
-                     "at least %"PRIu64" bytes, got %"PRIu64" bytes.)",
-                     calculated_size, dentry->length);
+        * the length of the dentry is large enough to actually hold them.  */
+       calculated_size = dentry_min_len_with_names(name_nbytes,
+                                                   short_name_nbytes);
+
+       if (unlikely(length < calculated_size)) {
                ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE;
                goto err_free_dentry;
        }
@@ -1327,56 +1479,47 @@ read_dentry(const u8 * restrict buf, size_t buf_len,
 
        /* Read the filename if present.  Note: if the filename is empty, there
         * is no null terminator following it.  */
-       if (file_name_nbytes) {
-               dentry->file_name = MALLOC(file_name_nbytes + 2);
-               if (dentry->file_name == NULL) {
+       if (name_nbytes) {
+               dentry->d_name = utf16le_dupz(p, name_nbytes);
+               if (unlikely(!dentry->d_name)) {
                        ret = WIMLIB_ERR_NOMEM;
                        goto err_free_dentry;
                }
-               dentry->file_name_nbytes = file_name_nbytes;
-               memcpy(dentry->file_name, p, file_name_nbytes);
-               p += file_name_nbytes + 2;
-               dentry->file_name[file_name_nbytes / 2] = cpu_to_le16(0);
+               dentry->d_name_nbytes = name_nbytes;
+               p += (u32)name_nbytes + 2;
        }
 
        /* Read the short filename if present.  Note: if there is no short
         * filename, there is no null terminator following it. */
        if (short_name_nbytes) {
-               dentry->short_name = MALLOC(short_name_nbytes + 2);
-               if (dentry->short_name == NULL) {
+               dentry->d_short_name = utf16le_dupz(p, short_name_nbytes);
+               if (unlikely(!dentry->d_short_name)) {
                        ret = WIMLIB_ERR_NOMEM;
                        goto err_free_dentry;
                }
-               dentry->short_name_nbytes = short_name_nbytes;
-               memcpy(dentry->short_name, p, short_name_nbytes);
-               p += short_name_nbytes + 2;
-               dentry->short_name[short_name_nbytes / 2] = cpu_to_le16(0);
+               dentry->d_short_name_nbytes = short_name_nbytes;
+               p += (u32)short_name_nbytes + 2;
        }
 
-       /* Align the dentry length.  */
-       dentry->length = (dentry->length + 7) & ~7;
+       /* Read extra data at end of dentry (but before extra stream entries).
+        * This may contain tagged metadata items.  */
+       ret = read_extra_data(p, &buf[offset + length], inode);
+       if (ret)
+               goto err_free_dentry;
 
-       /* 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
-        * metadata resource buffer.
-        *
-        * Note that each alternate data stream entry begins on an 8-byte
-        * 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)))
-               {
-                       ERROR("Failed to read alternate data stream "
-                             "entries of WIM dentry \"%"WS"\"",
-                             dentry->file_name);
-                       goto err_free_dentry;
-               }
-       }
+       offset += length;
 
+       /* Set up the inode's collection of streams.  */
+       ret = setup_inode_streams(&buf[offset],
+                                 &buf[buf_len],
+                                 inode,
+                                 le16_to_cpu(disk_dentry->num_extra_streams),
+                                 disk_dentry->default_hash,
+                                 &offset);
+       if (ret)
+               goto err_free_dentry;
+
+       *offset_p = offset;  /* Sets offset of next dentry in directory  */
        *dentry_ret = dentry;
        return 0;
 
@@ -1385,28 +1528,17 @@ err_free_dentry:
        return ret;
 }
 
-static const tchar *
-dentry_get_file_type_string(const struct wim_dentry *dentry)
-{
-       const struct wim_inode *inode = dentry->d_inode;
-       if (inode_is_directory(inode))
-               return T("directory");
-       else if (inode_is_symlink(inode))
-               return T("symbolic link");
-       else
-               return T("file");
-}
-
+/* Is the dentry named "." or ".." ?  */
 static bool
 dentry_is_dot_or_dotdot(const struct wim_dentry *dentry)
 {
-       if (dentry->file_name_nbytes <= 4) {
-               if (dentry->file_name_nbytes == 4) {
-                       if (dentry->file_name[0] == cpu_to_le16('.') &&
-                           dentry->file_name[1] == cpu_to_le16('.'))
+       if (dentry->d_name_nbytes <= 4) {
+               if (dentry->d_name_nbytes == 4) {
+                       if (dentry->d_name[0] == cpu_to_le16('.') &&
+                           dentry->d_name[1] == cpu_to_le16('.'))
                                return true;
-               } else if (dentry->file_name_nbytes == 2) {
-                       if (dentry->file_name[0] == cpu_to_le16('.'))
+               } else if (dentry->d_name_nbytes == 2) {
+                       if (dentry->d_name[0] == cpu_to_le16('.'))
                                return true;
                }
        }
@@ -1417,14 +1549,14 @@ static int
 read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len,
                           struct wim_dentry * restrict dir)
 {
-       u64 cur_offset = dir->subdir_offset;
+       u64 cur_offset = dir->d_subdir_offset;
 
        /* 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)) {
+               if (unlikely(d->d_subdir_offset == cur_offset)) {
                        ERROR("Cyclic directory structure detected: children "
                              "of \"%"TS"\" coincide with children of \"%"TS"\"",
                              dentry_full_path(dir), dentry_full_path(d));
@@ -1438,7 +1570,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;
 
@@ -1446,13 +1578,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 "
@@ -1475,21 +1600,17 @@ read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len,
                        /* We already found a dentry with this same
                         * case-sensitive long name.  Only keep the first one.
                         */
-                       const tchar *child_type, *duplicate_type;
-                       child_type = dentry_get_file_type_string(child);
-                       duplicate_type = dentry_get_file_type_string(duplicate);
-                       WARNING("Ignoring duplicate %"TS" \"%"TS"\" "
-                               "(the WIM image already contains a %"TS" "
+                       WARNING("Ignoring duplicate file \"%"TS"\" "
+                               "(the WIM image already contains a file "
                                "at that path with the exact same name)",
-                               child_type, dentry_full_path(duplicate),
-                               duplicate_type);
+                               dentry_full_path(duplicate));
                        free_dentry(child);
                        continue;
                }
 
                /* If this child is a directory that itself has children, call
                 * this procedure recursively.  */
-               if (child->subdir_offset != 0) {
+               if (child->d_subdir_offset != 0) {
                        if (likely(dentry_is_directory(child))) {
                                ret = read_dentry_tree_recursive(buf,
                                                                 buf_len,
@@ -1506,7 +1627,7 @@ read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len,
 }
 
 /*
- * Read a tree of dentries (directory entries) from a WIM metadata resource.
+ * Read a tree of dentries from a WIM metadata resource.
  *
  * @buf:
  *     Buffer containing an uncompressed WIM metadata resource.
@@ -1536,7 +1657,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;
 
@@ -1546,12 +1667,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))) {
@@ -1560,7 +1676,7 @@ read_dentry_tree(const u8 *buf, size_t buf_len,
                        goto err_free_dentry_tree;
                }
 
-               if (likely(root->subdir_offset != 0)) {
+               if (likely(root->d_subdir_offset != 0)) {
                        ret = read_dentry_tree_recursive(buf, buf_len, root);
                        if (ret)
                                goto err_free_dentry_tree;
@@ -1577,46 +1693,45 @@ err_free_dentry_tree:
        return ret;
 }
 
-/*
- * Writes a WIM alternate data stream (ADS) entry to an output buffer.
- *
- * @ads_entry:  The ADS entry structure.
- * @hash:       The hash field to use (instead of the one in the ADS entry).
- * @p:          The memory location to write the data to.
- *
- * Returns a pointer to the byte after the last byte written.
- */
 static u8 *
-write_ads_entry(const struct wim_ads_entry *ads_entry,
-               const u8 *hash, u8 * restrict p)
+write_extra_stream_entry(u8 * restrict p, const utf16lechar * restrict name,
+                        const u8 * restrict hash)
 {
-       struct wim_ads_entry_on_disk *disk_ads_entry =
-                       (struct wim_ads_entry_on_disk*)p;
+       struct wim_extra_stream_entry_on_disk *disk_strm =
+                       (struct wim_extra_stream_entry_on_disk *)p;
        u8 *orig_p = p;
+       size_t name_nbytes;
 
-       disk_ads_entry->reserved = cpu_to_le64(ads_entry->reserved);
-       copy_hash(disk_ads_entry->hash, hash);
-       disk_ads_entry->stream_name_nbytes = cpu_to_le16(ads_entry->stream_name_nbytes);
-       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);
-       }
+       if (name == NO_STREAM_NAME)
+               name_nbytes = 0;
+       else
+               name_nbytes = utf16le_len_bytes(name);
+
+       disk_strm->reserved = 0;
+       copy_hash(disk_strm->hash, hash);
+       disk_strm->name_nbytes = cpu_to_le16(name_nbytes);
+       p += sizeof(struct wim_extra_stream_entry_on_disk);
+       if (name_nbytes != 0)
+               p = mempcpy(p, name, name_nbytes + 2);
        /* Align to 8-byte boundary */
        while ((uintptr_t)p & 7)
                *p++ = 0;
-       disk_ads_entry->length = cpu_to_le64(p - orig_p);
+       disk_strm->length = cpu_to_le64(p - orig_p);
        return p;
 }
 
 /*
- * Writes a WIM dentry to an output buffer.
+ * Write a WIM dentry to an output buffer.
+ *
+ * This includes any extra stream entries that may follow the dentry itself.
+ *
+ * @dentry:
+ *     The dentry to write.
  *
- * @dentry:  The dentry structure.
- * @p:       The memory location to write the data to.
+ * @p:
+ *     The memory location to which to write the data.
  *
- * Returns the pointer to the byte after the last byte we wrote as part of the
- * dentry, including any alternate data stream entries.
+ * Returns a pointer to the byte following the last written.
  */
 static u8 *
 write_dentry(const struct wim_dentry * restrict dentry, u8 * restrict p)
@@ -1624,76 +1739,128 @@ write_dentry(const struct wim_dentry * restrict dentry, u8 * restrict p)
        const struct wim_inode *inode;
        struct wim_dentry_on_disk *disk_dentry;
        const u8 *orig_p;
-       const u8 *hash;
-       bool use_dummy_stream;
-       u16 num_ads;
 
        wimlib_assert(((uintptr_t)p & 7) == 0); /* 8 byte aligned */
        orig_p = p;
 
        inode = dentry->d_inode;
-       use_dummy_stream = inode_needs_dummy_stream(inode);
        disk_dentry = (struct wim_dentry_on_disk*)p;
 
        disk_dentry->attributes = cpu_to_le32(inode->i_attributes);
        disk_dentry->security_id = cpu_to_le32(inode->i_security_id);
-       disk_dentry->subdir_offset = cpu_to_le64(dentry->subdir_offset);
+       disk_dentry->subdir_offset = cpu_to_le64(dentry->d_subdir_offset);
+
        disk_dentry->unused_1 = cpu_to_le64(0);
        disk_dentry->unused_2 = cpu_to_le64(0);
+
        disk_dentry->creation_time = cpu_to_le64(inode->i_creation_time);
        disk_dentry->last_access_time = cpu_to_le64(inode->i_last_access_time);
        disk_dentry->last_write_time = cpu_to_le64(inode->i_last_write_time);
-       if (use_dummy_stream)
-               hash = zero_hash;
-       else
-               hash = inode_stream_hash(inode, 0);
-       copy_hash(disk_dentry->unnamed_stream_hash, hash);
+       disk_dentry->unknown_0x54 = cpu_to_le32(inode->i_unknown_0x54);
        if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
-               disk_dentry->reparse.rp_unknown_1 = cpu_to_le32(inode->i_rp_unknown_1);
                disk_dentry->reparse.reparse_tag = cpu_to_le32(inode->i_reparse_tag);
-               disk_dentry->reparse.rp_unknown_2 = cpu_to_le16(inode->i_rp_unknown_2);
-               disk_dentry->reparse.not_rpfixed = cpu_to_le16(inode->i_not_rpfixed);
+               disk_dentry->reparse.rp_reserved = cpu_to_le16(inode->i_rp_reserved);
+               disk_dentry->reparse.rp_flags = cpu_to_le16(inode->i_rp_flags);
        } else {
-               disk_dentry->nonreparse.rp_unknown_1 = cpu_to_le32(inode->i_rp_unknown_1);
                disk_dentry->nonreparse.hard_link_group_id =
                        cpu_to_le64((inode->i_nlink == 1) ? 0 : inode->i_ino);
        }
-       num_ads = inode->i_num_ads;
-       if (use_dummy_stream)
-               num_ads++;
-       disk_dentry->num_alternate_data_streams = cpu_to_le16(num_ads);
-       disk_dentry->short_name_nbytes = cpu_to_le16(dentry->short_name_nbytes);
-       disk_dentry->file_name_nbytes = cpu_to_le16(dentry->file_name_nbytes);
+
+       disk_dentry->short_name_nbytes = cpu_to_le16(dentry->d_short_name_nbytes);
+       disk_dentry->name_nbytes = cpu_to_le16(dentry->d_name_nbytes);
        p += sizeof(struct wim_dentry_on_disk);
 
        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->d_name, (u32)dentry->d_name_nbytes + 2);
 
        if (dentry_has_short_name(dentry))
-               p = mempcpy(p, dentry->short_name, dentry->short_name_nbytes + 2);
+               p = mempcpy(p, dentry->d_short_name, (u32)dentry->d_short_name_nbytes + 2);
 
        /* Align to 8-byte boundary */
        while ((uintptr_t)p & 7)
                *p++ = 0;
 
-       /* We calculate the correct length of the dentry ourselves because the
-        * dentry->length field may been set to an unexpected value from when we
-        * read the dentry in (for example, there may have been unknown data
-        * appended to the end of the dentry...).  Furthermore, the dentry may
-        * have been renamed, thus changing its needed length. */
-       disk_dentry->length = cpu_to_le64(p - orig_p);
+       if (inode->i_extra_size) {
+               /* Extra tagged items --- not usually present.  */
+               p = mempcpy(p, inode->i_extra, inode->i_extra_size);
 
-       if (use_dummy_stream) {
-               hash = inode_unnamed_stream_hash(inode);
-               p = write_ads_entry(&(struct wim_ads_entry){}, hash, p);
+               /* Align to 8-byte boundary */
+               while ((uintptr_t)p & 7)
+                       *p++ = 0;
        }
 
-       /* Write the alternate data streams entries, if any. */
-       for (u16 i = 0; i < inode->i_num_ads; i++) {
-               hash = inode_stream_hash(inode, i + 1);
-               p = write_ads_entry(&inode->i_ads_entries[i], hash, p);
+       disk_dentry->length = cpu_to_le64(p - orig_p);
+
+       /* Streams  */
+
+       if (unlikely(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED)) {
+               const struct wim_inode_stream *efs_strm;
+               const u8 *efs_hash;
+
+               efs_strm = inode_get_unnamed_stream(inode, STREAM_TYPE_EFSRPC_RAW_DATA);
+               efs_hash = efs_strm ? stream_hash(efs_strm) : zero_hash;
+               copy_hash(disk_dentry->default_hash, efs_hash);
+               disk_dentry->num_extra_streams = cpu_to_le16(0);
+       } else {
+               /*
+                * Extra stream entries:
+                *
+                * - Use one extra stream entry for each named data stream
+                * - Use one extra stream entry for the unnamed data stream when there is either:
+                *      - a reparse point stream
+                *      - at least one named data stream (for Windows PE bug workaround)
+                * - Use one extra stream entry for the reparse point stream if there is one
+                */
+               bool have_named_data_stream = false;
+               bool have_reparse_point_stream = false;
+               const u8 *unnamed_data_stream_hash = zero_hash;
+               const u8 *reparse_point_hash;
+               for (unsigned i = 0; i < inode->i_num_streams; i++) {
+                       const struct wim_inode_stream *strm = &inode->i_streams[i];
+                       if (strm->stream_type == STREAM_TYPE_DATA) {
+                               if (stream_is_named(strm))
+                                       have_named_data_stream = true;
+                               else
+                                       unnamed_data_stream_hash = stream_hash(strm);
+                       } else if (strm->stream_type == STREAM_TYPE_REPARSE_POINT) {
+                               have_reparse_point_stream = true;
+                               reparse_point_hash = stream_hash(strm);
+                       }
+               }
+
+               if (unlikely(have_reparse_point_stream || have_named_data_stream)) {
+
+                       unsigned num_extra_streams = 0;
+
+                       copy_hash(disk_dentry->default_hash, zero_hash);
+
+                       if (have_reparse_point_stream) {
+                               p = write_extra_stream_entry(p, NO_STREAM_NAME,
+                                                            reparse_point_hash);
+                               num_extra_streams++;
+                       }
+
+                       p = write_extra_stream_entry(p, NO_STREAM_NAME,
+                                                    unnamed_data_stream_hash);
+                       num_extra_streams++;
+
+                       for (unsigned i = 0; i < inode->i_num_streams; i++) {
+                               const struct wim_inode_stream *strm = &inode->i_streams[i];
+                               if (stream_is_named_data_stream(strm)) {
+                                       p = write_extra_stream_entry(p, strm->stream_name,
+                                                                    stream_hash(strm));
+                                       num_extra_streams++;
+                               }
+                       }
+                       wimlib_assert(num_extra_streams <= 0xFFFF);
+
+                       disk_dentry->num_extra_streams = cpu_to_le16(num_extra_streams);
+               } else {
+                       copy_hash(disk_dentry->default_hash, unnamed_data_stream_hash);
+                       disk_dentry->num_extra_streams = cpu_to_le16(0);
+               }
        }
 
        return p;
@@ -1702,7 +1869,7 @@ write_dentry(const struct wim_dentry * restrict dentry, u8 * restrict p)
 static int
 write_dir_dentries(struct wim_dentry *dir, void *_pp)
 {
-       if (dir->subdir_offset != 0) {
+       if (dir->d_subdir_offset != 0) {
                u8 **pp = _pp;
                u8 *p = *pp;
                struct wim_dentry *child;
@@ -1719,18 +1886,26 @@ write_dir_dentries(struct wim_dentry *dir, void *_pp)
        return 0;
 }
 
-/* Writes a directory tree to the metadata resource.
+/*
+ * Write a directory tree to the metadata resource.
+ *
+ * @root:
+ *     The root of a dentry tree on which calculate_subdir_offsets() has been
+ *     called.  This cannot be NULL; if the dentry tree is empty, the caller is
+ *     expected to first generate a dummy root directory.
  *
- * @root:      Root of the dentry tree.
- * @p:         Pointer to a buffer with enough space for the dentry tree.
+ * @p:
+ *     Pointer to a buffer with enough space for the dentry tree.  This size
+ *     must have been obtained by calculate_subdir_offsets().
  *
- * Returns pointer to the byte after the last byte we wrote.
+ * Returns a pointer to the byte following the last written.
  */
 u8 *
 write_dentry_tree(struct wim_dentry *root, u8 *p)
 {
        DEBUG("Writing dentry tree.");
-       wimlib_assert(dentry_is_root(root));
+
+       wimlib_assert(root != NULL);
 
        /* write root dentry and end-of-directory entry following it */
        p = write_dentry(root, p);