+/* Allocate a stream entry for the contents of the buffer, or re-use an existing
+ * entry in @lookup_table for the same stream. */
+struct wim_lookup_table_entry *
+new_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_stream(lookup_table, hash);
+ if (existing_lte) {
+ wimlib_assert(existing_lte->size == size);
+ lte = existing_lte;
+ lte->refcnt++;
+ } else {
+ void *buffer_copy;
+ lte = new_lookup_table_entry();
+ if (lte == NULL)
+ return NULL;
+ buffer_copy = memdup(buffer, size);
+ if (buffer_copy == NULL) {
+ free_lookup_table_entry(lte);
+ return NULL;
+ }
+ 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;
+}
+
+/* Calculate the SHA1 message digest of a stream and move it from the list of
+ * unhashed streams to the stream lookup table, possibly joining it with an
+ * existing lookup table entry for an identical stream.
+ *
+ * @lte: An unhashed lookup table entry.
+ * @lookup_table: Lookup table for the WIM.
+ * @lte_ret: On success, write a pointer to the resulting lookup table
+ * entry to this location. This will be the same as @lte
+ * if it was inserted into the lookup table, or different if
+ * a duplicate stream was found.
+ *
+ * Returns 0 on success; nonzero if there is an error reading the stream.
+ */
+int
+hash_unhashed_stream(struct wim_lookup_table_entry *lte,
+ struct wim_lookup_table *lookup_table,
+ struct wim_lookup_table_entry **lte_ret)
+{
+ int ret;
+ struct wim_lookup_table_entry *duplicate_lte;
+ struct wim_lookup_table_entry **back_ptr;
+
+ wimlib_assert(lte->unhashed);
+
+ /* back_ptr must be saved because @back_inode and @back_stream_id are in
+ * union with the SHA1 message digest and will no longer be valid once
+ * the SHA1 has been calculated. */
+ back_ptr = retrieve_lte_pointer(lte);
+
+ ret = sha1_stream(lte);
+ if (ret)
+ return ret;
+
+ /* Look for a duplicate stream */
+ duplicate_lte = lookup_stream(lookup_table, lte->hash);
+ list_del(<e->unhashed_list);
+ if (duplicate_lte) {
+ /* We have a duplicate stream. Transfer the reference counts
+ * from this stream to the duplicate and update the reference to
+ * this stream (in an inode or ads_entry) to point to the
+ * duplicate. The caller is responsible for freeing @lte if
+ * needed. */
+ wimlib_assert(!(duplicate_lte->unhashed));
+ wimlib_assert(duplicate_lte->size == lte->size);
+ duplicate_lte->refcnt += lte->refcnt;
+ lte->refcnt = 0;
+ *back_ptr = duplicate_lte;
+ lte = duplicate_lte;
+ } else {
+ /* No duplicate stream, so we need to insert this stream into
+ * the lookup table and treat it as a hashed stream. */
+ lookup_table_insert(lookup_table, lte);
+ lte->unhashed = 0;
+ }
+ *lte_ret = lte;
+ return 0;
+}
+