struct wim_lookup_table_entry *lte;
lte = CALLOC(1, sizeof(struct wim_lookup_table_entry));
- if (lte) {
- lte->part_number = 1;
- lte->refcnt = 1;
- } else {
+ if (lte == NULL) {
ERROR("Out of memory (tried to allocate %zu bytes for "
"lookup table entry)",
sizeof(struct wim_lookup_table_entry));
+ return NULL;
}
+ lte->refcnt = 1;
+ BUILD_BUG_ON(RESOURCE_NONEXISTENT != 0);
+ BUILD_BUG_ON(WIMLIB_COMPRESSION_TYPE_NONE != 0);
return lte;
}
new->extracted_file = NULL;
switch (new->resource_location) {
+ case RESOURCE_IN_WIM:
+ list_add(&new->wim_resource_list, &new->rspec->lte_list);
+ break;
+
case RESOURCE_IN_FILE_ON_DISK:
#ifdef __WIN32__
case RESOURCE_WIN32_ENCRYPTED:
goto out_free;
break;
case RESOURCE_IN_ATTACHED_BUFFER:
- new->attached_buffer = memdup(old->attached_buffer,
- wim_resource_size(old));
+ new->attached_buffer = memdup(old->attached_buffer, old->size);
if (!new->attached_buffer)
goto out_free;
break;
{
if (lte) {
switch (lte->resource_location) {
+ case RESOURCE_IN_WIM:
+ list_del(<e->wim_resource_list);
+ if (list_empty(<e->rspec->lte_list))
+ FREE(lte->rspec);
+ break;
case RESOURCE_IN_FILE_ON_DISK:
#ifdef __WIN32__
case RESOURCE_WIN32_ENCRYPTED:
{
const struct wim_lookup_table_entry *lte1, *lte2;
int v;
+ WIMStruct *wim1, *wim2;
lte1 = *(const struct wim_lookup_table_entry**)p1;
lte2 = *(const struct wim_lookup_table_entry**)p2;
switch (lte1->resource_location) {
case RESOURCE_IN_WIM:
+ wim1 = lte1->rspec->wim;
+ wim2 = lte2->rspec->wim;
/* Different (possibly split) WIMs? */
- if (lte1->wim != lte2->wim) {
- v = memcmp(lte1->wim->hdr.guid, lte2->wim->hdr.guid,
- WIM_GID_LEN);
+ if (wim1 != wim2) {
+ v = memcmp(wim1->hdr.guid, wim2->hdr.guid, WIM_GID_LEN);
if (v)
return v;
}
/* Different part numbers in the same WIM? */
- v = (int)lte1->wim->hdr.part_number - (int)lte2->wim->hdr.part_number;
+ v = (int)wim1->hdr.part_number - (int)wim2->hdr.part_number;
if (v)
return v;
/* Compare by offset. */
- if (lte1->resource_entry.offset < lte2->resource_entry.offset)
+ if (lte1->rspec->offset_in_wim < lte2->rspec->offset_in_wim)
return -1;
- else if (lte1->resource_entry.offset > lte2->resource_entry.offset)
+ if (lte1->rspec->offset_in_wim > lte2->rspec->offset_in_wim)
return 1;
return 0;
case RESOURCE_IN_FILE_ON_DISK:
+#ifdef WITH_FUSE
+ case RESOURCE_IN_STAGING_FILE:
+#endif
#ifdef __WIN32__
case RESOURCE_WIN32_ENCRYPTED:
#endif
/* On-disk format of a WIM lookup table entry (stream entry). */
struct wim_lookup_table_entry_disk {
- /* Location, offset, compression status, and metadata status of the
- * stream. */
- struct resource_entry_disk resource_entry;
+ /* Size, offset, and flags of the stream. */
+ struct wim_reshdr_disk reshdr;
/* Which part of the split WIM this stream is in; indexed from 1. */
le16 part_number;
#define WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE 50
-void
-lte_init_wim(struct wim_lookup_table_entry *lte, WIMStruct *wim)
+static int
+validate_resource(const struct wim_resource_spec *rspec,
+ u64 offset_save, u64 size_save)
{
- lte->resource_location = RESOURCE_IN_WIM;
- lte->wim = wim;
- if (lte->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED)
- lte->compression_type = wim->compression_type;
- else
- lte->compression_type = WIMLIB_COMPRESSION_TYPE_NONE;
+ struct wim_lookup_table_entry *lte;
+ list_for_each_entry(lte, &rspec->lte_list, wim_resource_list) {
+ if (rspec->flags & WIM_RESHDR_FLAG_COMPRESSED)
+ lte->flags |= WIM_RESHDR_FLAG_COMPRESSED;
+ else
+ lte->flags &= ~WIM_RESHDR_FLAG_COMPRESSED;
- if (wim_is_pipable(wim))
- lte->is_pipable = 1;
+ if (!(lte->flags & WIM_RESHDR_FLAG_CONCAT)) {
+ lte->offset_in_res = offset_save;
+ lte->size = size_save;
+ }
+
+
+ if (lte->offset_in_res + lte->size < lte->size ||
+ lte->offset_in_res + lte->size > rspec->uncompressed_size)
+ {
+ return WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
+ }
+ print_lookup_table_entry(lte, stderr);
+ }
+ return 0;
}
/*
size_t num_entries;
struct wim_lookup_table *table;
struct wim_lookup_table_entry *cur_entry, *duplicate_entry;
+ struct wim_resource_spec *cur_rspec;
+ u64 size_save;
+ u64 offset_save;
void *buf;
BUILD_BUG_ON(sizeof(struct wim_lookup_table_entry_disk) !=
WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE);
- DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"",
- wim->hdr.lookup_table_res_entry.offset,
- wim->hdr.lookup_table_res_entry.size);
+ DEBUG("Reading lookup table.");
/* Calculate number of entries in the lookup table. */
- num_entries = wim->hdr.lookup_table_res_entry.size /
+ num_entries = wim->hdr.lookup_table_reshdr.uncompressed_size /
sizeof(struct wim_lookup_table_entry_disk);
-
/* Read the lookup table into a buffer. */
- ret = res_entry_to_data(&wim->hdr.lookup_table_res_entry, wim, &buf);
+ ret = wim_reshdr_to_data(&wim->hdr.lookup_table_reshdr, wim, &buf);
if (ret)
goto out;
/* Allocate hash table. */
table = new_lookup_table(num_entries * 2 + 1);
- if (!table) {
+ if (table == NULL) {
ERROR("Not enough memory to read lookup table.");
ret = WIMLIB_ERR_NOMEM;
goto out_free_buf;
/* Allocate and initalize `struct wim_lookup_table_entry's from the
* on-disk lookup table. */
wim->current_image = 0;
+ cur_rspec = NULL;
for (i = 0; i < num_entries; i++) {
const struct wim_lookup_table_entry_disk *disk_entry =
&((const struct wim_lookup_table_entry_disk*)buf)[i];
+ u16 part_number;
+ struct wim_reshdr reshdr;
+
+ get_wim_reshdr(&disk_entry->reshdr, &reshdr);
+
+ DEBUG("reshdr: size=%"PRIu64", original_size=%"PRIu64", "
+ "offset=%"PRIu64", flags=0x%02x",
+ reshdr.size_in_wim, reshdr.uncompressed_size,
+ reshdr.offset_in_wim, reshdr.flags);
cur_entry = new_lookup_table_entry();
- if (!cur_entry) {
+ if (cur_entry == NULL) {
ERROR("Not enough memory to read lookup table.");
ret = WIMLIB_ERR_NOMEM;
goto out_free_lookup_table;
}
- cur_entry->wim = wim;
- cur_entry->resource_location = RESOURCE_IN_WIM;
- get_resource_entry(&disk_entry->resource_entry, &cur_entry->resource_entry);
- cur_entry->part_number = le16_to_cpu(disk_entry->part_number);
+ part_number = le16_to_cpu(disk_entry->part_number);
cur_entry->refcnt = le32_to_cpu(disk_entry->refcnt);
copy_hash(cur_entry->hash, disk_entry->hash);
- lte_init_wim(cur_entry, wim);
- if (cur_entry->part_number != wim->hdr.part_number) {
+ if (part_number != wim->hdr.part_number) {
WARNING("A lookup table entry in part %hu of the WIM "
"points to part %hu (ignoring it)",
- wim->hdr.part_number, cur_entry->part_number);
+ wim->hdr.part_number, part_number);
free_lookup_table_entry(cur_entry);
continue;
}
+ if (cur_rspec == NULL ||
+ !(reshdr.flags & WIM_RESHDR_FLAG_CONCAT))
+ {
+ /* Starting new run of stream entries that all share the
+ * same WIM resource (streams concatenated together); or
+ * simply a single normal entry by itself. */
+
+ if (cur_rspec != NULL) {
+ ret = validate_resource(cur_rspec, offset_save,
+ size_save);
+ if (ret)
+ goto out_free_cur_entry;
+ }
+
+ cur_rspec = MALLOC(sizeof(struct wim_resource_spec));
+ if (cur_rspec == NULL) {
+ ERROR("Not enough memory to read lookup table.");
+ ret = WIMLIB_ERR_NOMEM;
+ goto out_free_cur_entry;
+ }
+ offset_save = reshdr.offset_in_wim;
+ size_save = reshdr.size_in_wim;
+ wim_res_hdr_to_spec(&reshdr, wim, cur_rspec);
+ } else if (is_zero_hash(cur_entry->hash)) {
+ /* Found the resource specification for the run. */
+ cur_rspec->offset_in_wim = reshdr.offset_in_wim;
+ cur_rspec->size_in_wim = reshdr.size_in_wim;
+ cur_rspec->flags = reshdr.flags;
+ DEBUG("Full run is %"PRIu64" compressed bytes "
+ "at file offset %"PRIu64" (flags 0x%02x)",
+ cur_rspec->size_in_wim,
+ cur_rspec->offset_in_wim,
+ cur_rspec->flags);
+ free_lookup_table_entry(cur_entry);
+ continue;
+ } else {
+ /* Continuing the run with another stream. */
+ DEBUG("Continuing concat run with stream: "
+ "%"PRIu64" uncompressed bytes @ resource offset %"PRIu64")",
+ reshdr.size_in_wim, reshdr.offset_in_wim);
+ cur_rspec->uncompressed_size += reshdr.size_in_wim;
+ }
+
+ lte_bind_wim_resource_spec(cur_entry, cur_rspec);
+ if (reshdr.flags & WIM_RESHDR_FLAG_CONCAT) {
+ /* In concatenation runs, the offset field is used for
+ * in-resource offset, not the in-WIM offset, and the
+ * size field is used for the uncompressed size, not the
+ * compressed size. */
+ cur_entry->offset_in_res = reshdr.offset_in_wim;
+ cur_entry->size = reshdr.size_in_wim;
+ cur_entry->flags = reshdr.flags;
+ } else {
+ /* These may be overwritten in validate_resource() if
+ * the run turns out to be a concatenation. */
+ cur_entry->offset_in_res = 0;
+ cur_entry->size = reshdr.uncompressed_size;
+ cur_entry->flags = reshdr.flags;
+ }
+
if (is_zero_hash(cur_entry->hash)) {
WARNING("The WIM lookup table contains an entry with a "
"SHA1 message digest of all 0's (ignoring it)");
continue;
}
- if (!(cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED)
- && (cur_entry->resource_entry.size !=
- cur_entry->resource_entry.original_size))
- {
- if (wimlib_print_errors) {
- WARNING("Found uncompressed resource with "
- "original size (%"PRIu64") not the same "
- "as compressed size (%"PRIu64")",
- cur_entry->resource_entry.original_size,
- cur_entry->resource_entry.size);
- if (cur_entry->resource_entry.original_size) {
- WARNING("Overriding compressed size with original size.");
- cur_entry->resource_entry.size =
- cur_entry->resource_entry.original_size;
- } else {
- WARNING("Overriding original size with compressed size");
- cur_entry->resource_entry.original_size =
- cur_entry->resource_entry.size;
- }
- }
- }
-
- if (cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_METADATA) {
+ if (cur_entry->flags & WIM_RESHDR_FLAG_METADATA) {
/* Lookup table entry for a metadata resource */
if (cur_entry->refcnt != 1) {
+ /* Metadata entries with no references must be
+ * ignored. See for example the WinPE WIMs from
+ * WAIK v2.1. */
+ if (cur_entry->refcnt == 0) {
+ free_lookup_table_entry(cur_entry);
+ continue;
+ }
if (wimlib_print_errors) {
ERROR("Found metadata resource with refcnt != 1:");
print_lookup_table_entry(cur_entry, stderr);
DEBUG("Found metadata resource for image %u at "
"offset %"PRIu64".",
wim->current_image + 1,
- cur_entry->resource_entry.offset);
+ cur_entry->rspec->offset_in_wim);
wim->image_metadata[
wim->current_image++]->metadata_lte = cur_entry;
} else {
}
}
+ if (cur_rspec != NULL) {
+ ret = validate_resource(cur_rspec, offset_save, size_save);
+ if (ret)
+ goto out_free_cur_entry;
+ }
+
if (wim->hdr.part_number == 1 && wim->current_image != wim->hdr.image_count) {
WARNING("The header of \"%"TS"\" says there are %u images in\n"
" the WIM, but we only found %d metadata resources! Acting as if\n"
wim->lookup_table = table;
ret = 0;
goto out_free_buf;
+
out_free_cur_entry:
FREE(cur_entry);
out_free_lookup_table:
static void
write_wim_lookup_table_entry(const struct wim_lookup_table_entry *lte,
- struct wim_lookup_table_entry_disk *disk_entry)
+ struct wim_lookup_table_entry_disk *disk_entry,
+ u16 part_number)
{
- put_resource_entry(<e->output_resource_entry, &disk_entry->resource_entry);
- disk_entry->part_number = cpu_to_le16(lte->part_number);
+ put_wim_reshdr(<e->out_reshdr, &disk_entry->reshdr);
+ disk_entry->part_number = cpu_to_le16(part_number);
disk_entry->refcnt = cpu_to_le32(lte->out_refcnt);
copy_hash(disk_entry->hash, lte->hash);
}
static int
write_wim_lookup_table_from_stream_list(struct list_head *stream_list,
struct filedes *out_fd,
- struct resource_entry *out_res_entry,
- int write_resource_flags)
+ u16 part_number,
+ struct wim_reshdr *out_reshdr,
+ int write_resource_flags,
+ struct wimlib_lzx_context **comp_ctx)
{
size_t table_size;
struct wim_lookup_table_entry *lte;
}
table_buf_ptr = table_buf;
list_for_each_entry(lte, stream_list, lookup_table_list)
- write_wim_lookup_table_entry(lte, table_buf_ptr++);
+ write_wim_lookup_table_entry(lte, table_buf_ptr++, part_number);
/* Write the lookup table uncompressed. Although wimlib can handle a
* compressed lookup table, MS software cannot. */
WIM_RESHDR_FLAG_METADATA,
out_fd,
WIMLIB_COMPRESSION_TYPE_NONE,
- out_res_entry,
+ 0,
+ out_reshdr,
NULL,
- write_resource_flags);
+ write_resource_flags,
+ comp_ctx);
FREE(table_buf);
+ DEBUG("ret=%d", ret);
return ret;
}
* needs to be copied from the resource information read originally.
*/
if (lte->out_refcnt != 0 && !(lte->filtered & FILTERED_EXTERNAL_WIM)) {
- if (lte->filtered & FILTERED_SAME_WIM) {
- copy_resource_entry(<e->output_resource_entry,
- <e->resource_entry);
- }
+ if (lte->filtered & FILTERED_SAME_WIM)
+ wim_res_spec_to_hdr(lte->rspec, <e->out_reshdr);
list_add_tail(<e->lookup_table_list, (struct list_head*)_list);
}
return 0;
int
write_wim_lookup_table(WIMStruct *wim, int image, int write_flags,
- struct resource_entry *out_res_entry,
+ struct wim_reshdr *out_reshdr,
struct list_head *stream_list_override)
{
int write_resource_flags;
metadata_lte = wim->image_metadata[i - 1]->metadata_lte;
metadata_lte->out_refcnt = 1;
- metadata_lte->part_number = wim->hdr.part_number;
- metadata_lte->output_resource_entry.flags |= WIM_RESHDR_FLAG_METADATA;
-
+ metadata_lte->out_reshdr.flags |= WIM_RESHDR_FLAG_METADATA;
list_add(&metadata_lte->lookup_table_list, stream_list);
}
}
write_resource_flags |= WIMLIB_WRITE_RESOURCE_FLAG_PIPABLE;
return write_wim_lookup_table_from_stream_list(stream_list,
&wim->out_fd,
- out_res_entry,
- write_resource_flags);
+ wim->hdr.part_number,
+ out_reshdr,
+ write_resource_flags,
+ &wim->lzx_context);
}
void
print_lookup_table_entry(const struct wim_lookup_table_entry *lte, FILE *out)
{
- if (!lte) {
+ if (lte == NULL) {
tputc(T('\n'), out);
return;
}
- tfprintf(out, T("Offset = %"PRIu64" bytes\n"),
- lte->resource_entry.offset);
- tfprintf(out, T("Size = %"PRIu64" bytes\n"),
- (u64)lte->resource_entry.size);
- tfprintf(out, T("Original size = %"PRIu64" bytes\n"),
- lte->resource_entry.original_size);
+ tprintf(T("Uncompressed size = %"PRIu64" bytes\n"),
+ lte->size);
+ if (lte_is_partial(lte)) {
+ tprintf(T("Offset = %"PRIu64" bytes\n"),
+ lte->offset_in_res);
+
+ tprintf(T("Raw uncompressed size = %"PRIu64" bytes\n"),
+ lte->rspec->uncompressed_size);
+
+ tprintf(T("Raw compressed size = %"PRIu64" bytes\n"),
+ lte->rspec->size_in_wim);
- tfprintf(out, T("Part Number = %hu\n"), lte->part_number);
- tfprintf(out, T("Reference Count = %u\n"), lte->refcnt);
+ tprintf(T("Raw offset = %"PRIu64" bytes\n"),
+ lte->rspec->offset_in_wim);
+ } else if (lte->resource_location == RESOURCE_IN_WIM) {
+ tprintf(T("Compressed size = %"PRIu64" bytes\n"),
+ lte->rspec->size_in_wim);
+
+ tprintf(T("Offset = %"PRIu64" bytes\n"),
+ lte->rspec->offset_in_wim);
+ }
+
+ tfprintf(out, T("Reference Count = %u\n"), lte->refcnt);
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"));
+ tfprintf(out, T("Hash = 0x"));
print_hash(lte->hash, out);
tputc(T('\n'), out);
}
- tfprintf(out, T("Flags = "));
- u8 flags = lte->resource_entry.flags;
+ tfprintf(out, T("Flags = "));
+ u8 flags = lte->flags;
if (flags & WIM_RESHDR_FLAG_COMPRESSED)
tfputs(T("WIM_RESHDR_FLAG_COMPRESSED, "), out);
if (flags & WIM_RESHDR_FLAG_FREE)
tfputs(T("WIM_RESHDR_FLAG_METADATA, "), out);
if (flags & WIM_RESHDR_FLAG_SPANNED)
tfputs(T("WIM_RESHDR_FLAG_SPANNED, "), out);
+ if (flags & WIM_RESHDR_FLAG_CONCAT)
+ tfputs(T("WIM_RESHDR_FLAG_CONCAT, "), out);
tputc(T('\n'), out);
switch (lte->resource_location) {
case RESOURCE_IN_WIM:
- if (lte->wim->filename) {
- tfprintf(out, T("WIM file = `%"TS"'\n"),
- lte->wim->filename);
+ if (lte->rspec->wim->filename) {
+ tfprintf(out, T("WIM file = `%"TS"'\n"),
+ lte->rspec->wim->filename);
}
break;
#ifdef __WIN32__
case RESOURCE_WIN32_ENCRYPTED:
#endif
case RESOURCE_IN_FILE_ON_DISK:
- tfprintf(out, T("File on Disk = `%"TS"'\n"),
+ tfprintf(out, T("File on Disk = `%"TS"'\n"),
lte->file_on_disk);
break;
#ifdef WITH_FUSE
case RESOURCE_IN_STAGING_FILE:
- tfprintf(out, T("Staging File = `%"TS"'\n"),
+ tfprintf(out, T("Staging File = `%"TS"'\n"),
lte->staging_file_name);
break;
#endif
lte_to_wimlib_resource_entry(const struct wim_lookup_table_entry *lte,
struct wimlib_resource_entry *wentry)
{
- wentry->uncompressed_size = lte->resource_entry.original_size;
- wentry->compressed_size = lte->resource_entry.size;
- wentry->offset = lte->resource_entry.offset;
+ memset(wentry, 0, sizeof(*wentry));
+
+ wentry->uncompressed_size = lte->size;
+ if (lte->resource_location == RESOURCE_IN_WIM) {
+ wentry->part_number = lte->rspec->wim->hdr.part_number;
+ if (lte_is_partial(lte)) {
+ wentry->compressed_size = 0;
+ wentry->offset = lte->offset_in_res;
+ } else {
+ wentry->compressed_size = lte->rspec->size_in_wim;
+ wentry->offset = lte->rspec->offset_in_wim;
+ }
+ wentry->raw_resource_offset_in_wim = lte->rspec->offset_in_wim;
+ wentry->raw_resource_uncompressed_size = lte->rspec->uncompressed_size;
+ wentry->raw_resource_compressed_size = lte->rspec->size_in_wim;
+ }
copy_hash(wentry->sha1_hash, lte->hash);
- wentry->part_number = lte->part_number;
wentry->reference_count = lte->refcnt;
- wentry->is_compressed = (lte->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED) != 0;
- wentry->is_metadata = (lte->resource_entry.flags & WIM_RESHDR_FLAG_METADATA) != 0;
- wentry->is_free = (lte->resource_entry.flags & WIM_RESHDR_FLAG_FREE) != 0;
- wentry->is_spanned = (lte->resource_entry.flags & WIM_RESHDR_FLAG_SPANNED) != 0;
+ wentry->is_compressed = (lte->flags & WIM_RESHDR_FLAG_COMPRESSED) != 0;
+ wentry->is_metadata = (lte->flags & WIM_RESHDR_FLAG_METADATA) != 0;
+ wentry->is_free = (lte->flags & WIM_RESHDR_FLAG_FREE) != 0;
+ wentry->is_spanned = (lte->flags & WIM_RESHDR_FLAG_SPANNED) != 0;
+ wentry->is_partial = lte_is_partial(lte);
}
struct iterate_lte_context {
return -ENOENT;
}
} else {
- lte = inode->i_lte;
- stream_idx = 0;
+ lte = inode_unnamed_stream_resolved(inode, &stream_idx);
}
out:
if (dentry_ret)
}
struct wim_lookup_table_entry *
-inode_unnamed_lte_resolved(const struct wim_inode *inode)
+inode_unnamed_stream_resolved(const struct wim_inode *inode, u16 *stream_idx_ret)
{
wimlib_assert(inode->i_resolved);
for (unsigned i = 0; i <= inode->i_num_ads; i++) {
if (inode_stream_name_nbytes(inode, i) == 0 &&
!is_zero_hash(inode_stream_hash_resolved(inode, i)))
{
+ *stream_idx_ret = i;
return inode_stream_lte_resolved(inode, i);
}
}
+ *stream_idx_ret = 0;
return NULL;
}
+struct wim_lookup_table_entry *
+inode_unnamed_lte_resolved(const struct wim_inode *inode)
+{
+ u16 stream_idx;
+ return inode_unnamed_stream_resolved(inode, &stream_idx);
+}
+
struct wim_lookup_table_entry *
inode_unnamed_lte_unresolved(const struct wim_inode *inode,
const struct wim_lookup_table *table)
return inode_unnamed_lte_unresolved(inode, table);
}
+/* Returns the SHA1 message digest of the unnamed data stream of a WIM inode, or
+ * 'zero_hash' if the unnamed data stream is missing has all zeroes in its SHA1
+ * message digest field. */
const u8 *
inode_unnamed_stream_hash(const struct wim_inode *inode)
{
return hash;
}
}
- return NULL;
-}
-
-
-static int
-lte_add_stream_size(struct wim_lookup_table_entry *lte, void *total_bytes_p)
-{
- *(u64*)total_bytes_p += lte->resource_entry.size;
- return 0;
-}
-
-u64
-lookup_table_total_stream_size(struct wim_lookup_table *table)
-{
- u64 total_size = 0;
- for_lookup_table_entry(table, lte_add_stream_size, &total_size);
- return total_size;
+ return zero_hash;
}
struct wim_lookup_table_entry **