X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fverify.c;h=e11561efcf790021799ea9f4193924f38f5f4146;hp=6ee918f4c04bb4188a7f32dfdccc52121672b423;hb=3537ce00e3c430545c9abf57498d33a2ca5f216f;hpb=3071e89c11d1be71cf45b694432e5908e0c4ded9 diff --git a/src/verify.c b/src/verify.c index 6ee918f4..e11561ef 100644 --- a/src/verify.c +++ b/src/verify.c @@ -25,147 +25,75 @@ # include "config.h" #endif +#include "wimlib/blob_table.h" #include "wimlib/dentry.h" #include "wimlib/error.h" -#include "wimlib/lookup_table.h" #include "wimlib/metadata.h" #include "wimlib/progress.h" #include "wimlib/security.h" static int -lte_fix_refcnt(struct wim_lookup_table_entry *lte, void *ctr) +append_blob_to_list(struct blob_descriptor *blob, void *_list) { - if (lte->refcnt != lte->real_refcnt) { - lte->refcnt = lte->real_refcnt; - ++*(unsigned long *)ctr; - } - return 0; -} - -static void -tally_inode_refcnts(const struct wim_inode *inode, - const struct wim_lookup_table *lookup_table) -{ - for (unsigned i = 0; i <= inode->i_num_ads; i++) { - struct wim_lookup_table_entry *lte; - lte = inode_stream_lte(inode, i, lookup_table); - if (lte) - lte->real_refcnt += inode->i_nlink; - } -} - - -static int -tally_image_refcnts(WIMStruct *wim) -{ - const struct wim_image_metadata *imd; - const struct wim_inode *inode; - - imd = wim_get_current_image_metadata(wim); - image_for_each_inode(inode, imd) - tally_inode_refcnts(inode, wim->lookup_table); - return 0; -} - - -/* Ideally this would be unnecessary... however, the WIMs for Windows 8 are - * screwed up because some lookup table entries are referenced more times than - * their stated reference counts. So theoretically, if we delete all the - * references to a stream and then remove it, it might still be referenced - * somewhere else, making a file be missing from the WIM... So, work around this - * problem by looking at ALL the images to re-calculate the reference count of - * EVERY lookup table entry. This only absolutely has to be done before an image - * is deleted or before an image is mounted read-write. */ -int -wim_recalculate_refcnts(WIMStruct *wim) -{ - unsigned long num_ltes_with_bogus_refcnt = 0; - int ret; - - for_lookup_table_entry(wim->lookup_table, lte_zero_real_refcnt, NULL); - ret = for_image(wim, WIMLIB_ALL_IMAGES, tally_image_refcnts); - if (ret) - return ret; - num_ltes_with_bogus_refcnt = 0; - for_lookup_table_entry(wim->lookup_table, lte_fix_refcnt, - &num_ltes_with_bogus_refcnt); - if (num_ltes_with_bogus_refcnt != 0) { - WARNING("%lu stream(s) had incorrect reference count.", - num_ltes_with_bogus_refcnt); - } - wim->refcnts_ok = 1; - return 0; -} - -static int -append_lte_to_list(struct wim_lookup_table_entry *lte, void *_list) -{ - list_add(<e->extraction_list, (struct list_head *)_list); + list_add(&blob->extraction_list, (struct list_head *)_list); return 0; } -struct verify_stream_list_ctx { +struct verify_blob_list_ctx { wimlib_progress_func_t progfunc; void *progctx; union wimlib_progress_info *progress; u64 next_progress; + u64 cur_blob_offset; + u64 cur_blob_size; }; static int -end_verify_stream(struct wim_lookup_table_entry *lte, int status, void *_ctx) +verify_begin_blob(struct blob_descriptor *blob, void *_ctx) { - struct verify_stream_list_ctx *ctx = _ctx; - union wimlib_progress_info *progress = ctx->progress; + struct verify_blob_list_ctx *ctx = _ctx; - if (status) - return status; + ctx->cur_blob_offset = 0; + ctx->cur_blob_size = blob->size; + return 0; +} - progress->verify_streams.completed_streams++; - progress->verify_streams.completed_bytes += lte->size; +static int +verify_consume_chunk(const void *chunk, size_t size, void *_ctx) +{ + struct verify_blob_list_ctx *ctx = _ctx; + union wimlib_progress_info *progress = ctx->progress; - /* Handle rate-limiting of progress messages */ + ctx->cur_blob_offset += size; + if (ctx->cur_blob_offset == ctx->cur_blob_size) + progress->verify_streams.completed_streams++; - if (progress->verify_streams.completed_bytes < ctx->next_progress) - return 0; + progress->verify_streams.completed_bytes += size; - /* Time for another progress message. */ + if (progress->verify_streams.completed_bytes >= ctx->next_progress) { - status = call_progress(ctx->progfunc, WIMLIB_PROGRESS_MSG_VERIFY_STREAMS, - progress, ctx->progctx); - if (status) - return status; + int ret = call_progress(ctx->progfunc, + WIMLIB_PROGRESS_MSG_VERIFY_STREAMS, + progress, ctx->progctx); + if (ret) + return ret; - if (ctx->next_progress == progress->verify_streams.total_bytes) { - ctx->next_progress = ~(uint64_t)0; - return 0; + set_next_progress(progress->verify_streams.completed_bytes, + progress->verify_streams.total_bytes, + &ctx->next_progress); } - - /* Send new message as soon as another 1/128 of the total has - * been verified. (Arbitrary number.) */ - ctx->next_progress = progress->verify_streams.completed_bytes + - progress->verify_streams.total_bytes / 128; - - /* ... Unless that would be more than 5000000 bytes, in which case send - * the next after the next 5000000 bytes. (Another arbitrary number.) */ - if (progress->verify_streams.completed_bytes + 5000000 < ctx->next_progress) - ctx->next_progress = progress->verify_streams.completed_bytes + 5000000; - - /* ... But always send a message as soon as we're completely - * done. */ - if (progress->verify_streams.total_bytes < ctx->next_progress) - ctx->next_progress = progress->verify_streams.total_bytes; return 0; } static int -verify_image_streams_present(struct wim_image_metadata *imd, - struct wim_lookup_table *lookup_table) +verify_file_data_present(struct wim_image_metadata *imd, + struct blob_table *blob_table) { struct wim_inode *inode; int ret; image_for_each_inode(inode, imd) { - ret = inode_resolve_streams(inode, lookup_table, false); + ret = inode_resolve_streams(inode, blob_table, false); if (ret) return ret; } @@ -177,13 +105,14 @@ WIMLIBAPI int wimlib_verify_wim(WIMStruct *wim, int verify_flags) { int ret; - LIST_HEAD(stream_list); + LIST_HEAD(blob_list); union wimlib_progress_info progress; - struct verify_stream_list_ctx ctx; - struct wim_lookup_table_entry *lte; - struct read_stream_list_callbacks cbs = { - .end_stream = end_verify_stream, - .end_stream_ctx = &ctx, + struct verify_blob_list_ctx ctx; + struct blob_descriptor *blob; + struct read_blob_callbacks cbs = { + .begin_blob = verify_begin_blob, + .consume_chunk = verify_consume_chunk, + .ctx = &ctx, }; /* Check parameters */ @@ -215,8 +144,8 @@ wimlib_verify_wim(WIMStruct *wim, int verify_flags) if (ret) return ret; - ret = verify_image_streams_present(wim_get_current_image_metadata(wim), - wim->lookup_table); + ret = verify_file_data_present(wim_get_current_image_metadata(wim), + wim->blob_table); if (ret) return ret; @@ -230,16 +159,16 @@ wimlib_verify_wim(WIMStruct *wim, int verify_flags) wim->filename); } - /* Verify the streams */ + /* Verify the blobs: SHA-1 message digests must match */ - for_lookup_table_entry(wim->lookup_table, append_lte_to_list, &stream_list); + for_blob_in_table(wim->blob_table, append_blob_to_list, &blob_list); memset(&progress, 0, sizeof(progress)); progress.verify_streams.wimfile = wim->filename; - list_for_each_entry(lte, &stream_list, extraction_list) { + list_for_each_entry(blob, &blob_list, extraction_list) { progress.verify_streams.total_streams++; - progress.verify_streams.total_bytes += lte->size; + progress.verify_streams.total_bytes += blob->size; } ctx.progfunc = wim->progfunc; @@ -252,8 +181,7 @@ wimlib_verify_wim(WIMStruct *wim, int verify_flags) if (ret) return ret; - return read_stream_list(&stream_list, - offsetof(struct wim_lookup_table_entry, - extraction_list), - &cbs, VERIFY_STREAM_HASHES); + return read_blob_list(&blob_list, + offsetof(struct blob_descriptor, extraction_list), + &cbs, VERIFY_BLOB_HASHES); }