/*
* 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.
*
*/
#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
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];
/*
- * 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.
* 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;
}
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;
}
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",
}
/*
+ * calculate_integrity_table():
+ *
* Calculates an integrity table for the data in a file beginning at offset 208
* (WIM_HEADER_DISK_SIZE).
*
* 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
*
* 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;
/* 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
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;
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)))
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).
*
* 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:
* * 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;
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;
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;
}
/*
+ * verify_integrity():
+ *
* Checks a WIM for consistency with the integrity table.
*
* @fp:
* 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
* 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)
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
* -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;
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;
}
git://wimlib.net / wimlib / blobdiff