X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fmetadata_resource.c;h=54730598119568bf8a680ace268be946d701197f;hp=006871c6abbe57caaaa4615233dab95d8c31134e;hb=69f07a55f05919a15ff1ec77b963b48f5f6a5d04;hpb=2254a0fc3f1d7af1151ee83f3458f44339b5028b diff --git a/src/metadata_resource.c b/src/metadata_resource.c index 006871c6..54730598 100644 --- a/src/metadata_resource.c +++ b/src/metadata_resource.c @@ -5,19 +5,18 @@ /* * Copyright (C) 2012, 2013 Eric Biggers * - * This file is part of wimlib, a library for working with WIM files. + * 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. * - * 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. + * 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. * - * 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 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/. */ #ifdef HAVE_CONFIG_H @@ -26,23 +25,14 @@ #include "wimlib/dentry.h" #include "wimlib/error.h" -#include "wimlib/file_io.h" #include "wimlib/lookup_table.h" #include "wimlib/metadata.h" #include "wimlib/resource.h" #include "wimlib/security.h" +#include "wimlib/write.h" /* - * Reads a metadata resource for an image in the WIM file. The metadata - * resource consists of the security data, followed by the directory entry for - * the root directory, followed by all the other directory entries in the - * filesystem. The subdir_offset field of each directory entry gives the start - * of its child entries from the beginning of the metadata resource. An - * end-of-directory is signaled by a directory entry of length '0', really of - * length 8, because that's how long the 'length' field is. - * - * @wim: - * Pointer to the WIMStruct for the WIM file. + * Reads and parses a metadata resource for an image in the WIM file. * * @imd: * Pointer to the image metadata structure for the image whose metadata @@ -59,43 +49,29 @@ * WIMLIB_ERR_DECOMPRESSION */ int -read_metadata_resource(WIMStruct *wim, struct wim_image_metadata *imd) +read_metadata_resource(struct wim_image_metadata *imd) { + const struct wim_lookup_table_entry *metadata_lte; void *buf; int ret; + struct wim_security_data *sd; struct wim_dentry *root; - const struct wim_lookup_table_entry *metadata_lte; - u64 metadata_len; - u8 hash[SHA1_HASH_SIZE]; - struct wim_security_data *security_data; struct wim_inode *inode; metadata_lte = imd->metadata_lte; - metadata_len = wim_resource_size(metadata_lte); - - DEBUG("Reading metadata resource: original_size = %"PRIu64", " - "size = %"PRIu64", offset = %"PRIu64"", - metadata_lte->resource_entry.original_size, - metadata_lte->resource_entry.size, - metadata_lte->resource_entry.offset); - - /* There is no way the metadata resource could possibly be less than (8 - * + WIM_DENTRY_DISK_SIZE) bytes, where the 8 is for security data (with - * no security descriptors) and WIM_DENTRY_DISK_SIZE is for the root - * entry. */ - if (metadata_len < 8 + WIM_DENTRY_DISK_SIZE) { - ERROR("Expected at least %u bytes for the metadata resource", - 8 + WIM_DENTRY_DISK_SIZE); - return WIMLIB_ERR_INVALID_METADATA_RESOURCE; - } - /* Read the metadata resource into memory. (It may be compressed.) */ - ret = read_full_resource_into_alloc_buf(metadata_lte, &buf); + DEBUG("Reading metadata resource (size=%"PRIu64").", metadata_lte->size); + + /* Read the metadata resource into memory. (It may be compressed.) */ + ret = read_full_stream_into_alloc_buf(metadata_lte, &buf); if (ret) return ret; + /* Checksum the metadata resource. */ if (!metadata_lte->dont_check_metadata_hash) { - sha1_buffer(buf, metadata_len, hash); + u8 hash[SHA1_HASH_SIZE]; + + sha1_buffer(buf, metadata_lte->size, hash); if (!hashes_equal(metadata_lte->hash, hash)) { ERROR("Metadata resource is corrupted " "(invalid SHA-1 message digest)!"); @@ -104,93 +80,48 @@ read_metadata_resource(WIMStruct *wim, struct wim_image_metadata *imd) } } - DEBUG("Finished reading metadata resource into memory."); - - ret = read_wim_security_data(buf, metadata_len, &security_data); + /* Parse the metadata resource. + * + * Notes: The metadata resource consists of the security data, followed + * by the directory entry for the root directory, followed by all the + * other directory entries in the filesystem. The subdir_offset field + * of each directory entry gives the start of its child entries from the + * beginning of the metadata resource. An end-of-directory is signaled + * by a directory entry of length '0', really of length 8, because + * that's how long the 'length' field is. */ + + ret = read_wim_security_data(buf, metadata_lte->size, &sd); if (ret) goto out_free_buf; - DEBUG("Reading root dentry"); - - /* Allocate memory for the root dentry and read it into memory */ - root = MALLOC(sizeof(struct wim_dentry)); - if (!root) { - ret = WIMLIB_ERR_NOMEM; - goto out_free_security_data; - } - - /* The root directory entry starts after security data, aligned on an - * 8-byte boundary within the metadata resource. Since - * security_data->total_length was already rounded up to an 8-byte - * boundary, its value can be used as the offset of the root directory - * entry. */ - ret = read_dentry(buf, metadata_len, - security_data->total_length, root); - - if (ret == 0 && root->length == 0) { - WARNING("Metadata resource begins with end-of-directory entry " - "(treating as empty image)"); - FREE(root); - root = NULL; - goto out_success; - } - - if (ret) { - FREE(root); - goto out_free_security_data; - } - - if (dentry_has_long_name(root) || dentry_has_short_name(root)) { - WARNING("The root directory has a nonempty name (removing it)"); - FREE(root->file_name); - FREE(root->short_name); - root->file_name = NULL; - root->short_name = NULL; - root->file_name_nbytes = 0; - root->short_name_nbytes = 0; - } - - if (!dentry_is_directory(root)) { - ERROR("Root of the WIM image must be a directory!"); - FREE(root); - ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE; + ret = read_dentry_tree(buf, metadata_lte->size, sd->total_length, &root); + if (ret) goto out_free_security_data; - } - - /* This is the root dentry, so set its parent to itself. */ - root->parent = root; - inode_add_dentry(root, root->d_inode); + /* We have everything we need from the buffer now. */ + FREE(buf); + buf = NULL; - /* Now read the entire directory entry tree into memory. */ - DEBUG("Reading dentry tree"); - ret = read_dentry_tree(buf, metadata_len, root); - if (ret) - goto out_free_dentry_tree; + /* Calculate and validate inodes. */ - /* Build hash table that maps hard link group IDs to dentry sets */ ret = dentry_tree_fix_inodes(root, &imd->inode_list); if (ret) goto out_free_dentry_tree; + image_for_each_inode(inode, imd) + check_inode(inode, sd); - DEBUG("Running miscellaneous verifications on the dentry tree"); - image_for_each_inode(inode, imd) { - ret = verify_inode(inode, security_data); - if (ret) - goto out_free_dentry_tree; - } - DEBUG("Done reading image metadata"); -out_success: + /* Success; fill in the image_metadata structure. */ imd->root_dentry = root; - imd->security_data = security_data; + imd->security_data = sd; INIT_LIST_HEAD(&imd->unhashed_streams); - ret = 0; - goto out_free_buf; + DEBUG("Done parsing metadata resource."); + return 0; + out_free_dentry_tree: - free_dentry_tree(root, wim->lookup_table); + free_dentry_tree(root, NULL); out_free_security_data: - free_wim_security_data(security_data); + free_wim_security_data(sd); out_free_buf: FREE(buf); return ret; @@ -214,7 +145,7 @@ prepare_metadata_resource(WIMStruct *wim, int image, int ret; u64 subdir_offset; struct wim_dentry *root; - u64 len; + size_t len; struct wim_security_data *sd; struct wim_image_metadata *imd; @@ -231,7 +162,7 @@ prepare_metadata_resource(WIMStruct *wim, int image, if (!root) { /* Empty image; create a dummy root. */ - ret = new_filler_directory(T(""), &root); + ret = new_filler_directory(&root); if (ret) return ret; imd->root_dentry = root; @@ -255,10 +186,12 @@ prepare_metadata_resource(WIMStruct *wim, int image, len = subdir_offset; /* Allocate a buffer to contain the uncompressed metadata resource. */ - buf = MALLOC(len); + buf = NULL; + if (likely(len == subdir_offset)) + buf = MALLOC(len); if (!buf) { ERROR("Failed to allocate %"PRIu64" bytes for " - "metadata resource", len); + "metadata resource", subdir_offset); return WIMLIB_ERR_NOMEM; } @@ -296,11 +229,11 @@ write_metadata_resource(WIMStruct *wim, int image, int write_resource_flags) * the metadata resource. */ ret = write_wim_resource_from_buffer(buf, len, WIM_RESHDR_FLAG_METADATA, &wim->out_fd, - wim->compression_type, - &imd->metadata_lte->output_resource_entry, + wim->out_compression_type, + wim->out_chunk_size, + &imd->metadata_lte->out_reshdr, imd->metadata_lte->hash, - write_resource_flags, - &wim->lzx_context); + write_resource_flags); /* Original checksum was overridden; set a flag so it isn't used. */ imd->metadata_lte->dont_check_metadata_hash = 1;