X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fverify.c;h=e11561efcf790021799ea9f4193924f38f5f4146;hb=a5f60b5a884906945b841457874c83e609b016af;hp=c06e7029d6cb145f43bbc9ea18eba0ac3c1c6236;hpb=4c73e29d8d74a4e969782d2d40e209337414034c;p=wimlib

diff --git a/src/verify.c b/src/verify.c
index c06e7029..e11561ef 100644
--- a/src/verify.c
+++ b/src/verify.c
@@ -25,82 +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
-append_lte_to_list(struct wim_lookup_table_entry *lte, void *_list)
+append_blob_to_list(struct blob_descriptor *blob, void *_list)
 {
-	list_add(&lte->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;
 	}
@@ -112,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  */
@@ -150,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;
 
@@ -165,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;
@@ -187,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);
 }