#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"
* WIMLIB_ERR_READ
* WIMLIB_ERR_UNEXPECTED_END_OF_FILE
*/
-static int
+int
read_integrity_table(WIMStruct *wim, u64 num_checked_bytes,
struct integrity_table **table_ret)
{
return 0;
invalid:
- ERROR("Integrity table is invalid");
return WIMLIB_ERR_INVALID_INTEGRITY_TABLE;
}
* 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.
- *
* @integrity_table_ret:
* On success, a pointer to the calculated integrity table is written into
* this location.
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;
size_t chunk_size = INTEGRITY_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);
- }
+ 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;
/* Calculate the SHA1 message digest of this chunk */
ret = calculate_chunk_sha1(in_fd, this_chunk_size,
offset, new_table->sha1sums[i]);
- if (ret) {
- FREE(new_table);
- return ret;
- }
+ 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;
}
*integrity_table_ret = new_table;
return 0;
+
+out_free_new_table:
+ FREE(new_table);
+ return ret;
}
/*
* chunks of the file).
*
* This function can optionally re-use entries from an older integrity table.
- * To do this, ensure that @wim->hdr.integrity_table_reshdr is the resource
- * header 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_lookup_table_end and old_table.
*
* @wim:
* WIMStruct for the WIM file. @wim->out_fd must be a seekable descriptor
* If nonzero, the offset of the byte directly following the old lookup
* table in the WIM.
*
- * @progress_func
- * If non-NULL, a progress function that will be called after every
- * calculated chunk.
- *
- * Return values:
- * WIMLIB_ERR_SUCCESS (0)
- * WIMLIB_ERR_NOMEM
- * WIMLIB_ERR_UNEXPECTED_END_OF_FILE
- * WIMLIB_ERR_WRITE
+ * @old_table
+ * Pointer to the old integrity table read into memory, or NULL if not
+ * specified.
*/
int
write_integrity_table(WIMStruct *wim,
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 *old_table;
struct integrity_table *new_table;
int ret;
u32 new_table_size;
wimlib_assert(old_lookup_table_end <= new_lookup_table_end);
- old_table = NULL;
- if (wim_has_integrity_table(wim) && old_lookup_table_end != 0) {
- ret = read_integrity_table(wim,
- 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");
- }
- }
-
ret = calculate_integrity_table(&wim->out_fd, new_lookup_table_end,
old_table, old_lookup_table_end,
- progress_func, &new_table);
+ &new_table, wim->progfunc, wim->progctx);
if (ret)
- goto out_free_old_table;
+ return ret;
new_table_size = new_table->size;
NULL,
0);
FREE(new_table);
-out_free_old_table:
- FREE(old_table);
DEBUG("ret=%d", ret);
return ret;
}
* 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.
- *
* Returns:
* > 0 (WIMLIB_ERR_READ, WIMLIB_ERR_UNEXPECTED_END_OF_FILE) on error
* 0 (WIM_INTEGRITY_OK) if the integrity was checked successfully and there
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)
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;
}
* @wim:
* The WIM, opened for reading.
*
- * @progress_func
- * If non-NULL, a progress function that will be called after every
- * verified chunk.
- *
* Returns:
* > 0 (WIMLIB_ERR_INVALID_INTEGRITY_TABLE, WIMLIB_ERR_READ,
* WIMLIB_ERR_UNEXPECTED_END_OF_FILE) on error
* information.
*/
int
-check_wim_integrity(WIMStruct *wim, wimlib_progress_func_t progress_func)
+check_wim_integrity(WIMStruct *wim)
{
int ret;
u64 bytes_to_check;
if (ret)
return ret;
ret = verify_integrity(&wim->in_fd, wim->filename, table,
- bytes_to_check, progress_func);
+ bytes_to_check, wim->progfunc, wim->progctx);
FREE(table);
return ret;
}
git://wimlib.net / wimlib / blobdiff