+ lte->resource_location = RESOURCE_IN_ATTACHED_BUFFER;
+ lte->attached_buffer = buffer_copy;
+ lte->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 == NULL)
+ return WIMLIB_ERR_NOMEM;
+
+ new_ads_entry->lte = add_stream_from_data_buffer(value, size,
+ lookup_table);
+ if (new_ads_entry->lte == NULL) {
+ 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 == NULL)
+ 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 == NULL)
+ return NO_UNIX_DATA;
+
+ if (stream_idx_ret)
+ *stream_idx_ret = ads_entry - inode->i_ads_entries;
+
+ lte = ads_entry->lte;
+ if (lte == NULL)
+ return NO_UNIX_DATA;
+
+ size = lte->size;
+ if (size != sizeof(struct wimlib_unix_data))
+ return BAD_UNIX_DATA;
+
+ ret = read_full_stream_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 == NULL)
+ 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 == NULL)
+ 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);
+ } else {
+ /* Mark inode as having weird stream entries. */
+ inode->i_canonical_streams = 0;
+ }
+