X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fverify.c;h=1ca5be46d57a9c3c41696e4291e2765f5346f9b1;hb=26a90546f2a8ded51376d631e5a13f3d7a84f8dc;hp=a83b1d3b0bcbaf03c414c729d9a0462389c951b2;hpb=de3839d65d8e60296533f46c57c07a88f7f08b73;p=wimlib

diff --git a/src/verify.c b/src/verify.c
index a83b1d3b..1ca5be46 100644
--- a/src/verify.c
+++ b/src/verify.c
@@ -7,135 +7,100 @@
 /*
  * 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)
+append_blob_to_list(struct blob_descriptor *blob, void *_list)
 {
-	if (lte->refcnt != lte->real_refcnt) {
-		lte->refcnt = lte->real_refcnt;
-		++*(unsigned long *)ctr;
-	}
+	list_add(&blob->extraction_list, (struct list_head *)_list);
 	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;
-	}
-}
-
+struct verify_blob_list_ctx {
+	wimlib_progress_func_t progfunc;
+	void *progctx;
+	union wimlib_progress_info *progress;
+	u64 next_progress;
+};
 
 static int
-tally_image_refcnts(WIMStruct *wim)
+end_verify_blob(struct blob_descriptor *blob, int status, void *_ctx)
 {
-	const struct wim_image_metadata *imd;
-	const struct wim_inode *inode;
+	struct verify_blob_list_ctx *ctx = _ctx;
+	union wimlib_progress_info *progress = ctx->progress;
 
-	imd = wim_get_current_image_metadata(wim);
-	image_for_each_inode(inode, imd)
-		tally_inode_refcnts(inode, wim->lookup_table);
-	return 0;
-}
+	if (status)
+		return status;
 
+	progress->verify_streams.completed_streams++;
+	progress->verify_streams.completed_bytes += blob->size;
 
-/* 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;
+	/* Handle rate-limiting of progress messages  */
 
-	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(&lte->extraction_list, (struct list_head *)_list);
-	return 0;
-}
-
-struct verify_stream_list_ctx {
-	wimlib_progress_func_t progfunc;
-	void *progctx;
-	union wimlib_progress_info *progress;
-};
+	if (progress->verify_streams.completed_bytes < ctx->next_progress)
+		return 0;
 
-static int
-end_verify_stream(struct wim_lookup_table_entry *lte, int status, void *_ctx)
-{
-	struct verify_stream_list_ctx *ctx = _ctx;
+	/* Time for another progress message.  */
 
+	status = call_progress(ctx->progfunc, WIMLIB_PROGRESS_MSG_VERIFY_STREAMS,
+			       progress, ctx->progctx);
 	if (status)
 		return status;
 
-	ctx->progress->verify_streams.completed_streams++;
-	ctx->progress->verify_streams.completed_bytes += lte->size;
+	if (ctx->next_progress == progress->verify_streams.total_bytes) {
+		ctx->next_progress = ~(u64)0;
+		return 0;
+	}
+
+	/* 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;
 
-	return call_progress(ctx->progfunc, WIMLIB_PROGRESS_MSG_VERIFY_STREAMS,
-			     ctx->progress, ctx->progctx);
+	/* ... 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;
 	}
@@ -147,13 +112,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 = {
+		.end_blob	= end_verify_blob,
+		.ctx		= &ctx,
 	};
 
 	/* Check parameters  */
@@ -185,8 +150,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 +165,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);
 }