#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. */
* read_integrity_table: - Reads the integrity table from a WIM file.
*
* @wim:
- * WIMStruct for the WIM file; @wim->hdr.integrity specifies the location
- * of the integrity table. The integrity table must exist (i.e.
- * res_entry->offset must not be 0). @wim->in_fd is expected to be a
+ * 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:
struct integrity_table *table;
int ret;
- if (wim->hdr.integrity.size < 8)
+ if (wim->hdr.integrity_table_reshdr.uncompressed_size < 8)
goto invalid;
- DEBUG("Reading integrity table (offset %"PRIu64", "
- "original_size %"PRIu64")",
- wim->hdr.integrity.offset, wim->hdr.integrity.original_size);
+ DEBUG("Reading integrity table.");
- ret = res_entry_to_data(&wim->hdr.integrity, wim, &buf);
+ ret = wim_reshdr_to_data(&wim->hdr.integrity_table_reshdr, wim, &buf);
if (ret)
return ret;
table = buf;
"table->chunk_size = %u",
table->size, table->num_entries, table->chunk_size);
- if (table->size != wim->hdr.integrity.original_size ||
+ 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))
* 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, make @integrity_res_entry point to the resource entry for the
- * older table (note: this is an input-output parameter), and set
+ * 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
* 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
int
write_integrity_table(WIMStruct *wim,
off_t new_lookup_table_end,
- off_t old_lookup_table_end,
- wimlib_progress_func_t progress_func)
+ off_t old_lookup_table_end)
{
struct integrity_table *old_table;
struct integrity_table *new_table;
int ret;
u32 new_table_size;
+ DEBUG("Writing integrity table "
+ "(new_lookup_table_end=%"PRIu64", old_lookup_table_end=%"PRIu64")",
+ new_lookup_table_end, old_lookup_table_end);
+
wimlib_assert(old_lookup_table_end <= new_lookup_table_end);
old_table = NULL;
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;
0,
&wim->out_fd,
WIMLIB_COMPRESSION_TYPE_NONE,
- &wim->hdr.integrity,
- NULL,
0,
- &wim->lzx_context);
+ &wim->hdr.integrity_table_reshdr,
+ 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;
return WIM_INTEGRITY_NONEXISTENT;
}
- end_lookup_table_offset = wim->hdr.lookup_table_res_entry.offset +
- wim->hdr.lookup_table_res_entry.size;
+ end_lookup_table_offset = wim->hdr.lookup_table_reshdr.offset_in_wim +
+ wim->hdr.lookup_table_reshdr.size_in_wim;
if (end_lookup_table_offset < WIM_HEADER_DISK_SIZE) {
ERROR("WIM lookup table ends before WIM header ends!");
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