X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fintegrity.c;h=0054c40219a381f954a36bd08c31becb3d924394;hp=bbabaea289a2680180f227284c4b867ae9af3323;hb=21da2526eff64cdb8e3cb509d34af182d764c701;hpb=650997e4865a090b6856c7ca34b02f42994e8e29 diff --git a/src/integrity.c b/src/integrity.c index bbabaea2..0054c402 100644 --- a/src/integrity.c +++ b/src/integrity.c @@ -9,31 +9,40 @@ /* * Copyright (C) 2012, 2013 Eric Biggers * - * This file is part of wimlib, a library for working with WIM files. - * - * 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 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. + * + * 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/. */ -#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/endianness.h" +#include "wimlib/error.h" +#include "wimlib/file_io.h" +#include "wimlib/integrity.h" +#include "wimlib/progress.h" +#include "wimlib/resource.h" +#include "wimlib/sha1.h" +#include "wimlib/wim.h" +#include "wimlib/write.h" /* Size, in bytes, of each SHA1-summed chunk, when wimlib writes integrity * information. */ #define INTEGRITY_CHUNK_SIZE 10485760 -/* Only use a different chunk size for compatiblity with an existing integrity +/* Only use a different chunk size for compatibility with an existing integrity * table if the chunk size is between these two numbers. */ #define INTEGRITY_MIN_CHUNK_SIZE 4096 #define INTEGRITY_MAX_CHUNK_SIZE 134217728 @@ -42,44 +51,32 @@ struct integrity_table { u32 size; u32 num_entries; u32 chunk_size; - u8 sha1sums[0][20]; -}; + u8 sha1sums[][20]; +} _packed_attribute; static int -calculate_chunk_sha1(FILE *fp, size_t this_chunk_size, +calculate_chunk_sha1(struct filedes *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; + int ret; - 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); - 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"); - } - return WIMLIB_ERR_READ; + ret = full_pread(in_fd, buf, bytes_to_read, offset); + if (ret) { + ERROR_WITH_ERRNO("Read error while calculating " + "integrity checksums"); + return ret; } - sha1_update(&ctx, buf, bytes_read); - bytes_remaining -= bytes_read; + sha1_update(&ctx, buf, bytes_to_read); + bytes_remaining -= bytes_to_read; + offset += bytes_to_read; } while (bytes_remaining); sha1_final(sha1_md, &ctx); return 0; @@ -89,115 +86,59 @@ calculate_chunk_sha1(FILE *fp, size_t this_chunk_size, /* * 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. + * @wim: + * WIMStruct for the WIM file; @wim->hdr.integrity_table_reshdr specifies + * the location of the integrity table. @wim->in_fd is expected to be a + * seekable 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. - * - * @table ret: - * On success, a pointer to an in-memory structure containing the integrity - * information is written to this location. - * - * Returns 0 on success; nonzero on failure. The possible error codes are: - * - * * WIMLIB_ERR_INVALID_INTEGRITY_TABLE: The integrity table is invalid. - * * WIMLIB_ERR_NOMEM: Could not allocate memory to store the integrity - * data. - * * WIMLIB_ERR_READ: Could not read the integrity data from the WIM file. + * Number of bytes of data that should be checked by the integrity table. + * + * @table_ret: + * On success, a pointer to an in-memory structure containing the integrity + * information is written to this location. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_INVALID_INTEGRITY_TABLE + * WIMLIB_ERR_NOMEM + * WIMLIB_ERR_READ + * WIMLIB_ERR_UNEXPECTED_END_OF_FILE */ -static int -read_integrity_table(const struct resource_entry *res_entry, - FILE *fp, - u64 num_checked_bytes, +int +read_integrity_table(WIMStruct *wim, 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 (resource_is_compressed(res_entry)) { - ERROR("Didn't expect a compressed integrity table"); - return WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - } - - 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 ((table = MALLOC(res_entry->size)) == NULL) { - ERROR("Can't allocate %"PRIu64" bytes for integrity table", - (u64)res_entry->size); - return WIMLIB_ERR_NOMEM; - } + void *buf; + struct integrity_table *table; + int ret; - ret = read_uncompressed_resource(fp, res_entry->offset, - res_entry->size, (void*)table); + if (wim->hdr.integrity_table_reshdr.uncompressed_size < 8) + goto invalid; - if (ret != 0) { - ERROR("Failed to read integrity table (size = %u, " - " offset = %"PRIu64")", - (unsigned)res_entry->size, res_entry->offset); - goto out; - } + ret = wim_reshdr_to_data(&wim->hdr.integrity_table_reshdr, wim, &buf); + if (ret) + return ret; + table = buf; table->size = le32_to_cpu(table->size); table->num_entries = le32_to_cpu(table->num_entries); table->chunk_size = le32_to_cpu(table->chunk_size); - if (table->size != res_entry->size) { - ERROR("Inconsistent integrity table sizes: Table header says " - "%u bytes but resource entry says %u bytes", - table->size, (unsigned)res_entry->size); - ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - goto out; - } - - DEBUG("table->size = %u, table->num_entries = %u, " - "table->chunk_size = %u", - table->size, table->num_entries, table->chunk_size); - - expected_size = (u64)table->num_entries * SHA1_HASH_SIZE + 12; - - if (table->size != expected_size) { - ERROR("Integrity table is %u bytes, but expected %"PRIu64" " - "bytes to hold %u entries", - table->size, expected_size, table->num_entries); - ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - goto out; + if (table->size != wim->hdr.integrity_table_reshdr.uncompressed_size || + table->size != (u64)table->num_entries * SHA1_HASH_SIZE + 12 || + table->chunk_size == 0 || + table->num_entries != DIV_ROUND_UP(num_checked_bytes, table->chunk_size)) + { + FREE(table); + goto invalid; } - if (table->chunk_size == 0) { - ERROR("Cannot use integrity chunk size of 0"); - ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - goto out; - } + *table_ret = table; + return 0; - expected_num_entries = DIV_ROUND_UP(num_checked_bytes, table->chunk_size); - - if (table->num_entries != expected_num_entries) { - 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", - table->chunk_size, table->num_entries); - ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - } -out: - if (ret == 0) - *table_ret = table; - else - FREE(table); - return ret; +invalid: + return WIMLIB_ERR_INVALID_INTEGRITY_TABLE; } /* @@ -206,40 +147,41 @@ out: * 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. + * Offset of byte after the last byte to be checked. * * @old_table: - * If non-NULL, a pointer to the table containing the previously calculated - * integrity data for a prefix of this file. + * 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. - * - * @progress_func: - * If non-NULL, a progress function that will be called after every - * calculated chunk. + * 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. * * @integrity_table_ret: - * On success, a pointer to the calculated integrity table is written into - * this location. - * - * Returns 0 on success; nonzero on failure. + * On success, a pointer to the calculated integrity table is written into + * this location. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_NOMEM + * WIMLIB_ERR_READ + * WIMLIB_ERR_UNEXPECTED_END_OF_FILE */ static int -calculate_integrity_table(FILE *fp, +calculate_integrity_table(struct filedes *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) + struct integrity_table **integrity_table_ret, + wimlib_progress_func_t progfunc, + void *progctx) { - 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 @@ -275,16 +217,17 @@ calculate_integrity_table(FILE *fp, 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); - } + 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; + + ret = call_progress(progfunc, WIMLIB_PROGRESS_MSG_CALC_INTEGRITY, + &progress, progctx); + if (ret) + goto out_free_new_table; for (u32 i = 0; i < new_num_chunks; i++) { size_t this_chunk_size; @@ -301,23 +244,25 @@ 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) + goto out_free_new_table; } 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); - } + + progress.integrity.completed_chunks++; + progress.integrity.completed_bytes += this_chunk_size; + ret = call_progress(progfunc, WIMLIB_PROGRESS_MSG_CALC_INTEGRITY, + &progress, progctx); + if (ret) + goto out_free_new_table; } - if (ret == 0) - *integrity_table_ret = new_table; - else - FREE(new_table); + *integrity_table_ret = new_table; + return 0; + +out_free_new_table: + FREE(new_table); return ret; } @@ -328,80 +273,45 @@ calculate_integrity_table(FILE *fp, * chunks of the file). * * This function can optionally re-use entries from an older integrity table. - * To do this, make @integrity_res_entry point to the resource entry for the - * older table (note: this is an input-output parameter), and set - * @old_lookup_table_end to the offset of the byte directly following the last - * byte checked by the old table. If the old integrity table is invalid or - * cannot be read, a warning is printed and the integrity information is - * re-calculated. + * To do this, specify old_blob_table_end and old_table. * - * @fp: - * FILE * to the WIM file, opened read-write, positioned at the location at - * which the integrity table is to be written. + * On success, @wim->out_hdr.integrity_table_reshdr will be filled in with + * information about the integrity table that was written. * - * @integrity_res_entry: - * Resource entry which will be set to point to the integrity table on - * success. In addition, if @old_lookup_table_end != 0, this initially - * must point to the resource entry for the old integrity table for the - * WIM. + * @wim: + * WIMStruct for the WIM file. @wim->out_fd must be a seekable descriptor + * to the new WIM file, opened read-write, positioned at the location at + * which the integrity table is to be written. * - * @new_lookup_table_end: - * The offset of the byte directly following the lookup table in the WIM - * being written. + * @new_blob_table_end: + * The offset of the byte directly following the blob table in the WIM + * being written. * - * @old_lookup_table_end: - * If nonzero, the offset of the byte directly following the old lookup - * table in the WIM. + * @old_blob_table_end: + * If nonzero, the offset of the byte directly following the old blob table + * in the WIM. * - * @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_WRITE: Could not write the integrity table. - * * WIMLIB_ERR_READ: Could not read a chunk of data that needed - * to be checked. + * @old_table + * Pointer to the old integrity table read into memory, or NULL if not + * specified. */ 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) +write_integrity_table(WIMStruct *wim, + off_t new_blob_table_end, + off_t old_blob_table_end, + struct integrity_table *old_table) { - struct integrity_table *old_table; struct integrity_table *new_table; int ret; - 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) - 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, - old_lookup_table_end - WIM_HEADER_DISK_SIZE, - &old_table); - if (ret == WIMLIB_ERR_INVALID_INTEGRITY_TABLE) { - WARNING("Old integrity table is invalid! " - "Ignoring it"); - } else if (ret != 0) { - WARNING("Can't read old integrity table! " - "Ignoring it"); - } - } + wimlib_assert(old_blob_table_end <= new_blob_table_end); - ret = calculate_integrity_table(fp, new_lookup_table_end, - old_table, old_lookup_table_end, - progress_func, &new_table); - if (ret != 0) - goto out_free_old_table; + ret = calculate_integrity_table(&wim->out_fd, new_blob_table_end, + old_table, old_blob_table_end, + &new_table, wim->progfunc, wim->progctx); + if (ret) + return ret; new_table_size = new_table->size; @@ -409,27 +319,16 @@ 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) { - ERROR_WITH_ERRNO("Failed to write WIM integrity table"); - ret = WIMLIB_ERR_WRITE; - } else { - integrity_res_entry->offset = cur_offset; - integrity_res_entry->size = new_table_size; - integrity_res_entry->original_size = new_table_size; - integrity_res_entry->flags = 0; - ret = 0; - } -out_free_new_table: + ret = write_wim_resource_from_buffer(new_table, + new_table_size, + false, + &wim->out_fd, + WIMLIB_COMPRESSION_TYPE_NONE, + 0, + &wim->out_hdr.integrity_table_reshdr, + NULL, + 0); FREE(new_table); -out_free_old_table: - FREE(old_table); return ret; } @@ -438,47 +337,45 @@ out_free_old_table: * * 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. + * The integrity table for the WIM, read into memory. * * @bytes_to_check: - * 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). - * - * @progress_func - * If non-NULL, a progress function that will be called after every - * verified chunk. + * Number of bytes in the WIM that need to be checked (offset of end of the + * blob table minus offset of end of the header). * * Returns: - * > 0 (WIMLIB_ERR_*) on error - * 0 (WIM_INTEGRITY_OK) if the integrity was checked successfully and there - * were no inconsistencies. - * -1 (WIM_INTEGRITY_NOT_OK) if the WIM failed the integrity check. + * > 0 (WIMLIB_ERR_READ, WIMLIB_ERR_UNEXPECTED_END_OF_FILE) on error + * 0 (WIM_INTEGRITY_OK) if the integrity was checked successfully and there + * were no inconsistencies. + * -1 (WIM_INTEGRITY_NOT_OK) if the WIM failed the integrity check. */ static int -verify_integrity(FILE *fp, const tchar *filename, +verify_integrity(struct filedes *in_fd, const tchar *filename, const struct integrity_table *table, u64 bytes_to_check, - wimlib_progress_func_t progress_func) + wimlib_progress_func_t progfunc, void *progctx) { 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); - } + 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; + + ret = call_progress(progfunc, WIMLIB_PROGRESS_MSG_VERIFY_INTEGRITY, + &progress, progctx); + if (ret) + return ret; + for (u32 i = 0; i < table->num_entries; i++) { size_t this_chunk_size; if (i == table->num_entries - 1) @@ -487,20 +384,21 @@ verify_integrity(FILE *fp, const tchar *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])) return WIM_INTEGRITY_NOT_OK; 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); - } + progress.integrity.completed_chunks++; + progress.integrity.completed_bytes += this_chunk_size; + + ret = call_progress(progfunc, WIMLIB_PROGRESS_MSG_VERIFY_INTEGRITY, + &progress, progctx); + if (ret) + return ret; } return WIM_INTEGRITY_OK; } @@ -513,50 +411,44 @@ verify_integrity(FILE *fp, const tchar *filename, * ~10 MiB chunks of the WIM match up with the values given in the integrity * table. * - * @w: - * The WIM, opened for reading, and with the header already read. - * - * @progress_func - * If non-NULL, a progress function that will be called after every - * verified chunk. + * @wim: + * The WIM, opened for reading. * * Returns: - * > 0 (WIMLIB_ERR_*) on error - * 0 (WIM_INTEGRITY_OK) if the integrity was checked successfully and there - * were no inconsistencies. - * -1 (WIM_INTEGRITY_NOT_OK) if the WIM failed the integrity check. - * -2 (WIM_INTEGRITY_NONEXISTENT) if the WIM contains no integrity - * information. + * > 0 (WIMLIB_ERR_INVALID_INTEGRITY_TABLE, WIMLIB_ERR_READ, + * WIMLIB_ERR_UNEXPECTED_END_OF_FILE) on error + * 0 (WIM_INTEGRITY_OK) if the integrity was checked successfully and there + * were no inconsistencies. + * -1 (WIM_INTEGRITY_NOT_OK) if the WIM failed the integrity check. + * -2 (WIM_INTEGRITY_NONEXISTENT) if the WIM contains no integrity + * information. */ int -check_wim_integrity(WIMStruct *w, wimlib_progress_func_t progress_func) +check_wim_integrity(WIMStruct *wim) { int ret; u64 bytes_to_check; struct integrity_table *table; - u64 end_lookup_table_offset; + u64 end_blob_table_offset; - if (w->hdr.integrity.offset == 0) { - DEBUG("No integrity information."); + if (!wim_has_integrity_table(wim)) return WIM_INTEGRITY_NONEXISTENT; - } - end_lookup_table_offset = w->hdr.lookup_table_res_entry.offset + - w->hdr.lookup_table_res_entry.size; + end_blob_table_offset = wim->hdr.blob_table_reshdr.offset_in_wim + + wim->hdr.blob_table_reshdr.size_in_wim; - if (end_lookup_table_offset < WIM_HEADER_DISK_SIZE) { - ERROR("WIM lookup table ends before WIM header ends!"); + if (end_blob_table_offset < WIM_HEADER_DISK_SIZE) { + ERROR("WIM blob table ends before WIM header ends!"); return WIMLIB_ERR_INVALID_INTEGRITY_TABLE; } - bytes_to_check = end_lookup_table_offset - WIM_HEADER_DISK_SIZE; + bytes_to_check = end_blob_table_offset - WIM_HEADER_DISK_SIZE; - ret = read_integrity_table(&w->hdr.integrity, w->fp, - bytes_to_check, &table); - if (ret != 0) + ret = read_integrity_table(wim, bytes_to_check, &table); + if (ret) return ret; - ret = verify_integrity(w->fp, w->filename, table, - bytes_to_check, progress_func); + ret = verify_integrity(&wim->in_fd, wim->filename, table, + bytes_to_check, wim->progfunc, wim->progctx); FREE(table); return ret; }