switch (new->resource_location) {
#ifdef __WIN32__
case RESOURCE_WIN32:
+ case RESOURCE_WIN32_ENCRYPTED:
#endif
+#ifdef WITH_FUSE
case RESOURCE_IN_STAGING_FILE:
+#endif
case RESOURCE_IN_FILE_ON_DISK:
BUILD_BUG_ON((void*)&old->file_on_disk !=
(void*)&old->staging_file_name);
#ifdef WITH_FUSE
if (lte->resource_location == RESOURCE_IN_STAGING_FILE) {
unlink(lte->staging_file_name);
- list_del(<e->staging_list);
+ list_del(<e->unhashed_list);
}
#endif
free_lookup_table_entry(lte);
wimlib_assert(lte != NULL);
wimlib_assert(lte->refcnt != 0);
if (--lte->refcnt == 0) {
- lookup_table_unlink(table, lte);
+ if (!lte->unhashed)
+ lookup_table_unlink(table, lte);
#ifdef WITH_FUSE
if (lte->num_opened_fds == 0)
#endif
{
wimlib_assert2(!(lte->resource_entry.flags & WIM_RESHDR_FLAG_METADATA));
ret = visitor(lte, arg);
- if (ret != 0)
+ if (ret)
return ret;
}
}
return 0;
}
-static int
+int
cmp_streams_by_wim_position(const void *p1, const void *p2)
{
const struct wim_lookup_table_entry *lte1, *lte2;
return 0;
}
-int
-sort_stream_list_by_wim_position(struct list_head *stream_list)
-{
- struct list_head *cur;
- size_t num_streams;
- struct wim_lookup_table_entry **array;
- size_t i;
- size_t array_size;
-
- num_streams = 0;
- list_for_each(cur, stream_list)
- num_streams++;
- array_size = num_streams * sizeof(array[0]);
- array = MALLOC(array_size);
- if (!array) {
- ERROR("Failed to allocate %zu bytes to sort stream entries",
- array_size);
- return WIMLIB_ERR_NOMEM;
- }
- cur = stream_list->next;
- for (i = 0; i < num_streams; i++) {
- array[i] = container_of(cur, struct wim_lookup_table_entry, staging_list);
- cur = cur->next;
- }
-
- qsort(array, num_streams, sizeof(array[0]), cmp_streams_by_wim_position);
-
- INIT_LIST_HEAD(stream_list);
- for (i = 0; i < num_streams; i++)
- list_add_tail(&array[i]->staging_list, stream_list);
- FREE(array);
- return 0;
-}
-
static int
add_lte_to_array(struct wim_lookup_table_entry *lte,
qsort(lte_array, num_streams, sizeof(lte_array[0]),
cmp_streams_by_wim_position);
ret = 0;
- for (size_t i = 0; i < num_streams && ret == 0; i++)
+ for (size_t i = 0; i < num_streams; i++) {
ret = visitor(lte_array[i], arg);
+ if (ret)
+ break;
+ }
FREE(lte_array);
return ret;
}
w->current_image + 1,
cur_entry->resource_entry.offset);
w->image_metadata[
- w->current_image++].metadata_lte = cur_entry;
+ w->current_image++]->metadata_lte = cur_entry;
} else {
/* Lookup table entry for a stream that is not a
* metadata resource */
for (int i = start_image; i <= end_image; i++) {
struct wim_lookup_table_entry *metadata_lte;
- metadata_lte = w->image_metadata[i - 1].metadata_lte;
+ metadata_lte = w->image_metadata[i - 1]->metadata_lte;
metadata_lte->out_refcnt = 1;
metadata_lte->output_resource_entry.flags |= WIM_RESHDR_FLAG_METADATA;
ret = write_lookup_table_entry(metadata_lte, out);
return 0;
}
-
int
-lte_zero_real_refcnt(struct wim_lookup_table_entry *lte, void *ignore)
+lte_zero_real_refcnt(struct wim_lookup_table_entry *lte, void *_ignore)
{
lte->real_refcnt = 0;
return 0;
}
int
-lte_zero_out_refcnt(struct wim_lookup_table_entry *lte, void *ignore)
+lte_zero_out_refcnt(struct wim_lookup_table_entry *lte, void *_ignore)
{
lte->out_refcnt = 0;
return 0;
}
int
-lte_free_extracted_file(struct wim_lookup_table_entry *lte, void *ignore)
+lte_free_extracted_file(struct wim_lookup_table_entry *lte, void *_ignore)
{
if (lte->extracted_file != NULL) {
FREE(lte->extracted_file);
tfprintf(out, T("Part Number = %hu\n"), lte->part_number);
tfprintf(out, T("Reference Count = %u\n"), lte->refcnt);
- tfprintf(out, T("Hash = 0x"));
- print_hash(lte->hash, out);
- tputc(T('\n'), out);
+ if (lte->unhashed) {
+ tfprintf(out, T("(Unhashed: inode %p, stream_id = %u)\n"),
+ lte->back_inode, lte->back_stream_id);
+ } else {
+ tfprintf(out, T("Hash = 0x"));
+ print_hash(lte->hash, out);
+ tputc(T('\n'), out);
+ }
tfprintf(out, T("Flags = "));
u8 flags = lte->resource_entry.flags;
break;
#ifdef __WIN32__
case RESOURCE_WIN32:
+ case RESOURCE_WIN32_ENCRYPTED:
#endif
case RESOURCE_IN_FILE_ON_DISK:
tfprintf(out, T("File on Disk = `%"TS"'\n"),
return total_size;
}
-void
-lookup_table_free_unhashed_streams(struct wim_lookup_table *table)
+struct wim_lookup_table_entry **
+retrieve_lte_pointer(struct wim_lookup_table_entry *lte)
{
- struct wim_lookup_table_entry *lte, *tmp;
+ wimlib_assert(lte->unhashed);
+ struct wim_inode *inode = lte->back_inode;
+ u32 stream_id = lte->back_stream_id;
+ if (stream_id == 0)
+ return &inode->i_lte;
+ else
+ for (u16 i = 0; i < inode->i_num_ads; i++)
+ if (inode->i_ads_entries[i].stream_id == stream_id)
+ return &inode->i_ads_entries[i].lte;
+ wimlib_assert(0);
+ return NULL;
+}
+
+/* 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;
- list_for_each_entry_safe(lte, tmp, table->unhashed_streams, staging_list)
+ 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_resource(lte);
+ if (ret)
+ return ret;
+
+ /* Look for a duplicate stream */
+ duplicate_lte = __lookup_resource(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, update the reference to
+ * this stream (in an inode or ads_entry) to point to the
+ * duplicate, then free this stream. */
+ wimlib_assert(!(duplicate_lte->unhashed));
+ duplicate_lte->refcnt += lte->refcnt;
+ duplicate_lte->out_refcnt += lte->refcnt;
+ *back_ptr = duplicate_lte;
free_lookup_table_entry(lte);
- INIT_LIST_HEAD(table->unhashed_streams);
+ 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;
+ }
+ if (lte_ret)
+ *lte_ret = lte;
+ return 0;
}
+
git://wimlib.net / wimlib / blobdiff