X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fverify.c;h=a83b1d3b0bcbaf03c414c729d9a0462389c951b2;hb=dd95b601226f4c508252ad3cd7c7a2887ee48486;hp=a9de114642138b6aa1bbcb2c9b1f8b012c0366e6;hpb=1c19875f1bcbfe341014b20b9bbbc9b5fa0cea4d;p=wimlib diff --git a/src/verify.c b/src/verify.c index a9de1146..a83b1d3b 100644 --- a/src/verify.c +++ b/src/verify.c @@ -1,11 +1,11 @@ /* * verify.c * - * Verify WIM inodes and stream reference counts. + * Verify WIM files. */ /* - * Copyright (C) 2012, 2013 Eric Biggers + * Copyright (C) 2012, 2013, 2014 Eric Biggers * * This file is part of wimlib, a library for working with WIM files. * @@ -31,86 +31,13 @@ #include "wimlib/error.h" #include "wimlib/lookup_table.h" #include "wimlib/metadata.h" +#include "wimlib/progress.h" #include "wimlib/security.h" -/* - * Verify a WIM inode: - * - * - Check to make sure the security ID is valid - * - Check to make sure there is at most one unnamed stream - * - Check to make sure there is at most one DOS name. - * - * Return values: - * WIMLIB_ERR_SUCCESS (0) - */ -int -verify_inode(struct wim_inode *inode, const struct wim_security_data *sd) -{ - struct wim_dentry *dentry; - - /* Check the security ID. -1 is valid and means "no security - * descriptor". Anything else has to be a valid index into the WIM - * image's security descriptors table. */ - if (inode->i_security_id < -1 || - (inode->i_security_id >= 0 && - inode->i_security_id >= sd->num_entries)) - { - WARNING("\"%"TS"\" has an invalid security ID (%d)", - inode_first_full_path(inode), inode->i_security_id); - inode->i_security_id = -1; - } - - /* Make sure there is only one unnamed data stream. */ - unsigned num_unnamed_streams = 0; - for (unsigned i = 0; i <= inode->i_num_ads; i++) { - const u8 *hash; - hash = inode_stream_hash(inode, i); - if (inode_stream_name_nbytes(inode, i) == 0 && !is_zero_hash(hash)) - num_unnamed_streams++; - } - if (num_unnamed_streams > 1) { - WARNING("\"%"TS"\" has multiple (%u) un-named streams", - inode_first_full_path(inode), num_unnamed_streams); - } - - /* Files cannot have multiple DOS names, even if they have multiple - * names in multiple directories (i.e. hard links). - * Source: NTFS-3g authors. */ - struct wim_dentry *dentry_with_dos_name = NULL; - inode_for_each_dentry(dentry, inode) { - if (dentry_has_short_name(dentry)) { - if (dentry_with_dos_name) { - /* This was previously an error, but if we - * capture a WIM from UDF on Windows, hard links - * are supported but DOS names are automatically - * generated for all names for an inode. */ - #if 0 - ERROR("Hard-linked file has a DOS name at " - "both `%"TS"' and `%"TS"'", - dentry_full_path(dentry_with_dos_name), - dentry_full_path(dentry)); - return WIMLIB_ERR_INVALID_METADATA_RESOURCE; - #else - dentry->dos_name_invalid = 1; - #endif - } - dentry_with_dos_name = dentry; - } - } - return 0; -} - static int lte_fix_refcnt(struct wim_lookup_table_entry *lte, void *ctr) { if (lte->refcnt != lte->real_refcnt) { - if (wimlib_print_errors) { - WARNING("The following lookup table entry has a reference " - "count of %u, but", lte->refcnt); - WARNING("We found %u references to it", - lte->real_refcnt); - print_lookup_table_entry(lte, stderr); - } lte->refcnt = lte->real_refcnt; ++*(unsigned long *)ctr; } @@ -165,11 +92,137 @@ wim_recalculate_refcnts(WIMStruct *wim) for_lookup_table_entry(wim->lookup_table, lte_fix_refcnt, &num_ltes_with_bogus_refcnt); if (num_ltes_with_bogus_refcnt != 0) { - WARNING("A total of %lu entries in the WIM's stream " - "lookup table had to have\n" - " their reference counts fixed.", + WARNING("%lu stream(s) had incorrect reference count.", num_ltes_with_bogus_refcnt); } wim->refcnts_ok = 1; return 0; } + +static int +append_lte_to_list(struct wim_lookup_table_entry *lte, void *_list) +{ + list_add(<e->extraction_list, (struct list_head *)_list); + return 0; +} + +struct verify_stream_list_ctx { + wimlib_progress_func_t progfunc; + void *progctx; + union wimlib_progress_info *progress; +}; + +static int +end_verify_stream(struct wim_lookup_table_entry *lte, int status, void *_ctx) +{ + struct verify_stream_list_ctx *ctx = _ctx; + + if (status) + return status; + + ctx->progress->verify_streams.completed_streams++; + ctx->progress->verify_streams.completed_bytes += lte->size; + + return call_progress(ctx->progfunc, WIMLIB_PROGRESS_MSG_VERIFY_STREAMS, + ctx->progress, ctx->progctx); +} + +static int +verify_image_streams_present(struct wim_image_metadata *imd, + struct wim_lookup_table *lookup_table) +{ + struct wim_inode *inode; + int ret; + + image_for_each_inode(inode, imd) { + ret = inode_resolve_streams(inode, lookup_table, false); + if (ret) + return ret; + } + return 0; +} + +/* API function documented in wimlib.h */ +WIMLIBAPI int +wimlib_verify_wim(WIMStruct *wim, int verify_flags) +{ + int ret; + LIST_HEAD(stream_list); + union wimlib_progress_info progress; + struct verify_stream_list_ctx ctx; + struct wim_lookup_table_entry *lte; + struct read_stream_list_callbacks cbs = { + .end_stream = end_verify_stream, + .end_stream_ctx = &ctx, + }; + + /* Check parameters */ + + if (!wim) + return WIMLIB_ERR_INVALID_PARAM; + + if (verify_flags) + return WIMLIB_ERR_INVALID_PARAM; + + /* Verify the images */ + + if (wim_has_metadata(wim)) { + + memset(&progress, 0, sizeof(progress)); + progress.verify_image.wimfile = wim->filename; + progress.verify_image.total_images = wim->hdr.image_count; + + for (int i = 1; i <= wim->hdr.image_count; i++) { + + progress.verify_image.current_image = i; + + ret = call_progress(wim->progfunc, WIMLIB_PROGRESS_MSG_BEGIN_VERIFY_IMAGE, + &progress, wim->progctx); + if (ret) + return ret; + + ret = select_wim_image(wim, i); + if (ret) + return ret; + + ret = verify_image_streams_present(wim_get_current_image_metadata(wim), + wim->lookup_table); + if (ret) + return ret; + + ret = call_progress(wim->progfunc, WIMLIB_PROGRESS_MSG_END_VERIFY_IMAGE, + &progress, wim->progctx); + if (ret) + return ret; + } + } else { + WARNING("\"%"TS"\" does not contain image metadata. Skipping image verification.", + wim->filename); + } + + /* Verify the streams */ + + for_lookup_table_entry(wim->lookup_table, append_lte_to_list, &stream_list); + + memset(&progress, 0, sizeof(progress)); + + progress.verify_streams.wimfile = wim->filename; + list_for_each_entry(lte, &stream_list, extraction_list) { + progress.verify_streams.total_streams++; + progress.verify_streams.total_bytes += lte->size; + } + + ctx.progfunc = wim->progfunc; + ctx.progctx = wim->progctx; + ctx.progress = &progress; + + ret = call_progress(ctx.progfunc, WIMLIB_PROGRESS_MSG_VERIFY_STREAMS, + ctx.progress, ctx.progctx); + if (ret) + return ret; + + return read_stream_list(&stream_list, + offsetof(struct wim_lookup_table_entry, + extraction_list), + &cbs, VERIFY_STREAM_HASHES); +}