X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fverify.c;h=41fcff789919f1b60a0e888ad3598a8a21fb4e37;hb=88afc46984c143cbf928a3186f8cc93d819e9269;hp=a83b1d3b0bcbaf03c414c729d9a0462389c951b2;hpb=de3839d65d8e60296533f46c57c07a88f7f08b73;p=wimlib diff --git a/src/verify.c b/src/verify.c index a83b1d3b..41fcff78 100644 --- a/src/verify.c +++ b/src/verify.c @@ -7,135 +7,81 @@ /* * Copyright (C) 2012, 2013, 2014 Eric Biggers * - * This file is part of wimlib, a library for working with WIM files. + * This file is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 3 of the License, or (at your option) any + * later version. * - * wimlib is free software; you can redistribute it and/or modify it under the - * terms of the GNU General Public License as published by the Free - * Software Foundation; either version 3 of the License, or (at your option) - * any later version. - * - * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY - * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU General Public License for more + * This file is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * - * You should have received a copy of the GNU General Public License - * along with wimlib; if not, see http://www.gnu.org/licenses/. + * You should have received a copy of the GNU Lesser General Public License + * along with this file; if not, see http://www.gnu.org/licenses/. */ #ifdef HAVE_CONFIG_H # 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) -{ - 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) +append_blob_to_list(struct blob_descriptor *blob, 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; }; static int -end_verify_stream(struct wim_lookup_table_entry *lte, int status, void *_ctx) +verify_continue_blob(const struct blob_descriptor *blob, u64 offset, + const void *chunk, size_t size, void *_ctx) { - struct verify_stream_list_ctx *ctx = _ctx; + struct verify_blob_list_ctx *ctx = _ctx; + union wimlib_progress_info *progress = ctx->progress; + + if (offset + size == blob->size) + progress->verify_streams.completed_streams++; + + progress->verify_streams.completed_bytes += size; - if (status) - return status; + if (progress->verify_streams.completed_bytes >= ctx->next_progress) { - ctx->progress->verify_streams.completed_streams++; - ctx->progress->verify_streams.completed_bytes += lte->size; + int ret = call_progress(ctx->progfunc, + WIMLIB_PROGRESS_MSG_VERIFY_STREAMS, + progress, ctx->progctx); + if (ret) + return ret; - return call_progress(ctx->progfunc, WIMLIB_PROGRESS_MSG_VERIFY_STREAMS, - ctx->progress, ctx->progctx); + set_next_progress(progress->verify_streams.completed_bytes, + progress->verify_streams.total_bytes, + &ctx->next_progress); + } + 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; } @@ -147,13 +93,13 @@ 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 = { + .continue_blob = verify_continue_blob, + .ctx = &ctx, }; /* Check parameters */ @@ -185,8 +131,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; @@ -200,29 +146,29 @@ 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; ctx.progctx = wim->progctx; ctx.progress = &progress; + ctx.next_progress = 0; ret = call_progress(ctx.progfunc, WIMLIB_PROGRESS_MSG_VERIFY_STREAMS, ctx.progress, ctx.progctx); 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); }