X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fintegrity.c;h=bbabaea289a2680180f227284c4b867ae9af3323;hp=bf02a6b108ecf58ebe6ca4a453cb6346fd2a1e7c;hb=9e2571b03cd9c71d11b3dad9ea5dcfa43f50deb4;hpb=0541069de2f74283d44ebb02372b60fb608795f2

diff --git a/src/integrity.c b/src/integrity.c
index bf02a6b1..bbabaea2 100644
--- a/src/integrity.c
+++ b/src/integrity.c
@@ -1,13 +1,13 @@
 /*
  * integrity.c
  *
- * WIM files can optionally contain an array of SHA1 message digests at the end,
- * one digest for each 1 MB of the file.  This file implements the checking of
- * the digests, and the writing of the digests for new WIM files.
+ * WIM files can optionally contain a table of SHA1 message digests at the end,
+ * one digest for each chunk of the file of some specified size (often 10 MB).
+ * This file implements the checking and writing of this table.
  */
 
 /*
- * Copyright (C) 2012 Eric Biggers
+ * Copyright (C) 2012, 2013 Eric Biggers
  *
  * This file is part of wimlib, a library for working with WIM files.
  *
@@ -26,7 +26,7 @@
  */
 
 #include "wimlib_internal.h"
-#include "io.h"
+#include "buffer_io.h"
 #include "sha1.h"
 
 /* Size, in bytes, of each SHA1-summed chunk, when wimlib writes integrity
@@ -45,8 +45,9 @@ struct integrity_table {
 	u8  sha1sums[0][20];
 };
 
-static int calculate_chunk_sha1(FILE *fp, size_t this_chunk_size,
-				off_t offset, u8 sha1_md[])
+static int
+calculate_chunk_sha1(FILE *fp, size_t this_chunk_size,
+		     off_t offset, u8 sha1_md[])
 {
 	int ret;
 	u8 buf[BUFFER_SIZE];
@@ -86,7 +87,7 @@ static int calculate_chunk_sha1(FILE *fp, size_t this_chunk_size,
 
 
 /*
- * Reads the integrity table from a WIM file.
+ * read_integrity_table: -  Reads the integrity table from a WIM file.
  *
  * @res_entry:
  * 	The resource entry that specifies the location of the integrity table.
@@ -109,46 +110,41 @@ static int calculate_chunk_sha1(FILE *fp, size_t this_chunk_size,
  *     			    data.
  *     * WIMLIB_ERR_READ:   Could not read the integrity data from the WIM file.
  */
