+/* Frees an inode. */
+void
+free_inode(struct wim_inode *inode)
+{
+ if (inode) {
+ if (inode->i_ads_entries) {
+ for (u16 i = 0; i < inode->i_num_ads; i++)
+ destroy_ads_entry(&inode->i_ads_entries[i]);
+ FREE(inode->i_ads_entries);
+ }
+ /* HACK: This may instead delete the inode from i_list, but the
+ * hlist_del() behaves the same as list_del(). */
+ if (!hlist_unhashed(&inode->i_hlist))
+ hlist_del(&inode->i_hlist);
+ FREE(inode);
+ }
+}
+
+/* Decrements link count on an inode and frees it if the link count reaches 0.
+ * */
+static void
+put_inode(struct wim_inode *inode)
+{
+ wimlib_assert(inode->i_nlink != 0);
+ if (--inode->i_nlink == 0) {
+ #ifdef WITH_FUSE
+ if (inode->i_num_opened_fds == 0)
+ #endif
+ {
+ free_inode(inode);
+ }
+ }
+}
+
+/* Frees a WIM dentry.
+ *
+ * The corresponding inode (if any) is freed only if its link count is
+ * decremented to 0.
+ */
+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);
+ 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)
+{
+ 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;
+
+ lte = inode_stream_lte(inode, i, lookup_table);
+ if (lte)
+ lte_decrement_refcnt(lte, lookup_table);
+ }
+ }
+ free_dentry(dentry);
+ return 0;
+}
+
+/*
+ * Unlinks and frees a dentry tree.
+ *
+ * @root:
+ * The root of the tree.
+ *
+ * @lookup_table:
+ * The lookup table for dentries. If non-NULL, the reference counts in the
+ * lookup table for the lookup table entries corresponding to the dentries
+ * will be decremented.
+ */
+void
+free_dentry_tree(struct wim_dentry *root, struct wim_lookup_table *lookup_table)
+{
+ for_dentry_in_tree_depth(root, do_free_dentry, lookup_table);
+}
+
+#ifdef __WIN32__
+
+/* Insert a dentry into the case insensitive index for a directory.
+ *
+ * This is a red-black tree, but when multiple dentries share the same
+ * case-insensitive name, only one is inserted into the tree itself; the rest
+ * are connected in a list.
+ */
+static struct wim_dentry *
+dentry_add_child_case_insensitive(struct wim_dentry *parent,
+ struct wim_dentry *child)
+{
+ struct rb_root *root;
+ struct rb_node **new;
+ struct rb_node *rb_parent;
+
+ root = &parent->d_inode->i_children_case_insensitive;
+ new = &root->rb_node;
+ rb_parent = NULL;
+ while (*new) {
+ struct wim_dentry *this = container_of(*new, struct wim_dentry,
+ rb_node_case_insensitive);
+ int result = dentry_compare_names_case_insensitive(child, this);
+
+ rb_parent = *new;
+
+ if (result < 0)
+ new = &((*new)->rb_left);
+ else if (result > 0)
+ new = &((*new)->rb_right);
+ else
+ return this;
+ }
+ rb_link_node(&child->rb_node_case_insensitive, rb_parent, new);
+ rb_insert_color(&child->rb_node_case_insensitive, root);
+ return NULL;
+}
+#endif
+
+/*
+ * Links a dentry into the directory tree.
+ *
+ * @parent: The dentry that will be the parent of @child.
+ * @child: The dentry to link.
+ *
+ * Returns NULL if successful. If @parent already contains a dentry with the
+ * same case-sensitive name as @child, the pointer to this duplicate dentry is
+ * returned.
+ */
+struct wim_dentry *
+dentry_add_child(struct wim_dentry * restrict parent,
+ struct wim_dentry * restrict child)
+{
+ struct rb_root *root;
+ struct rb_node **new;
+ struct rb_node *rb_parent;
+
+ wimlib_assert(dentry_is_directory(parent));
+ wimlib_assert(parent != child);
+
+ /* Case sensitive child dentry index */
+ root = &parent->d_inode->i_children;
+ new = &root->rb_node;
+ rb_parent = NULL;
+ while (*new) {
+ struct wim_dentry *this = rbnode_dentry(*new);
+ int result = dentry_compare_names_case_sensitive(child, this);
+
+ rb_parent = *new;
+
+ if (result < 0)
+ new = &((*new)->rb_left);
+ else if (result > 0)
+ new = &((*new)->rb_right);
+ else
+ return this;
+ }
+ child->parent = parent;
+ rb_link_node(&child->rb_node, rb_parent, new);
+ rb_insert_color(&child->rb_node, root);
+
+#ifdef __WIN32__
+ {
+ struct wim_dentry *existing;
+ existing = dentry_add_child_case_insensitive(parent, child);
+ if (existing) {
+ list_add(&child->case_insensitive_conflict_list,
+ &existing->case_insensitive_conflict_list);
+ child->rb_node_case_insensitive.__rb_parent_color = 0;
+ } else {
+ INIT_LIST_HEAD(&child->case_insensitive_conflict_list);
+ }
+ }
+#endif
+ return NULL;
+}
+
+/* Unlink a WIM dentry from the directory entry tree. */
+void
+unlink_dentry(struct wim_dentry *dentry)
+{
+ struct wim_dentry *parent = dentry->parent;
+
+ if (parent == dentry)
+ return;
+ rb_erase(&dentry->rb_node, &parent->d_inode->i_children);
+#ifdef __WIN32__
+ if (dentry->rb_node_case_insensitive.__rb_parent_color) {
+ /* This dentry was in the case-insensitive red-black tree. */
+ rb_erase(&dentry->rb_node_case_insensitive,
+ &parent->d_inode->i_children_case_insensitive);
+ if (!list_empty(&dentry->case_insensitive_conflict_list)) {
+ /* Make a different case-insensitively-the-same dentry
+ * be the "representative" in the red-black tree. */
+ struct list_head *next;
+ struct wim_dentry *other;
+ struct wim_dentry *existing;
+
+ next = dentry->case_insensitive_conflict_list.next;
+ other = list_entry(next, struct wim_dentry, case_insensitive_conflict_list);
+ existing = dentry_add_child_case_insensitive(parent, other);
+ wimlib_assert(existing == NULL);
+ }
+ }
+ list_del(&dentry->case_insensitive_conflict_list);
+#endif
+}
+
+/*
+ * Returns the alternate data stream entry belonging to @inode that has the
+ * stream name @stream_name.
+ */
+struct wim_ads_entry *
+inode_get_ads_entry(struct wim_inode *inode, const tchar *stream_name,
+ u16 *idx_ret)
+{
+ if (inode->i_num_ads == 0) {
+ return NULL;
+ } else {
+ size_t stream_name_utf16le_nbytes;
+ u16 i;
+ struct wim_ads_entry *result;
+
+ #if TCHAR_IS_UTF16LE
+ const utf16lechar *stream_name_utf16le;
+
+ stream_name_utf16le = stream_name;
+ stream_name_utf16le_nbytes = tstrlen(stream_name) * sizeof(tchar);
+ #else
+ utf16lechar *stream_name_utf16le;
+
+ {
+ int ret = tstr_to_utf16le(stream_name,
+ tstrlen(stream_name) *
+ sizeof(tchar),
+ &stream_name_utf16le,
+ &stream_name_utf16le_nbytes);
+ if (ret)
+ return NULL;
+ }
+ #endif
+ i = 0;
+ result = NULL;
+ do {
+ if (ads_entry_has_name(&inode->i_ads_entries[i],
+ stream_name_utf16le,
+ stream_name_utf16le_nbytes))
+ {
+ if (idx_ret)
+ *idx_ret = i;
+ result = &inode->i_ads_entries[i];
+ break;
+ }
+ } while (++i != inode->i_num_ads);
+ #if !TCHAR_IS_UTF16LE
+ FREE(stream_name_utf16le);
+ #endif
+ return result;
+ }
+}
+
+static struct wim_ads_entry *
+do_inode_add_ads(struct wim_inode *inode, const void *stream_name,
+ size_t stream_name_nbytes, bool is_utf16le)
+{
+ u16 num_ads;
+ struct wim_ads_entry *ads_entries;
+ struct wim_ads_entry *new_entry;
+
+ if (inode->i_num_ads >= 0xfffe) {
+ ERROR("Too many alternate data streams in one inode!");
+ return NULL;
+ }
+ num_ads = inode->i_num_ads + 1;
+ ads_entries = REALLOC(inode->i_ads_entries,
+ num_ads * sizeof(inode->i_ads_entries[0]));
+ if (!ads_entries) {
+ ERROR("Failed to allocate memory for new alternate data stream");
+ return NULL;
+ }
+ inode->i_ads_entries = ads_entries;
+
+ new_entry = &inode->i_ads_entries[num_ads - 1];
+ if (init_ads_entry(new_entry, stream_name, stream_name_nbytes, is_utf16le))
+ return NULL;
+ new_entry->stream_id = inode->i_next_stream_id++;
+ inode->i_num_ads = num_ads;
+ return new_entry;
+}
+
+struct wim_ads_entry *
+inode_add_ads_utf16le(struct wim_inode *inode,
+ const utf16lechar *stream_name,
+ size_t stream_name_nbytes)
+{
+ DEBUG("Add alternate data stream \"%"WS"\"", stream_name);
+ return do_inode_add_ads(inode, stream_name, stream_name_nbytes, true);
+}
+
+/*
+ * Add an alternate stream entry to a WIM inode and return a pointer to it, or
+ * NULL if memory could not be allocated.
+ */
+struct wim_ads_entry *
+inode_add_ads(struct wim_inode *inode, const tchar *stream_name)
+{
+ DEBUG("Add alternate data stream \"%"TS"\"", stream_name);
+ return do_inode_add_ads(inode, stream_name,
+ tstrlen(stream_name) * sizeof(tchar),
+ TCHAR_IS_UTF16LE);
+}
+
+static struct wim_lookup_table_entry *
+add_stream_from_data_buffer(const void *buffer, size_t size,
+ struct wim_lookup_table *lookup_table)
+{
+ u8 hash[SHA1_HASH_SIZE];
+ struct wim_lookup_table_entry *lte, *existing_lte;
+
+ sha1_buffer(buffer, size, hash);
+ existing_lte = lookup_resource(lookup_table, hash);
+ if (existing_lte) {
+ wimlib_assert(wim_resource_size(existing_lte) == size);
+ lte = existing_lte;
+ lte->refcnt++;
+ } else {
+ void *buffer_copy;
+ lte = new_lookup_table_entry();
+ if (!lte)
+ return NULL;
+ buffer_copy = memdup(buffer, size);
+ if (!buffer_copy) {
+ free_lookup_table_entry(lte);
+ return NULL;
+ }
+ lte->resource_location = RESOURCE_IN_ATTACHED_BUFFER;
+ lte->attached_buffer = buffer_copy;
+ lte->resource_entry.original_size = size;
+ copy_hash(lte->hash, hash);
+ lookup_table_insert(lookup_table, lte);
+ }
+ return lte;
+}
+
+int
+inode_add_ads_with_data(struct wim_inode *inode, const tchar *name,
+ const void *value, size_t size,
+ struct wim_lookup_table *lookup_table)
+{
+ struct wim_ads_entry *new_ads_entry;
+
+ wimlib_assert(inode->i_resolved);
+
+ new_ads_entry = inode_add_ads(inode, name);
+ if (!new_ads_entry)
+ return WIMLIB_ERR_NOMEM;
+
+ new_ads_entry->lte = add_stream_from_data_buffer(value, size,
+ lookup_table);
+ if (!new_ads_entry->lte) {
+ inode_remove_ads(inode, new_ads_entry - inode->i_ads_entries,
+ lookup_table);
+ return WIMLIB_ERR_NOMEM;
+ }
+ return 0;
+}
+
+bool
+inode_has_named_stream(const struct wim_inode *inode)
+{
+ for (u16 i = 0; i < inode->i_num_ads; i++)
+ if (ads_entry_is_named_stream(&inode->i_ads_entries[i]))
+ return true;
+ return false;
+}
+
+/* Set the unnamed stream of a WIM inode, given a data buffer containing the
+ * stream contents. */
+int
+inode_set_unnamed_stream(struct wim_inode *inode, const void *data, size_t len,
+ struct wim_lookup_table *lookup_table)
+{
+ inode->i_lte = add_stream_from_data_buffer(data, len, lookup_table);
+ if (!inode->i_lte)
+ return WIMLIB_ERR_NOMEM;
+ inode->i_resolved = 1;
+ return 0;
+}
+
+/* Remove an alternate data stream from a WIM inode */
+void
+inode_remove_ads(struct wim_inode *inode, u16 idx,
+ struct wim_lookup_table *lookup_table)
+{
+ struct wim_ads_entry *ads_entry;
+ struct wim_lookup_table_entry *lte;
+
+ wimlib_assert(idx < inode->i_num_ads);
+ wimlib_assert(inode->i_resolved);
+
+ ads_entry = &inode->i_ads_entries[idx];
+
+ DEBUG("Remove alternate data stream \"%"WS"\"", ads_entry->stream_name);
+
+ lte = ads_entry->lte;
+ if (lte)
+ lte_decrement_refcnt(lte, lookup_table);
+
+ destroy_ads_entry(ads_entry);
+
+ memmove(&inode->i_ads_entries[idx],
+ &inode->i_ads_entries[idx + 1],
+ (inode->i_num_ads - idx - 1) * sizeof(inode->i_ads_entries[0]));
+ inode->i_num_ads--;
+}
+
+bool
+inode_has_unix_data(const struct wim_inode *inode)
+{
+ for (u16 i = 0; i < inode->i_num_ads; i++)
+ if (ads_entry_is_unix_data(&inode->i_ads_entries[i]))
+ return true;
+ return false;
+}
+
+#ifndef __WIN32__
+int
+inode_get_unix_data(const struct wim_inode *inode,
+ struct wimlib_unix_data *unix_data,
+ u16 *stream_idx_ret)
+{
+ const struct wim_ads_entry *ads_entry;
+ const struct wim_lookup_table_entry *lte;
+ size_t size;
+ int ret;
+
+ wimlib_assert(inode->i_resolved);
+
+ ads_entry = inode_get_ads_entry((struct wim_inode*)inode,
+ WIMLIB_UNIX_DATA_TAG, NULL);
+ if (!ads_entry)
+ return NO_UNIX_DATA;
+
+ if (stream_idx_ret)
+ *stream_idx_ret = ads_entry - inode->i_ads_entries;
+
+ lte = ads_entry->lte;
+ if (!lte)
+ return NO_UNIX_DATA;
+
+ size = wim_resource_size(lte);
+ if (size != sizeof(struct wimlib_unix_data))
+ return BAD_UNIX_DATA;
+
+ ret = read_full_resource_into_buf(lte, unix_data);
+ if (ret)
+ return ret;
+
+ if (unix_data->version != 0)
+ return BAD_UNIX_DATA;
+ return 0;
+}
+
+int
+inode_set_unix_data(struct wim_inode *inode, uid_t uid, gid_t gid, mode_t mode,
+ struct wim_lookup_table *lookup_table, int which)
+{
+ struct wimlib_unix_data unix_data;
+ int ret;
+ bool have_good_unix_data = false;
+ bool have_unix_data = false;
+ u16 stream_idx;
+
+ if (!(which & UNIX_DATA_CREATE)) {
+ ret = inode_get_unix_data(inode, &unix_data, &stream_idx);
+ if (ret == 0 || ret == BAD_UNIX_DATA || ret > 0)
+ have_unix_data = true;
+ if (ret == 0)
+ have_good_unix_data = true;
+ }
+ unix_data.version = 0;
+ if (which & UNIX_DATA_UID || !have_good_unix_data)
+ unix_data.uid = uid;
+ if (which & UNIX_DATA_GID || !have_good_unix_data)
+ unix_data.gid = gid;
+ if (which & UNIX_DATA_MODE || !have_good_unix_data)
+ unix_data.mode = mode;
+ ret = inode_add_ads_with_data(inode, WIMLIB_UNIX_DATA_TAG,
+ &unix_data,
+ sizeof(struct wimlib_unix_data),
+ lookup_table);
+ if (ret == 0 && have_unix_data)
+ inode_remove_ads(inode, stream_idx, lookup_table);
+ return ret;
+}
+#endif /* !__WIN32__ */
+
+/*
+ * Reads the alternate data stream entries of a WIM dentry.
+ *
+ * @p:
+ * Pointer to buffer that starts with the first alternate stream entry.
+ *
+ * @inode:
+ * Inode to load the alternate data streams into. @inode->i_num_ads must
+ * have been set to the number of alternate data streams that are expected.
+ *
+ * @remaining_size:
+ * Number of bytes of data remaining in the buffer pointed to by @p.
+ *
+ * On success, inode->i_ads_entries is set to an array of `struct
+ * wim_ads_entry's of length inode->i_num_ads. On failure, @inode is not
+ * modified.
+ *
+ * Return values:
+ * WIMLIB_ERR_SUCCESS (0)
+ * WIMLIB_ERR_INVALID_METADATA_RESOURCE
+ * WIMLIB_ERR_NOMEM
+ */
+static int
+read_ads_entries(const u8 * restrict p, struct wim_inode * restrict inode,
+ size_t nbytes_remaining)
+{
+ u16 num_ads;
+ struct wim_ads_entry *ads_entries;
+ int ret;
+
+ BUILD_BUG_ON(sizeof(struct wim_ads_entry_on_disk) != WIM_ADS_ENTRY_DISK_SIZE);
+
+ /* Allocate an array for our in-memory representation of the alternate
+ * data stream entries. */
+ num_ads = inode->i_num_ads;
+ ads_entries = CALLOC(num_ads, sizeof(inode->i_ads_entries[0]));
+ if (!ads_entries)
+ goto out_of_memory;
+
+ /* Read the entries into our newly allocated buffer. */
+ for (u16 i = 0; i < num_ads; i++) {
+ u64 length;
+ struct wim_ads_entry *cur_entry;
+ const struct wim_ads_entry_on_disk *disk_entry =
+ (const struct wim_ads_entry_on_disk*)p;
+
+ cur_entry = &ads_entries[i];
+ ads_entries[i].stream_id = i + 1;
+
+ /* Do we have at least the size of the fixed-length data we know
+ * need? */
+ if (nbytes_remaining < sizeof(struct wim_ads_entry_on_disk))
+ goto out_invalid;
+
+ /* Read the length field */
+ length = le64_to_cpu(disk_entry->length);
+
+ /* 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_ads_entry_on_disk) ||
+ length > nbytes_remaining)
+ goto out_invalid;
+
+ /* Read the rest of the fixed-length data. */
+
+ cur_entry->reserved = le64_to_cpu(disk_entry->reserved);
+ copy_hash(cur_entry->hash, disk_entry->hash);
+ cur_entry->stream_name_nbytes = le16_to_cpu(disk_entry->stream_name_nbytes);
+
+ /* If stream_name_nbytes != 0, this is a named stream.
+ * Otherwise this is an unnamed stream, or in some cases (bugs
+ * in Microsoft's software I guess) a meaningless entry
+ * distinguished from the real unnamed stream entry, if any, by
+ * the fact that the real unnamed stream entry has a nonzero
+ * hash field. */
+ if (cur_entry->stream_name_nbytes) {
+ /* 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 (cur_entry->stream_name_nbytes & 1)
+ goto out_invalid;
+
+ /* 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_ads_entry_on_disk) +
+ cur_entry->stream_name_nbytes > length)
+ goto out_invalid;
+
+ cur_entry->stream_name = MALLOC(cur_entry->stream_name_nbytes + 2);
+ if (!cur_entry->stream_name)
+ goto out_of_memory;
+
+ memcpy(cur_entry->stream_name,
+ disk_entry->stream_name,
+ cur_entry->stream_name_nbytes);
+ cur_entry->stream_name[cur_entry->stream_name_nbytes / 2] = cpu_to_le16(0);
+ }
+
+ /* It's expected that the size of every ADS entry is a multiple
+ * of 8. However, to be safe, I'm allowing the possibility of
+ * an ADS entry at the very end of the metadata resource ending
+ * un-aligned. So although we still need to increment the input
+ * pointer by @length to reach the next ADS entry, it's possible
+ * that less than @length is actually remaining in the metadata
+ * resource. We should set the remaining bytes to 0 if this
+ * happens. */
+ length = (length + 7) & ~(u64)7;
+ p += length;
+ if (nbytes_remaining < length)
+ nbytes_remaining = 0;
+ else
+ nbytes_remaining -= length;
+ }
+ inode->i_ads_entries = ads_entries;
+ inode->i_next_stream_id = inode->i_num_ads + 1;
+ ret = 0;
+ goto out;
+out_of_memory:
+ ret = WIMLIB_ERR_NOMEM;
+ goto out_free_ads_entries;
+out_invalid:
+ ERROR("An alternate data stream entry is invalid");
+ ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE;
+out_free_ads_entries:
+ if (ads_entries) {
+ for (u16 i = 0; i < num_ads; i++)
+ destroy_ads_entry(&ads_entries[i]);
+ FREE(ads_entries);
+ }
+out:
+ return ret;
+}
+
+/*
+ * Reads a WIM directory entry, including all alternate data stream entries that
+ * follow it, from the WIM image's metadata resource.
+ *
+ * @metadata_resource:
+ * Pointer to the metadata resource buffer.
+ *
+ * @metadata_resource_len:
+ * Length of the metadata resource buffer, in bytes.
+ *
+ * @offset: Offset of the dentry within the metadata resource.
+ *
+ * @dentry: A `struct wim_dentry' that will be filled in by this function.
+ *
+ * Return 0 on success or nonzero on failure. On failure, @dentry will have
+ * been modified, but it will not be left with pointers to any allocated
+ * buffers. On success, the dentry->length field must be examined. If zero,
+ * this was a special "end of directory" dentry and not a real dentry. If
+ * nonzero, this was a real dentry.
+ *
+ * Return values:
+ * WIMLIB_ERR_SUCCESS (0)
+ * WIMLIB_ERR_INVALID_METADATA_RESOURCE
+ * WIMLIB_ERR_NOMEM
+ */
+int
+read_dentry(const u8 * restrict metadata_resource, u64 metadata_resource_len,
+ u64 offset, struct wim_dentry * restrict dentry)
+{
+
+ u64 calculated_size;
+ utf16lechar *file_name;
+ utf16lechar *short_name;
+ u16 short_name_nbytes;
+ u16 file_name_nbytes;
+ int ret;
+ struct wim_inode *inode;
+ const u8 *p = &metadata_resource[offset];
+ const struct wim_dentry_on_disk *disk_dentry =
+ (const struct wim_dentry_on_disk*)p;
+
+ BUILD_BUG_ON(sizeof(struct wim_dentry_on_disk) != WIM_DENTRY_DISK_SIZE);
+
+ if ((uintptr_t)p & 7)
+ WARNING("WIM dentry is not 8-byte aligned");
+
+ dentry_common_init(dentry);
+
+ /* Before reading the whole dentry, we need to read just the length.
+ * This is because a dentry of length 8 (that is, just the length field)
+ * terminates the list of sibling directory entries. */
+ if (offset + sizeof(u64) > metadata_resource_len ||
+ offset + sizeof(u64) < offset)
+ {
+ ERROR("Directory entry starting at %"PRIu64" ends past the "
+ "end of the metadata resource (size %"PRIu64")",
+ offset, metadata_resource_len);
+ return WIMLIB_ERR_INVALID_METADATA_RESOURCE;
+ }
+ dentry->length = le64_to_cpu(disk_dentry->length);