X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fintegrity.c;h=0af6fdddeb9687f4881e2f352538148cb91addd8;hp=837a1d8dbbdc1a117ddc32848f1409c651656b56;hb=e8c3ca2d1d0cac3d64985b45a9f654d2029a7518;hpb=fea0ee9f10fbcb85ff56ca06510e96186a7611ae

diff --git a/src/integrity.c b/src/integrity.c
index 837a1d8d..0af6fddd 100644
--- a/src/integrity.c
+++ b/src/integrity.c
@@ -3,11 +3,11 @@
  *
  * 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 this table.
+ * 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.
  *
@@ -25,9 +25,18 @@
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
-#include "wimlib_internal.h"
-#include "buffer_io.h"
-#include "sha1.h"
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "wimlib/assert.h"
+#include "wimlib/buffer_io.h"
+#include "wimlib/error.h"
+#include "wimlib/file_io.h"
+#include "wimlib/integrity.h"
+#include "wimlib/resource.h"
+#include "wimlib/sha1.h"
+#include "wimlib/wim.h"
 
 /* Size, in bytes, of each SHA1-summed chunk, when wimlib writes integrity
  * information. */
@@ -45,40 +54,29 @@ 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(int in_fd, size_t this_chunk_size,
+		     off_t offset, u8 sha1_md[])
 {
-	int ret;
 	u8 buf[BUFFER_SIZE];
 	SHA_CTX ctx;
 	size_t bytes_remaining;
 	size_t bytes_to_read;
 	size_t bytes_read;
 
-	ret = fseeko(fp, offset, SEEK_SET);
-	if (ret != 0) {
-		ERROR_WITH_ERRNO("Can't seek to offset "
-				 "%"PRIu64" in WIM", offset);
-		return WIMLIB_ERR_READ;
-	}
 	bytes_remaining = this_chunk_size;
 	sha1_init(&ctx);
 	do {
 		bytes_to_read = min(bytes_remaining, sizeof(buf));
-		bytes_read = fread(buf, 1, bytes_to_read, fp);
+		bytes_read = full_pread(in_fd, buf, bytes_to_read, offset);
 		if (bytes_read != bytes_to_read) {
-			if (feof(fp)) {
-				ERROR("Unexpected EOF while calculating "
-				      "integrity checksums");
-			} else {
-				ERROR_WITH_ERRNO("File stream error while "
-						 "calculating integrity "
-						 "checksums");
-			}
+			ERROR_WITH_ERRNO("Read error while calculating "
+					 "integrity checksums");
 			return WIMLIB_ERR_READ;
 		}
 		sha1_update(&ctx, buf, bytes_read);
 		bytes_remaining -= bytes_read;
+		offset += bytes_read;
 	} while (bytes_remaining);
 	sha1_final(sha1_md, &ctx);
 	return 0;
@@ -86,14 +84,14 @@ 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.
  * 	The integrity table must exist (i.e. res_entry->offset must not be 0).
  *
- * @fp:
- * 	FILE * to the WIM file, opened for reading.
+ * @in_fd:
+ * 	File descriptor to the WIM file, opened for reading.
  *
  * @num_checked_bytes:
  * 	Number of bytes of data that should be checked by the integrity table.
@@ -109,13 +107,14 @@ 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,
+		     int in_fd,
+		     u64 num_checked_bytes,
+		     struct integrity_table **table_ret)
 {
-	struct integrity_table *table = NULL;
-	int ret = 0;
+	struct integrity_table *table;
+	int ret;
 	u64 expected_size;
 	u64 expected_num_entries;
 
@@ -130,20 +129,21 @@ static int read_integrity_table(const struct resource_entry *res_entry,
 	}
 
 	/* Read the integrity table into memory. */
-	if ((table = MALLOC(res_entry->size)) == NULL) {
-		ERROR("Can't allocate %"PRIu64" bytes for integrity table",
-		      (u64)res_entry->size);
+	table = MALLOC((size_t)res_entry->size);
+	if (table == NULL) {
+		ERROR("Can't allocate %zu bytes for integrity table",
+		      (size_t)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 = %u, "
+	if (full_pread(in_fd, table, res_entry->size,
+		       res_entry->offset) != res_entry->size)
+	{
+		ERROR("Failed to read integrity table (size = %zu, "
 		      " offset = %"PRIu64")",
-		      (unsigned)res_entry->size, res_entry->offset);
-		goto out;
+		      (size_t)res_entry->size, res_entry->offset);
+		ret = WIMLIB_ERR_READ;
+		goto out_free_table;
 	}
 
 	table->size        = le32_to_cpu(table->size);
@@ -155,7 +155,7 @@ static int read_integrity_table(const struct resource_entry *res_entry,
 		      "%u bytes but resource entry says %u bytes",
 		      table->size, (unsigned)res_entry->size);
 		ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
-		goto out;
+		goto out_free_table;
 	}
 
 	DEBUG("table->size = %u, table->num_entries = %u, "
@@ -169,13 +169,13 @@ static int read_integrity_table(const struct resource_entry *res_entry,
 		      "bytes to hold %u entries",
 		      table->size, expected_size, table->num_entries);
 		ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
-		goto out;
+		goto out_free_table;
 	}
 
 	if (table->chunk_size == 0) {
 		ERROR("Cannot use integrity chunk size of 0");
 		ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
-		goto out;
+		goto out_free_table;
 	}
 
 	expected_num_entries = DIV_ROUND_UP(num_checked_bytes, table->chunk_size);
@@ -189,28 +189,32 @@ static int read_integrity_table(const struct resource_entry *res_entry,
 		      "there were only %u entries",
 		      table->chunk_size, table->num_entries);
 		ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
+		goto out_free_table;
 	}
+	*table_ret = table;
+	ret = 0;
+	goto out;
+out_free_table:
+	FREE(table);
 out:
-	if (ret == 0)
-		*table_ret = table;
-	else
-		FREE(table);
 	return ret;
 }
 
 /*
+ * calculate_integrity_table():
+ *
  * Calculates an integrity table for the data in a file beginning at offset 208
  * (WIM_HEADER_DISK_SIZE).
  *
- * @fp:
- * 	FILE * for the file to be checked, opened for reading.  Does not need to
- * 	be at any specific location in the file.
+ * @in_fd:
+ * 	File descriptor for the file to be checked, opened for reading.  Does
+ * 	not need to be at any specific location in the file.
  *
  * @new_check_end:
  * 	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:
@@ -227,14 +231,15 @@ 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,
-				     wimlib_progress_func_t progress_func,
-				     struct integrity_table **integrity_table_ret)
+static int
+calculate_integrity_table(int in_fd,
+			  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;
+	int ret;
 	size_t chunk_size = INTEGRITY_CHUNK_SIZE;
 
 	/* If an old table is provided, set the chunk size to be compatible with
@@ -296,10 +301,12 @@ static int calculate_integrity_table(FILE *fp,
 			copy_hash(new_table->sha1sums[i], old_table->sha1sums[i]);
 		} else {
 			/* Calculate the SHA1 message digest of this chunk */
