X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fverify.c;h=d348e302b2d65edfc4ff29ed66e698d875c660ac;hp=62e9547e0e4f947d231fd3920a2a0d7bae530301;hb=9c7e852e60e96935beef11a28b0f010f7e24e863;hpb=16176f3b7ce78da85646e814bd2f3ffe5babb82b diff --git a/src/verify.c b/src/verify.c index 62e9547e..d348e302 100644 --- a/src/verify.c +++ b/src/verify.c @@ -8,8 +8,6 @@ /* * Copyright (C) 2012, 2013 Eric Biggers * - * wimlib - Library for working with WIM files - * * 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 @@ -26,33 +24,34 @@ * along with wimlib; if not, see http://www.gnu.org/licenses/. */ -#include "wimlib_internal.h" -#include "dentry.h" -#include "lookup_table.h" +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "wimlib/dentry.h" +#include "wimlib/error.h" +#include "wimlib/lookup_table.h" +#include "wimlib/metadata.h" +#include "wimlib/security.h" -static int verify_inode(struct wim_inode *inode, const WIMStruct *w) +static int +verify_inode(struct wim_inode *inode, const WIMStruct *w) { const struct wim_lookup_table *table = w->lookup_table; const struct wim_security_data *sd = wim_const_security_data(w); - const struct wim_dentry *first_dentry = inode_first_dentry(inode); - const struct wim_dentry *dentry; - int ret = WIMLIB_ERR_INVALID_DENTRY; + struct wim_dentry *first_dentry = inode_first_dentry(inode); + 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) { - ERROR("Dentry `%s' has an invalid security ID (%d)", - first_dentry->full_path, inode->i_security_id); - goto out; - } - - if (inode->i_security_id >= sd->num_entries) { - ERROR("Dentry `%s' has an invalid security ID (%d) " - "(there are only %u entries in the security table)", - first_dentry->full_path, inode->i_security_id, - sd->num_entries); - goto out; + 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)", + dentry_full_path(first_dentry), inode->i_security_id); + inode->i_security_id = -1; } /* Check that lookup table entries for all the inode's stream exist, @@ -60,57 +59,20 @@ static int verify_inode(struct wim_inode *inode, const WIMStruct *w) * empty stream. * * This check is skipped on split WIMs. */ - if (w->hdr.total_parts == 1) { + if (w->hdr.total_parts == 1 && !inode->i_resolved) { for (unsigned i = 0; i <= inode->i_num_ads; i++) { struct wim_lookup_table_entry *lte; const u8 *hash; - hash = inode_stream_hash_unresolved(inode, i); + hash = inode_stream_hash(inode, i); lte = __lookup_resource(table, hash); if (!lte && !is_zero_hash(hash)) { ERROR("Could not find lookup table entry for stream " - "%u of dentry `%s'", i, first_dentry->full_path); - goto out; + "%u of dentry `%"TS"'", + i, dentry_full_path(first_dentry)); + return WIMLIB_ERR_INVALID_DENTRY; } if (lte) lte->real_refcnt += inode->i_nlink; - - /* The following is now done when required by - * wim_run_full_verifications(). */ - - #if 0 - if (lte && !w->full_verification_in_progress && - lte->real_refcnt > lte->refcnt) - { - #ifdef ENABLE_ERROR_MESSAGES - 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); - WARNING("(One dentry referencing it is at `%s')", - first_dentry->full_path_utf8); - - print_lookup_table_entry(lte); - #endif - /* Guess what! install.wim for Windows 8 - * contains many streams referenced by more - * dentries than the refcnt stated in the lookup - * table entry. So we will need to handle this - * case and not just make it be an error... I'm - * just setting the reference count to the - * number of references we found. - * (Unfortunately, even after doing this, the - * reference count could be too low if it's also - * referenced in other WIM images) */ - - #if 1 - lte->refcnt = lte->real_refcnt; - WARNING("Fixing reference count"); - #else - goto out; - #endif - } - #endif } } @@ -118,56 +80,57 @@ static int verify_inode(struct wim_inode *inode, const WIMStruct *w) unsigned num_unnamed_streams = 0; for (unsigned i = 0; i <= inode->i_num_ads; i++) { const u8 *hash; - hash = inode_stream_hash_unresolved(inode, i); + 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) { - ERROR("Dentry `%s' has multiple (%u) un-named streams", - first_dentry->full_path, num_unnamed_streams); - goto out; + WARNING("\"%"TS"\" has multiple (%u) un-named streams", + dentry_full_path(first_dentry), 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. */ - const struct wim_dentry *dentry_with_dos_name = NULL; + 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 `%s' and `%s'", - dentry_with_dos_name->full_path, - dentry->full_path); - goto out; + "both `%"TS"' and `%"TS"'", + dentry_full_path(dentry_with_dos_name), + dentry_full_path(dentry)); + return WIMLIB_ERR_INVALID_DENTRY; + #else + dentry->dos_name_invalid = 1; + #endif } dentry_with_dos_name = dentry; } } - /* Directories with multiple links have not been tested. XXX */ - if (inode->i_nlink > 1 && inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) { - ERROR("Hard-linked directory `%s' is unsupported", - first_dentry->full_path); - goto out; - } - inode->i_verified = 1; - ret = 0; -out: - return ret; + return 0; } /* Run some miscellaneous verifications on a WIM dentry */ -int verify_dentry(struct wim_dentry *dentry, void *wim) +int +verify_dentry(struct wim_dentry *dentry, void *wim) { int ret; + WIMStruct *w = wim; /* Verify the associated inode, but only one time no matter how many - * dentries it has. */ + * dentries it has (unless we are doing a full verification of the WIM, + * in which case we need to force the inode to be verified again.) */ if (!dentry->d_inode->i_verified) { - ret = verify_inode(dentry->d_inode, wim); - if (ret != 0) + ret = verify_inode(dentry->d_inode, w); + if (ret) return ret; } @@ -180,14 +143,13 @@ int verify_dentry(struct wim_dentry *dentry, void *wim) * (This seems to be the case...) */ if (dentry_is_root(dentry)) { if (dentry_has_long_name(dentry) || dentry_has_short_name(dentry)) { - ERROR("The root dentry has a nonempty name!"); - return WIMLIB_ERR_INVALID_DENTRY; - } - } else { - if (!dentry_has_long_name(dentry)) { - ERROR("Dentry `%s' has no long name!", - dentry->full_path); - return WIMLIB_ERR_INVALID_DENTRY; + WARNING("The root dentry has a nonempty name"); + FREE(dentry->file_name); + FREE(dentry->short_name); + dentry->file_name = NULL; + dentry->short_name = NULL; + dentry->file_name_nbytes = 0; + dentry->short_name_nbytes = 0; } } @@ -195,20 +157,28 @@ int verify_dentry(struct wim_dentry *dentry, void *wim) /* Check timestamps */ if (inode->i_last_access_time < inode->i_creation_time || inode->i_last_write_time < inode->i_creation_time) { - WARNING("Dentry `%s' was created after it was last accessed or " - "written to", dentry->full_path_utf8); + WARNING("Dentry `%"TS"' was created after it was last accessed or " + "written to", dentry->full_path); } #endif return 0; } -static int image_run_full_verifications(WIMStruct *w) +static int +image_run_full_verifications(WIMStruct *w) { - return for_dentry_in_tree(wim_root_dentry(w), verify_dentry, w); + struct wim_image_metadata *imd; + struct wim_inode *inode; + + imd = wim_get_current_image_metadata(w); + image_for_each_inode(inode, imd) + inode->i_verified = 0; + return for_dentry_in_tree(imd->root_dentry, verify_dentry, w); } -static int lte_fix_refcnt(struct wim_lookup_table_entry *lte, void *ctr) +static int +lte_fix_refcnt(struct wim_lookup_table_entry *lte, void *ctr) { if (lte->refcnt != lte->real_refcnt) { #ifdef ENABLE_ERROR_MESSAGES @@ -232,19 +202,18 @@ static int lte_fix_refcnt(struct wim_lookup_table_entry *lte, void *ctr) * problem by looking at ALL the images to re-calculate the reference count of * EVERY lookup table entry. This only absolutely has to be done before an image * is deleted or before an image is mounted read-write. */ -int wim_run_full_verifications(WIMStruct *w) +int +wim_run_full_verifications(WIMStruct *w) { int ret; for_lookup_table_entry(w->lookup_table, lte_zero_real_refcnt, NULL); - w->all_images_verified = 1; - w->full_verification_in_progress = 1; + + w->all_images_verified = 1; /* Set *before* image_run_full_verifications, + because of check in read_metadata_resource() */ ret = for_image(w, WIMLIB_ALL_IMAGES, image_run_full_verifications); - w->full_verification_in_progress = 0; if (ret == 0) { unsigned long num_ltes_with_bogus_refcnt = 0; - for (int i = 0; i < w->hdr.image_count; i++) - w->image_metadata[i].metadata_lte->real_refcnt++; for_lookup_table_entry(w->lookup_table, lte_fix_refcnt, &num_ltes_with_bogus_refcnt); if (num_ltes_with_bogus_refcnt != 0) { @@ -258,111 +227,3 @@ int wim_run_full_verifications(WIMStruct *w) } return ret; } - -/* - * verify_swm_set: - Sanity checks to make sure a set of WIMs correctly - * correspond to a spanned set. - * - * @w: - * Part 1 of the set. - * - * @additional_swms: - * All parts of the set other than part 1. - * - * @num_additional_swms: - * Number of WIMStructs in @additional_swms. Or, the total number of parts - * in the set minus 1. - * - * @return: - * 0 on success; WIMLIB_ERR_SPLIT_INVALID if the set is not valid. - */ -int verify_swm_set(WIMStruct *w, WIMStruct **additional_swms, - unsigned num_additional_swms) -{ - unsigned total_parts = w->hdr.total_parts; - int ctype; - const u8 *guid; - - if (total_parts != num_additional_swms + 1) { - ERROR("`%s' says there are %u parts in the spanned set, " - "but %s%u part%s provided", - w->filename, total_parts, - (num_additional_swms + 1 < total_parts) ? "only " : "", - num_additional_swms + 1, - (num_additional_swms) ? "s were" : " was"); - return WIMLIB_ERR_SPLIT_INVALID; - } - if (w->hdr.part_number != 1) { - ERROR("WIM `%s' is not the first part of the split WIM.", - w->filename); - return WIMLIB_ERR_SPLIT_INVALID; - } - for (unsigned i = 0; i < num_additional_swms; i++) { - if (additional_swms[i]->hdr.total_parts != total_parts) { - ERROR("WIM `%s' says there are %u parts in the spanned set, " - "but %u parts were provided", - additional_swms[i]->filename, - additional_swms[i]->hdr.total_parts, - total_parts); - return WIMLIB_ERR_SPLIT_INVALID; - } - } - - /* keep track of ctype and guid just to make sure they are the same for - * all the WIMs. */ - ctype = wimlib_get_compression_type(w); - guid = w->hdr.guid; - - { - /* parts_to_swms is not allocated at function scope because it - * should only be allocated after num_additional_swms was - * checked to be the same as w->hdr.total_parts. Otherwise, it - * could be unexpectedly high and cause a stack overflow. */ - WIMStruct *parts_to_swms[num_additional_swms]; - ZERO_ARRAY(parts_to_swms); - for (unsigned i = 0; i < num_additional_swms; i++) { - - WIMStruct *swm = additional_swms[i]; - - if (wimlib_get_compression_type(swm) != ctype) { - ERROR("The split WIMs do not all have the same " - "compression type"); - return WIMLIB_ERR_SPLIT_INVALID; - } - if (memcmp(guid, swm->hdr.guid, WIM_GID_LEN) != 0) { - ERROR("The split WIMs do not all have the same " - "GUID"); - return WIMLIB_ERR_SPLIT_INVALID; - } - if (swm->hdr.part_number == 1) { - ERROR("WIMs `%s' and `%s' both are marked as the " - "first WIM in the spanned set", - w->filename, swm->filename); - return WIMLIB_ERR_SPLIT_INVALID; - } - if (swm->hdr.part_number == 0 || - swm->hdr.part_number > total_parts) - { - ERROR("WIM `%s' says it is part %u in the spanned set, " - "but the part number must be in the range " - "[1, %u]", - swm->filename, swm->hdr.part_number, total_parts); - return WIMLIB_ERR_SPLIT_INVALID; - } - if (parts_to_swms[swm->hdr.part_number - 2]) - { - ERROR("`%s' and `%s' are both marked as part %u of %u " - "in the spanned set", - parts_to_swms[swm->hdr.part_number - 2]->filename, - swm->filename, - swm->hdr.part_number, - total_parts); - return WIMLIB_ERR_SPLIT_INVALID; - } else { - parts_to_swms[swm->hdr.part_number - 2] = swm; - } - } - } - return 0; -} -