-static int read_integrity_table(const struct resource_entry *res_entry,
-				FILE *fp,
-				u64 num_checked_bytes,
-				struct integrity_table **table_ret)
+static int
+read_integrity_table(const struct resource_entry *res_entry,
+		     FILE *fp,
+		     u64 num_checked_bytes,
+		     struct integrity_table **table_ret)
 {
 	struct integrity_table *table = NULL;
 	int ret = 0;
 	u64 expected_size;
 	u64 expected_num_entries;
 
-	if (res_entry->original_size < 12) {
-		ERROR("Integrity table is too short (expected at least 12 bytes)");
-		ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
-		goto out;
+	if (resource_is_compressed(res_entry)) {
+		ERROR("Didn't expect a compressed integrity table");
+		return WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
 	}
 
-	if (res_entry->flags & WIM_RESHDR_FLAG_COMPRESSED) {
-		ERROR("Didn't expect a compressed integrity table");
-		ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
-		goto out;
+	if (res_entry->size < 8 || res_entry->size  > 0xffffffff) {
+		ERROR("Integrity table resource header is invalid");
+		return WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
 	}
 
 	/* Read the integrity table into memory. */
-	if ((sizeof(size_t) < sizeof(u64)
-	    && res_entry->size > ~(size_t)0)
-	    || ((table = MALLOC(res_entry->size)) == NULL))
-	{
-		ERROR("Out of memory (needed %zu bytes for integrity table)",
-		      (size_t)res_entry->size);
-		ret = WIMLIB_ERR_NOMEM;
-		goto out;
+	if ((table = MALLOC(res_entry->size)) == NULL) {
+		ERROR("Can't allocate %"PRIu64" bytes for integrity table",
+		      (u64)res_entry->size);
+		return WIMLIB_ERR_NOMEM;
 	}
 
 	ret = read_uncompressed_resource(fp, res_entry->offset,
 					 res_entry->size, (void*)table);
 
 	if (ret != 0) {
-		ERROR("Failed to read integrity table (size = %"PRIu64", "
+		ERROR("Failed to read integrity table (size = %u, "
 		      " offset = %"PRIu64")",
-		      (u64)res_entry->size, res_entry->offset);
+		      (unsigned)res_entry->size, res_entry->offset);
 		goto out;
 	}
 
@@ -158,8 +154,8 @@ static int read_integrity_table(const struct resource_entry *res_entry,
 
 	if (table->size != res_entry->size) {
 		ERROR("Inconsistent integrity table sizes: Table header says "
-		      "%u bytes but resource entry says %"PRIu64" bytes",
-		      table->size, (u64)res_entry->size);
+		      "%u bytes but resource entry says %u bytes",
+		      table->size, (unsigned)res_entry->size);
 		ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
 		goto out;
 	}
@@ -187,8 +183,9 @@ static int read_integrity_table(const struct resource_entry *res_entry,
 	expected_num_entries = DIV_ROUND_UP(num_checked_bytes, table->chunk_size);
 
 	if (table->num_entries != expected_num_entries) {
-		ERROR("%"PRIu64" entries would be required to checksum "
-		      "the %"PRIu64" bytes from the end of the header to the",
+		ERROR("%"PRIu64" integrity table entries would be required "
+		      "to checksum the %"PRIu64" bytes from the end of the "
+		      "header to the",
 		      expected_num_entries, num_checked_bytes);
 		ERROR("end of the lookup table with a chunk size of %u, but "
 		      "there were only %u entries",
@@ -204,6 +201,8 @@ out:
 }
 
 /*
+ * calculate_integrity_table():
+ *
  * Calculates an integrity table for the data in a file beginning at offset 208
  * (WIM_HEADER_DISK_SIZE).
  *
@@ -215,16 +214,16 @@ out:
  * 	Offset of byte after the last byte to be checked.
  *
  * @old_table:
- * 	If non-NULL, a pointer to the table containing previously contained
+ * 	If non-NULL, a pointer to the table containing the previously calculated
  * 	integrity data for a prefix of this file.
  *
  * @old_check_end:
  * 	If @old_table is non-NULL, the byte after the last byte that was checked
  * 	in the old table.  Must be less than or equal to new_check_end.
  *
- * @show_progress:
- * 	True if progress information is to be shown while calculating the
- * 	integrity data.
+ * @progress_func:
+ * 	If non-NULL, a progress function that will be called after every
+ * 	calculated chunk.
  *
  * @integrity_table_ret:
  * 	On success, a pointer to the calculated integrity table is written into
@@ -232,12 +231,13 @@ out:
  *
  * Returns 0 on success; nonzero on failure.
  */
-static int calculate_integrity_table(FILE *fp,
-				     off_t new_check_end,
-				     const struct integrity_table *old_table,
-				     off_t old_check_end,
-				     bool show_progress,
-				     struct integrity_table **integrity_table_ret)
+static int
+calculate_integrity_table(FILE *fp,
+			  off_t new_check_end,
+			  const struct integrity_table *old_table,
+			  off_t old_check_end,
+			  wimlib_progress_func_t progress_func,
+			  struct integrity_table **integrity_table_ret)
 {
 	int ret = 0;
 	size_t chunk_size = INTEGRITY_CHUNK_SIZE;
@@ -245,7 +245,8 @@ static int calculate_integrity_table(FILE *fp,
 	/* If an old table is provided, set the chunk size to be compatible with
 	 * the old chunk size, unless the old chunk size was weird. */
 	if (old_table != NULL) {
-		if (old_table->chunk_size < INTEGRITY_MIN_CHUNK_SIZE ||
+		if (old_table->num_entries == 0 ||
+		    old_table->chunk_size < INTEGRITY_MIN_CHUNK_SIZE ||
 		    old_table->chunk_size > INTEGRITY_MAX_CHUNK_SIZE)
 			old_table = NULL;
 		else
@@ -272,6 +273,18 @@ static int calculate_integrity_table(FILE *fp,
 	new_table->chunk_size = chunk_size;
 
 	u64 offset = WIM_HEADER_DISK_SIZE;
+	union wimlib_progress_info progress;
+
+	if (progress_func) {
+		progress.integrity.total_bytes      = new_check_bytes;
+		progress.integrity.total_chunks     = new_num_chunks;
+		progress.integrity.completed_chunks = 0;
+		progress.integrity.completed_bytes  = 0;
+		progress.integrity.chunk_size       = chunk_size;
+		progress.integrity.filename         = NULL;
+		progress_func(WIMLIB_PROGRESS_MSG_CALC_INTEGRITY,
+			      &progress);
+	}
 
 	for (u32 i = 0; i < new_num_chunks; i++) {
 		size_t this_chunk_size;
@@ -279,18 +292,6 @@ static int calculate_integrity_table(FILE *fp,
 			this_chunk_size = new_last_chunk_size;
 		else
 			this_chunk_size = chunk_size;
-		if (show_progress) {
-			unsigned percent_done;
-			u64 checked_bytes = offset - WIM_HEADER_DISK_SIZE;
-			percent_done = checked_bytes * 100 / new_check_bytes;
-			printf("\rCalculating integrity checksums for WIM: "
-			       "%"PRIu64" MiB of %"PRIu64" MiB (%u%%) done",
-			       checked_bytes >> 20,
-			       new_check_bytes >> 20,
-			       percent_done);
-			fflush(stdout);
-		}
-
 		if (old_table &&
 		    ((this_chunk_size == chunk_size && i < old_num_chunks - 1) ||
 		      (i == old_num_chunks - 1 && this_chunk_size == old_last_chunk_size)))
@@ -306,21 +307,23 @@ static int calculate_integrity_table(FILE *fp,
 				break;
 		}
 		offset += this_chunk_size;
+		if (progress_func) {
+			progress.integrity.completed_chunks++;
+			progress.integrity.completed_bytes += this_chunk_size;
+			progress_func(WIMLIB_PROGRESS_MSG_CALC_INTEGRITY,
+				      &progress);
+		}
 	}
-	if (ret != 0) {
-		FREE(new_table);
-	} else {
-		printf("\rCalculating integrity checksums for WIM: "
-		       "%"PRIu64" MiB of %"PRIu64" MiB (100%%) done\n",
-		       new_check_bytes >> 20,
-		       new_check_bytes >> 20);
-		fflush(stdout);
+	if (ret == 0)
 		*integrity_table_ret = new_table;
-	}
+	else
+		FREE(new_table);
 	return ret;
 }
 
 /*
+ * write_integrity_table():
+ *
  * Writes a WIM integrity table (a list of SHA1 message digests of raw 10 MiB
  * chunks of the file).
  *
@@ -350,9 +353,9 @@ static int calculate_integrity_table(FILE *fp,
  * 	If nonzero, the offset of the byte directly following the old lookup
  * 	table in the WIM.
  *
- * @show_progress:
- * 	True if progress information is to be shown while writing the integrity
- * 	table.
+ * @progress_func
+ * 	If non-NULL, a progress function that will be called after every
+ * 	calculated chunk.
  *
  * Returns:
  * 	0 on success, nonzero on failure.  The possible error codes are:
@@ -360,11 +363,12 @@ static int calculate_integrity_table(FILE *fp,
  * 	   * WIMLIB_ERR_READ:   Could not read a chunk of data that needed
  * 				to be checked.
  */
-int write_integrity_table(FILE *fp,
-			  struct resource_entry *integrity_res_entry,
-			  off_t new_lookup_table_end,
-			  off_t old_lookup_table_end,
-			  bool show_progress)
+int
+write_integrity_table(FILE *fp,
+		      struct resource_entry *integrity_res_entry,
+		      off_t new_lookup_table_end,
+		      off_t old_lookup_table_end,
+		      wimlib_progress_func_t progress_func)
 {
 	struct integrity_table *old_table;
 	struct integrity_table *new_table;
@@ -372,11 +376,11 @@ int write_integrity_table(FILE *fp,
 	off_t cur_offset;
 	u32 new_table_size;
 
+	wimlib_assert(old_lookup_table_end <= new_lookup_table_end);
+
 	cur_offset = ftello(fp);
-	if (cur_offset == -1) {
-		ERROR_WITH_ERRNO("Failed to get offset in WIM");
+	if (cur_offset == -1)
 		return WIMLIB_ERR_WRITE;
-	}
 
 	if (integrity_res_entry->offset == 0 || old_lookup_table_end == 0) {
 		old_table = NULL;
@@ -395,7 +399,7 @@ int write_integrity_table(FILE *fp,
 
 	ret = calculate_integrity_table(fp, new_lookup_table_end,
 					old_table, old_lookup_table_end,
-					show_progress, &new_table);
+					progress_func, &new_table);
 	if (ret != 0)
 		goto out_free_old_table;
 
@@ -430,6 +434,8 @@ out_free_old_table:
 }
 
 /*
+ * verify_integrity():
+ *
  * Checks a WIM for consistency with the integrity table.
  *
  * @fp:
@@ -442,9 +448,9 @@ out_free_old_table:
  * 	Number of bytes in the WIM that need to be checked (offset of end of the
  * 	lookup table minus offset of end of the header).
  *
- * @show_progress:
- * 	True if progress information is to be shown while checking the
- * 	integrity.
+ * @progress_func
+ * 	If non-NULL, a progress function that will be called after every
+ * 	verified chunk.
  *
  * Returns:
  * 	> 0 (WIMLIB_ERR_*) on error
@@ -452,12 +458,27 @@ out_free_old_table:
  * 	were no inconsistencies.
  * 	-1 (WIM_INTEGRITY_NOT_OK) if the WIM failed the integrity check.
  */
-static int verify_integrity(FILE *fp, const struct integrity_table *table,
-			    u64 bytes_to_check, bool show_progress)
+static int
+verify_integrity(FILE *fp, const tchar *filename,
+		 const struct integrity_table *table,
+		 u64 bytes_to_check,
+		 wimlib_progress_func_t progress_func)
 {
 	int ret;
 	u64 offset = WIM_HEADER_DISK_SIZE;
 	u8 sha1_md[SHA1_HASH_SIZE];
+	union wimlib_progress_info progress;
+
+	if (progress_func) {
+		progress.integrity.total_bytes      = bytes_to_check;
+		progress.integrity.total_chunks     = table->num_entries;
+		progress.integrity.completed_chunks = 0;
+		progress.integrity.completed_bytes  = 0;
+		progress.integrity.chunk_size       = table->chunk_size;
+		progress.integrity.filename         = filename;
+		progress_func(WIMLIB_PROGRESS_MSG_VERIFY_INTEGRITY,
+			      &progress);
+	}
 	for (u32 i = 0; i < table->num_entries; i++) {
 		size_t this_chunk_size;
 		if (i == table->num_entries - 1)
@@ -473,38 +494,31 @@ static int verify_integrity(FILE *fp, const struct integrity_table *table,
 		if (!hashes_equal(sha1_md, table->sha1sums[i]))
 			return WIM_INTEGRITY_NOT_OK;
 
-		if (show_progress) {
-			u64 checked_bytes = offset - WIM_HEADER_DISK_SIZE;
-			unsigned percent_done = checked_bytes * 100 / bytes_to_check;
-			printf("\rVerifying integrity of WIM: "
-			       "%"PRIu64" MiB of %"PRIu64" MiB (%u%%) done",
-			       checked_bytes >> 20,
-			       bytes_to_check >> 20,
-			       percent_done);
-			fflush(stdout);
-		}
 		offset += this_chunk_size;
+		if (progress_func) {
+			progress.integrity.completed_chunks++;
+			progress.integrity.completed_bytes += this_chunk_size;
+			progress_func(WIMLIB_PROGRESS_MSG_VERIFY_INTEGRITY,
+				      &progress);
+		}
 	}
-	printf("\rVerifying integrity of WIM: "
-	       "%"PRIu64" MiB of %"PRIu64" MiB (100%%) done\n",
-	       bytes_to_check >> 20,
-	       bytes_to_check >> 20);
-	fflush(stdout);
 	return WIM_INTEGRITY_OK;
 }
 
 
 /*
+ * check_wim_integrity():
+ *
  * Verifies the integrity of the WIM by making sure the SHA1 message digests of
  * ~10 MiB chunks of the WIM match up with the values given in the integrity
- * tabel.
+ * table.
  *
  * @w:
  * 	The WIM, opened for reading, and with the header already read.
  *
- * @show_progress:
- * 	True if progress information is to be shown while checking the
- * 	integrity.
+ * @progress_func
+ * 	If non-NULL, a progress function that will be called after every
+ * 	verified chunk.
  *
  * Returns:
  * 	> 0 (WIMLIB_ERR_*) on error
@@ -514,7 +528,8 @@ static int verify_integrity(FILE *fp, const struct integrity_table *table,
  * 	-2 (WIM_INTEGRITY_NONEXISTENT) if the WIM contains no integrity
  * 	information.
  */
-int check_wim_integrity(WIMStruct *w, bool show_progress)
+int
+check_wim_integrity(WIMStruct *w, wimlib_progress_func_t progress_func)
 {
 	int ret;
 	u64 bytes_to_check;
@@ -540,7 +555,8 @@ int check_wim_integrity(WIMStruct *w, bool show_progress)
 				   bytes_to_check, &table);
 	if (ret != 0)
 		return ret;
-	ret = verify_integrity(w->fp, table, bytes_to_check, show_progress);
+	ret = verify_integrity(w->fp, w->filename, table,
+			       bytes_to_check, progress_func);
 	FREE(table);
 	return ret;
 }