-			ret = calculate_chunk_sha1(fp, this_chunk_size,
+			ret = calculate_chunk_sha1(in_fd, this_chunk_size,
 						   offset, new_table->sha1sums[i]);
-			if (ret != 0)
-				break;
+			if (ret) {
+				FREE(new_table);
+				return ret;
+			}
 		}
 		offset += this_chunk_size;
 		if (progress_func) {
@@ -309,14 +316,13 @@ static int calculate_integrity_table(FILE *fp,
 				      &progress);
 		}
 	}
-	if (ret == 0)
-		*integrity_table_ret = new_table;
-	else
-		FREE(new_table);
-	return ret;
+	*integrity_table_ret = new_table;
+	return 0;
 }
 
 /*
+ * write_integrity_table():
+ *
  * Writes a WIM integrity table (a list of SHA1 message digests of raw 10 MiB
  * chunks of the file).
  *
@@ -328,9 +334,9 @@ static int calculate_integrity_table(FILE *fp,
  * cannot be read, a warning is printed and the integrity information is
  * re-calculated.
  *
- * @fp:
- * 	FILE * to the WIM file, opened read-write, positioned at the location at
- * 	which the integrity table is to be written.
+ * @fd:
+ * 	File descriptor to the WIM file, opened read-write, positioned at the
+ * 	location at which the integrity table is to be written.
  *
  * @integrity_res_entry:
  * 	Resource entry which will be set to point to the integrity table on
@@ -356,11 +362,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,
-			  wimlib_progress_func_t progress_func)
+int
+write_integrity_table(int fd,
+		      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;
@@ -370,14 +377,14 @@ int write_integrity_table(FILE *fp,
 
 	wimlib_assert(old_lookup_table_end <= new_lookup_table_end);
 
-	cur_offset = ftello(fp);
+	cur_offset = filedes_offset(fd);
 	if (cur_offset == -1)
 		return WIMLIB_ERR_WRITE;
 
 	if (integrity_res_entry->offset == 0 || old_lookup_table_end == 0) {
 		old_table = NULL;
 	} else {
-		ret = read_integrity_table(integrity_res_entry, fp,
+		ret = read_integrity_table(integrity_res_entry, fd,
 					   old_lookup_table_end - WIM_HEADER_DISK_SIZE,
 					   &old_table);
 		if (ret == WIMLIB_ERR_INVALID_INTEGRITY_TABLE) {
@@ -389,10 +396,10 @@ int write_integrity_table(FILE *fp,
 		}
 	}
 
-	ret = calculate_integrity_table(fp, new_lookup_table_end,
+	ret = calculate_integrity_table(fd, new_lookup_table_end,
 					old_table, old_lookup_table_end,
 					progress_func, &new_table);
-	if (ret != 0)
+	if (ret)
 		goto out_free_old_table;
 
 	new_table_size = new_table->size;
@@ -401,14 +408,7 @@ int write_integrity_table(FILE *fp,
 	new_table->num_entries = cpu_to_le32(new_table->num_entries);
 	new_table->chunk_size  = cpu_to_le32(new_table->chunk_size);
 
-	if (fseeko(fp, cur_offset, SEEK_SET) != 0) {
-		ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" of WIM to "
-				 "write integrity table", cur_offset);
-		ret = WIMLIB_ERR_WRITE;
-		goto out_free_new_table;
-	}
-
-	if (fwrite(new_table, 1, new_table_size, fp) != new_table_size) {
+	if (full_write(fd, new_table, new_table_size) != new_table_size) {
 		ERROR_WITH_ERRNO("Failed to write WIM integrity table");
 		ret = WIMLIB_ERR_WRITE;
 	} else {
@@ -418,7 +418,6 @@ int write_integrity_table(FILE *fp,
 		integrity_res_entry->flags         = 0;
 		ret = 0;
 	}
-out_free_new_table:
 	FREE(new_table);
 out_free_old_table:
 	FREE(old_table);
@@ -426,10 +425,12 @@ out_free_old_table:
 }
 
 /*
+ * verify_integrity():
+ *
  * Checks a WIM for consistency with the integrity table.
  *
- * @fp:
- * 	FILE * to the WIM file, opened for reading.
+ * @in_fd:
+ * 	File descriptor to the WIM file, opened for reading.
  *
  * @table:
  * 	The integrity table for the WIM, read into memory.
@@ -448,10 +449,11 @@ 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 char *filename,
-			    const struct integrity_table *table,
-			    u64 bytes_to_check,
-			    wimlib_progress_func_t progress_func)
+static int
+verify_integrity(int in_fd, 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;
@@ -476,8 +478,8 @@ static int verify_integrity(FILE *fp, const char *filename,
 		else
 			this_chunk_size = table->chunk_size;
 
-		ret = calculate_chunk_sha1(fp, this_chunk_size, offset, sha1_md);
-		if (ret != 0)
+		ret = calculate_chunk_sha1(in_fd, this_chunk_size, offset, sha1_md);
+		if (ret)
 			return ret;
 
 		if (!hashes_equal(sha1_md, table->sha1sums[i]))
@@ -496,6 +498,8 @@ static int verify_integrity(FILE *fp, const char *filename,
 
 
 /*
+ * 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
  * table.
@@ -515,7 +519,8 @@ static int verify_integrity(FILE *fp, const char *filename,
  * 	-2 (WIM_INTEGRITY_NONEXISTENT) if the WIM contains no integrity
  * 	information.
  */
-int check_wim_integrity(WIMStruct *w, wimlib_progress_func_t progress_func)
+int
+check_wim_integrity(WIMStruct *w, wimlib_progress_func_t progress_func)
 {
 	int ret;
 	u64 bytes_to_check;
@@ -537,11 +542,11 @@ int check_wim_integrity(WIMStruct *w, wimlib_progress_func_t progress_func)
 
 	bytes_to_check = end_lookup_table_offset - WIM_HEADER_DISK_SIZE;
 
-	ret = read_integrity_table(&w->hdr.integrity, w->fp,
+	ret = read_integrity_table(&w->hdr.integrity, w->in_fd,
 				   bytes_to_check, &table);
-	if (ret != 0)
+	if (ret)
 		return ret;
-	ret = verify_integrity(w->fp, w->filename, table,
+	ret = verify_integrity(w->in_fd, w->filename, table,
 			       bytes_to_check, progress_func);
 	FREE(table);
 	return ret;