X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Flookup_table.c;h=432873414d822a81fbda43bbcbd2c48af07bcd0d;hb=c5746b5e79df3d5c129f6185cf5fa130ab0512df;hp=15f5c0830c382fb501d9dc13ff5dbcc3513f85a8;hpb=b348831df3fcf7d8eb66d35e4d0cf8434e788473;p=wimlib diff --git a/src/lookup_table.c b/src/lookup_table.c index 15f5c083..43287341 100644 --- a/src/lookup_table.c +++ b/src/lookup_table.c @@ -31,6 +31,7 @@ #include "wimlib/endianness.h" #include "wimlib/error.h" #include "wimlib/file_io.h" +#include "wimlib/glob.h" #include "wimlib/lookup_table.h" #include "wimlib/metadata.h" #include "wimlib/paths.h" @@ -73,14 +74,15 @@ new_lookup_table_entry(void) 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; } @@ -95,6 +97,10 @@ clone_lookup_table_entry(const struct wim_lookup_table_entry *old) 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: @@ -109,8 +115,7 @@ clone_lookup_table_entry(const struct wim_lookup_table_entry *old) 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; @@ -150,6 +155,11 @@ free_lookup_table_entry(struct wim_lookup_table_entry *lte) { 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: @@ -300,6 +310,7 @@ cmp_streams_by_sequential_order(const void *p1, const void *p2) { 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; @@ -312,27 +323,31 @@ cmp_streams_by_sequential_order(const void *p1, const void *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 @@ -366,7 +381,7 @@ sort_stream_list_by_sequential_order(struct list_head *stream_list, array_size = num_streams * sizeof(array[0]); array = MALLOC(array_size); - if (!array) + if (array == NULL) return WIMLIB_ERR_NOMEM; cur = stream_list->next; for (i = 0; i < num_streams; i++) { @@ -433,9 +448,8 @@ for_lookup_table_entry_pos_sorted(struct wim_lookup_table *table, /* 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; @@ -450,18 +464,25 @@ struct wim_lookup_table_entry_disk { #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) { - 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; + if (!list_is_singular(&rspec->lte_list)) { + 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->offset_in_res + lte->size < lte->size || + lte->offset_in_res + lte->size > rspec->uncompressed_size) + { + return WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY; + } + } + } + return 0; } /* @@ -484,29 +505,26 @@ read_wim_lookup_table(WIMStruct *wim) size_t num_entries; struct wim_lookup_table *table; struct wim_lookup_table_entry *cur_entry, *duplicate_entry; - struct wim_lookup_table_entry_disk *buf; + struct wim_resource_spec *cur_rspec; + 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, - (void**)&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; @@ -515,32 +533,107 @@ read_wim_lookup_table(WIMStruct *wim) /* 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 = &buf[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; + + ret = get_wim_reshdr(&disk_entry->reshdr, &reshdr); + if (ret) { + ERROR("Resource header is invalid!"); + goto out_free_lookup_table; + } + + DEBUG("reshdr: size_in_wim=%"PRIu64", " + "uncompressed_size=%"PRIu64", " + "offset_in_wim=%"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) { - ERROR("Not enough memory to read lookup table."); + 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); + 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; + } + wim_res_hdr_to_spec(&reshdr, wim, cur_rspec); + if (reshdr.flags & WIM_RESHDR_FLAG_CONCAT) { + cur_rspec->size_in_wim = 0; + cur_rspec->uncompressed_size = 0; + } + } 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; + } + + if (reshdr.flags & WIM_RESHDR_FLAG_CONCAT) { + /* 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 { + cur_entry->offset_in_res = 0; + cur_entry->size = reshdr.uncompressed_size; + cur_entry->flags = reshdr.flags; + cur_rspec = NULL; + } + 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)"); @@ -548,31 +641,16 @@ read_wim_lookup_table(WIMStruct *wim) 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); @@ -606,13 +684,13 @@ read_wim_lookup_table(WIMStruct *wim) 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 { /* Lookup table entry for a stream that is not a * metadata resource */ - duplicate_entry = __lookup_resource(table, cur_entry->hash); + duplicate_entry = lookup_resource(table, cur_entry->hash); if (duplicate_entry) { if (wimlib_print_errors) { WARNING("The WIM lookup table contains two entries with the " @@ -630,6 +708,12 @@ read_wim_lookup_table(WIMStruct *wim) } } + if (cur_rspec != NULL) { + ret = validate_resource(cur_rspec); + 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" @@ -644,6 +728,7 @@ read_wim_lookup_table(WIMStruct *wim) wim->lookup_table = table; ret = 0; goto out_free_buf; + out_free_cur_entry: FREE(cur_entry); out_free_lookup_table: @@ -658,10 +743,11 @@ out: 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); } @@ -669,8 +755,10 @@ write_wim_lookup_table_entry(const struct wim_lookup_table_entry *lte, 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; @@ -693,7 +781,7 @@ write_wim_lookup_table_from_stream_list(struct list_head *stream_list, } 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. */ @@ -702,24 +790,46 @@ write_wim_lookup_table_from_stream_list(struct list_head *stream_list, 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; } static int append_lookup_table_entry(struct wim_lookup_table_entry *lte, void *_list) { - if (lte->out_refcnt != 0) + /* Lookup table entries with 'out_refcnt' == 0 correspond to streams not + * written and not present in the resulting WIM file, and should not be + * included in the lookup table. + * + * Lookup table entries marked as filtered (EXTERNAL_WIM) with + * 'out_refcnt != 0' were referenced as part of the logical write but + * correspond to streams that were not in fact written, and should not + * be included in the lookup table. + * + * Lookup table entries marked as filtered (SAME_WIM) with 'out_refcnt + * != 0' were referenced as part of the logical write but correspond to + * streams that were not in fact written, but nevertheless were already + * present in the WIM being overwritten in-place. These entries must be + * included in the lookup table, and the resource information to write + * 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) + 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; @@ -753,14 +863,14 @@ write_wim_lookup_table(WIMStruct *wim, int image, int write_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); } } - /* Append additional lookup table entries that have out_refcnt != 0. */ + /* Append additional lookup table entries that need to be written, with + * some special handling for streams that have been marked as filtered. + */ if (!stream_list_override) { for_lookup_table_entry(wim->lookup_table, append_lookup_table_entry, stream_list); @@ -771,8 +881,10 @@ write_wim_lookup_table(WIMStruct *wim, int image, int write_flags, 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); } @@ -803,33 +915,47 @@ lte_free_extracted_file(struct wim_lookup_table_entry *lte, void *_ignore) 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); + + 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("Part Number = %hu\n"), lte->part_number); - tfprintf(out, T("Reference Count = %u\n"), lte->refcnt); + 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) @@ -838,24 +964,26 @@ print_lookup_table_entry(const struct wim_lookup_table_entry *lte, FILE *out) 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 @@ -869,16 +997,29 @@ void 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 { @@ -918,28 +1059,10 @@ wimlib_iterate_lookup_table(WIMStruct *wim, int flags, return for_lookup_table_entry(wim->lookup_table, do_iterate_lte, &ctx); } -static int -do_print_lookup_table_entry(struct wim_lookup_table_entry *lte, void *fp) -{ - print_lookup_table_entry(lte, (FILE*)fp); - return 0; -} - -/* API function documented in wimlib.h */ -WIMLIBAPI void -wimlib_print_lookup_table(WIMStruct *wim) -{ - for (int i = 0; i < wim->hdr.image_count; i++) - print_lookup_table_entry(wim->image_metadata[i]->metadata_lte, stdout); - for_lookup_table_entry(wim->lookup_table, - do_print_lookup_table_entry, - stdout); -} - /* Given a SHA1 message digest, return the corresponding entry in the WIM's * lookup table, or NULL if there is none. */ struct wim_lookup_table_entry * -__lookup_resource(const struct wim_lookup_table *table, const u8 hash[]) +lookup_resource(const struct wim_lookup_table *table, const u8 hash[]) { size_t i; struct wim_lookup_table_entry *lte; @@ -963,12 +1086,12 @@ __lookup_resource(const struct wim_lookup_table *table, const u8 hash[]) * This is only for pre-resolved inodes. */ int -lookup_resource(WIMStruct *wim, - const tchar *path, - int lookup_flags, - struct wim_dentry **dentry_ret, - struct wim_lookup_table_entry **lte_ret, - u16 *stream_idx_ret) +wim_pathname_to_stream(WIMStruct *wim, + const tchar *path, + int lookup_flags, + struct wim_dentry **dentry_ret, + struct wim_lookup_table_entry **lte_ret, + u16 *stream_idx_ret) { struct wim_dentry *dentry; struct wim_lookup_table_entry *lte; @@ -1014,8 +1137,7 @@ lookup_resource(WIMStruct *wim, return -ENOENT; } } else { - lte = inode->i_lte; - stream_idx = 0; + lte = inode_unnamed_stream_resolved(inode, &stream_idx); } out: if (dentry_ret) @@ -1028,6 +1150,18 @@ out: } #endif +int +resource_not_found_error(const struct wim_inode *inode, const u8 *hash) +{ + if (wimlib_print_errors) { + ERROR("\"%"TS"\": resource not found", inode_first_full_path(inode)); + tfprintf(stderr, T(" SHA-1 message digest of missing resource:\n ")); + print_hash(hash, stderr); + tputc(T('\n'), stderr); + } + return WIMLIB_ERR_RESOURCE_NOT_FOUND; +} + /* * Resolve an inode's lookup table entries. * @@ -1055,7 +1189,7 @@ inode_resolve_ltes(struct wim_inode *inode, struct wim_lookup_table *table, lte = NULL; hash = inode->i_hash; if (!is_zero_hash(hash)) { - lte = __lookup_resource(table, hash); + lte = lookup_resource(table, hash); if (!lte) { if (force) { lte = new_lookup_table_entry(); @@ -1078,7 +1212,7 @@ inode_resolve_ltes(struct wim_inode *inode, struct wim_lookup_table *table, cur_entry = &inode->i_ads_entries[i]; hash = cur_entry->hash; if (!is_zero_hash(hash)) { - ads_lte = __lookup_resource(table, hash); + ads_lte = lookup_resource(table, hash); if (!ads_lte) { if (force) { ads_lte = new_lookup_table_entry(); @@ -1099,14 +1233,9 @@ inode_resolve_ltes(struct wim_inode *inode, struct wim_lookup_table *table, inode->i_resolved = 1; } return 0; + resource_not_found: - if (wimlib_print_errors) { - ERROR("\"%"TS"\": resource not found", inode_first_full_path(inode)); - tfprintf(stderr, T(" SHA-1 message digest of missing resource:\n ")); - print_hash(hash, stderr); - tputc(T('\n'), stderr); - } - return WIMLIB_ERR_RESOURCE_NOT_FOUND; + return resource_not_found_error(inode, hash); } void @@ -1147,19 +1276,28 @@ inode_stream_lte(const struct wim_inode *inode, unsigned stream_idx, } 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) @@ -1201,19 +1339,22 @@ inode_unnamed_lte(const struct wim_inode *inode, return inode_unnamed_lte_unresolved(inode, table); } -static int -lte_add_stream_size(struct wim_lookup_table_entry *lte, void *total_bytes_p) +/* 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) { - *(u64*)total_bytes_p += lte->resource_entry.size; - return 0; -} + const u8 *hash; -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; + for (unsigned i = 0; i <= inode->i_num_ads; i++) { + if (inode_stream_name_nbytes(inode, i) == 0) { + hash = inode_stream_hash(inode, i); + if (!is_zero_hash(hash)) + return hash; + } + } + return zero_hash; } struct wim_lookup_table_entry ** @@ -1261,12 +1402,12 @@ hash_unhashed_stream(struct wim_lookup_table_entry *lte, * the SHA1 has been calculated. */ back_ptr = retrieve_lte_pointer(lte); - ret = sha1_resource(lte); + ret = sha1_stream(lte); if (ret) return ret; /* Look for a duplicate stream */ - duplicate_lte = __lookup_resource(lookup_table, lte->hash); + 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 @@ -1275,7 +1416,7 @@ hash_unhashed_stream(struct wim_lookup_table_entry *lte, * duplicate, then free this stream. */ wimlib_assert(!(duplicate_lte->unhashed)); duplicate_lte->refcnt += lte->refcnt; - duplicate_lte->out_refcnt += lte->refcnt; + duplicate_lte->out_refcnt += lte->out_refcnt; *back_ptr = duplicate_lte; free_lookup_table_entry(lte); lte = duplicate_lte; @@ -1290,3 +1431,183 @@ hash_unhashed_stream(struct wim_lookup_table_entry *lte, *lte_ret = lte; return 0; } + +static int +lte_clone_if_new(struct wim_lookup_table_entry *lte, void *_lookup_table) +{ + struct wim_lookup_table *lookup_table = _lookup_table; + + if (lookup_resource(lookup_table, lte->hash)) + return 0; /* Resource already present. */ + + lte = clone_lookup_table_entry(lte); + if (!lte) + return WIMLIB_ERR_NOMEM; + lte->out_refcnt = 1; + lookup_table_insert(lookup_table, lte); + return 0; +} + +static int +lte_delete_if_new(struct wim_lookup_table_entry *lte, void *_lookup_table) +{ + struct wim_lookup_table *lookup_table = _lookup_table; + + if (lte->out_refcnt) { + lookup_table_unlink(lookup_table, lte); + free_lookup_table_entry(lte); + } + return 0; +} + +/* API function documented in wimlib.h */ +WIMLIBAPI int +wimlib_reference_resources(WIMStruct *wim, + WIMStruct **resource_wims, unsigned num_resource_wims, + int ref_flags) +{ + int ret; + unsigned i; + + if (wim == NULL) + return WIMLIB_ERR_INVALID_PARAM; + + if (num_resource_wims != 0 && resource_wims == NULL) + return WIMLIB_ERR_INVALID_PARAM; + + for (i = 0; i < num_resource_wims; i++) + if (resource_wims[i] == NULL) + return WIMLIB_ERR_INVALID_PARAM; + + for_lookup_table_entry(wim->lookup_table, lte_zero_out_refcnt, NULL); + + for (i = 0; i < num_resource_wims; i++) { + ret = for_lookup_table_entry(resource_wims[i]->lookup_table, + lte_clone_if_new, + wim->lookup_table); + if (ret) + goto out_rollback; + } + return 0; + +out_rollback: + for_lookup_table_entry(wim->lookup_table, lte_delete_if_new, + wim->lookup_table); + return ret; +} + +static int +reference_resource_paths(WIMStruct *wim, + const tchar * const *resource_wimfiles, + unsigned num_resource_wimfiles, + int ref_flags, + int open_flags, + wimlib_progress_func_t progress_func) +{ + WIMStruct **resource_wims; + unsigned i; + int ret; + + resource_wims = CALLOC(num_resource_wimfiles, sizeof(resource_wims[0])); + if (!resource_wims) + return WIMLIB_ERR_NOMEM; + + for (i = 0; i < num_resource_wimfiles; i++) { + DEBUG("Referencing resources from path \"%"TS"\"", + resource_wimfiles[i]); + ret = wimlib_open_wim(resource_wimfiles[i], open_flags, + &resource_wims[i], progress_func); + if (ret) + goto out_free_resource_wims; + } + + ret = wimlib_reference_resources(wim, resource_wims, + num_resource_wimfiles, ref_flags); + if (ret) + goto out_free_resource_wims; + + for (i = 0; i < num_resource_wimfiles; i++) + list_add_tail(&resource_wims[i]->subwim_node, &wim->subwims); + + ret = 0; + goto out_free_array; + +out_free_resource_wims: + for (i = 0; i < num_resource_wimfiles; i++) + wimlib_free(resource_wims[i]); +out_free_array: + FREE(resource_wims); + return ret; +} + +static int +reference_resource_glob(WIMStruct *wim, const tchar *refglob, + int ref_flags, int open_flags, + wimlib_progress_func_t progress_func) +{ + glob_t globbuf; + int ret; + + /* Note: glob() is replaced in Windows native builds. */ + ret = tglob(refglob, GLOB_ERR | GLOB_NOSORT, NULL, &globbuf); + if (ret) { + if (ret == GLOB_NOMATCH) { + if (ref_flags & WIMLIB_REF_FLAG_GLOB_ERR_ON_NOMATCH) { + ERROR("Found no files for glob \"%"TS"\"", refglob); + return WIMLIB_ERR_GLOB_HAD_NO_MATCHES; + } else { + return reference_resource_paths(wim, + &refglob, + 1, + ref_flags, + open_flags, + progress_func); + } + } else { + ERROR_WITH_ERRNO("Failed to process glob \"%"TS"\"", refglob); + if (ret == GLOB_NOSPACE) + return WIMLIB_ERR_NOMEM; + else + return WIMLIB_ERR_READ; + } + } + + ret = reference_resource_paths(wim, + (const tchar * const *)globbuf.gl_pathv, + globbuf.gl_pathc, + ref_flags, + open_flags, + progress_func); + globfree(&globbuf); + return ret; +} + +/* API function documented in wimlib.h */ +WIMLIBAPI int +wimlib_reference_resource_files(WIMStruct *wim, + const tchar * const * resource_wimfiles_or_globs, + unsigned count, + int ref_flags, + int open_flags, + wimlib_progress_func_t progress_func) +{ + unsigned i; + int ret; + + if (ref_flags & WIMLIB_REF_FLAG_GLOB_ENABLE) { + for (i = 0; i < count; i++) { + ret = reference_resource_glob(wim, + resource_wimfiles_or_globs[i], + ref_flags, + open_flags, + progress_func); + if (ret) + return ret; + } + return 0; + } else { + return reference_resource_paths(wim, resource_wimfiles_or_globs, + count, ref_flags, + open_flags, progress_func); + } +}