X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fresource.c;h=f7a7916e5f0cc0ed94bcae2b30673b500f80db4b;hb=d3a6c0b6414f880a9cea4d8655570d9f556f319d;hp=aaa0dac403fa2942e1520a2a7c452232718675c4;hpb=68b023ab834029db11ce9bf150dadd9c80e59404;p=wimlib diff --git a/src/resource.c b/src/resource.c index aaa0dac4..f7a7916e 100644 --- a/src/resource.c +++ b/src/resource.c @@ -5,25 +5,34 @@ */ /* - * Copyright (C) 2010 Carl Thijssen * Copyright (C) 2012 Eric Biggers * * 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 - * terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. + * 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. * * 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 Lesser General Public License for more - * details. + * A PARTICULAR PURPOSE. See the GNU General Public License for more details. * - * You should have received a copy of the GNU Lesser General Public License - * along with wimlib; if not, see http://www.gnu.org/licenses/. + * You should have received a copy of the GNU General Public License along with + * wimlib; if not, see http://www.gnu.org/licenses/. */ +#include "config.h" + +#include +#include + +#ifdef WITH_NTFS_3G +#include +#include +#include +#endif + #include "wimlib_internal.h" #include "lookup_table.h" #include "io.h" @@ -31,17 +40,13 @@ #include "xpress.h" #include "sha1.h" #include "dentry.h" -#include "config.h" #include #include +#ifdef HAVE_ALLOCA_H #include - -#ifdef WITH_NTFS_3G -#include -#include -#include #endif + /* * Reads all or part of a compressed resource into an in-memory buffer. * @@ -483,7 +488,13 @@ int read_wim_resource(const struct lookup_table_entry *lte, u8 buf[], break; #ifdef WITH_NTFS_3G case RESOURCE_IN_NTFS_VOLUME: + wimlib_assert(lte->ntfs_loc); if (lte->attr) { + u64 adjusted_offset; + if (lte->ntfs_loc->is_reparse_point) + adjusted_offset = offset + 8; + else + adjusted_offset = offset; if (ntfs_attr_pread(lte->attr, offset, size, buf) == size) { return 0; } else { @@ -599,7 +610,6 @@ static int compress_chunk(const u8 chunk[], unsigned chunk_size, unsigned *compressed_chunk_len_ret, int ctype) { - unsigned compressed_chunk_sz; int (*compress)(const void *, unsigned, void *, unsigned *); switch (ctype) { case WIM_COMPRESSION_TYPE_LZX: @@ -644,7 +654,6 @@ static int write_wim_resource_chunk(const u8 chunk[], unsigned chunk_size, } else { u8 *compressed_chunk = alloca(chunk_size); int ret; - unsigned compressed_chunk_len; ret = compress_chunk(chunk, chunk_size, compressed_chunk, &out_chunk_size, out_ctype); @@ -678,7 +687,7 @@ finish_wim_resource_chunk_tab(struct chunk_table *chunk_tab, { size_t bytes_written; if (fseeko(out_fp, chunk_tab->file_offset, SEEK_SET) != 0) { - ERROR_WITH_ERRNO("Failed to seek to byte "PRIu64" of output " + ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" of output " "WIM file", chunk_tab->file_offset); return WIMLIB_ERR_WRITE; } @@ -741,9 +750,11 @@ static int write_wim_resource(struct lookup_table_entry *lte, bool raw; off_t file_offset; #ifdef WITH_NTFS_3G - ntfs_inode *ni; + ntfs_inode *ni = NULL; #endif + wimlib_assert(lte); + /* Original size of the resource */ original_size = wim_resource_size(lte); @@ -772,7 +783,7 @@ static int write_wim_resource(struct lookup_table_entry *lte, return 0; /* Buffer for reading chunks for the resource */ - char buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; + u8 buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; /* If we are writing a compressed resource and not doing a raw copy, we * need to initialize the chunk table */ @@ -800,7 +811,7 @@ static int write_wim_resource(struct lookup_table_entry *lte, } #ifdef WITH_NTFS_3G else if (lte->resource_location == RESOURCE_IN_NTFS_VOLUME - && !lte->attr) + && !lte->attr) { struct ntfs_location *loc = lte->ntfs_loc; wimlib_assert(loc); @@ -808,15 +819,18 @@ static int write_wim_resource(struct lookup_table_entry *lte, if (!ni) { ERROR_WITH_ERRNO("Failed to open inode `%s' in NTFS " "volume", loc->path_utf8); + ret = WIMLIB_ERR_NTFS_3G; + goto out; } lte->attr = ntfs_attr_open(ni, loc->is_reparse_point ? AT_REPARSE_POINT : AT_DATA, (ntfschar*)loc->stream_name_utf16, loc->stream_name_utf16_num_chars); if (!lte->attr) { - ntfs_inode_close(ni); ERROR_WITH_ERRNO("Failed to open attribute of `%s' in " "NTFS volume", loc->path_utf8); + ret = WIMLIB_ERR_NTFS_3G; + goto out_fclose; } } #endif @@ -847,18 +861,27 @@ static int write_wim_resource(struct lookup_table_entry *lte, offset += to_read; } while (bytes_remaining); - /* If writing a compressed resource and not doing a raw copy, write the - * chunk table, and finish_wim_resource_chunk_tab() will provide the - * compressed size of the resource we wrote. Otherwise, the compressed - * size of the written resource is the same as the compressed size of - * the existing resource. */ - if (out_ctype != WIM_COMPRESSION_TYPE_NONE && !raw) { - ret = finish_wim_resource_chunk_tab(chunk_tab, out_fp, - &new_compressed_size); - if (ret != 0) - goto out_fclose; - } else { + /* Raw copy: The new compressed size is the same as the old compressed + * size + * + * Using WIM_COMPRESSION_TYPE_NONE: The new compressed size is the + * original size + * + * Using a different compression type: Call + * finish_wim_resource_chunk_tab() and it will provide the new + * compressed size. + */ + if (raw) { new_compressed_size = old_compressed_size; + } else { + if (out_ctype == WIM_COMPRESSION_TYPE_NONE) + new_compressed_size = original_size; + else { + ret = finish_wim_resource_chunk_tab(chunk_tab, out_fp, + &new_compressed_size); + if (ret != 0) + goto out_fclose; + } } /* Verify SHA1 message digest of the resource, unless we are doing a raw @@ -882,13 +905,13 @@ static int write_wim_resource(struct lookup_table_entry *lte, } } - if (new_compressed_size >= original_size && - out_ctype != WIM_COMPRESSION_TYPE_NONE && !raw) + if (!raw && new_compressed_size >= original_size && + out_ctype != WIM_COMPRESSION_TYPE_NONE) { /* Oops! We compressed the resource to larger than the original * size. Write the resource uncompressed instead. */ if (fseeko(out_fp, file_offset, SEEK_SET) != 0) { - ERROR_WITH_ERRNO("Failed to seek to byte "PRIu64" " + ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" " "of output WIM file", file_offset); ret = WIMLIB_ERR_WRITE; goto out_fclose; @@ -908,7 +931,7 @@ static int write_wim_resource(struct lookup_table_entry *lte, } goto out_fclose; } - wimlib_assert(new_compressed_size <= original_size); + wimlib_assert(new_compressed_size <= original_size || raw); if (out_res_entry) { out_res_entry->size = new_compressed_size; out_res_entry->original_size = original_size; @@ -925,10 +948,13 @@ out_fclose: lte->file_on_disk_fp = NULL; } #ifdef WITH_NTFS_3G - else if (lte->resource_location == RESOURCE_IN_NTFS_VOLUME - && lte->attr) { - ntfs_attr_close(lte->attr); - ntfs_inode_close(ni); + else if (lte->resource_location == RESOURCE_IN_NTFS_VOLUME) { + if (lte->attr) { + ntfs_attr_close(lte->attr); + lte->attr = NULL; + } if (ni) { + ntfs_inode_close(ni); + } } #endif out: @@ -955,7 +981,7 @@ static int write_wim_resource_from_buffer(const u8 *buf, u64 buf_size, lte.resource_location = RESOURCE_IN_ATTACHED_BUFFER; lte.attached_buffer = (u8*)buf; - zero_hash(lte.hash); + zero_out_hash(lte.hash); ret = write_wim_resource(<e, out_fp, out_ctype, out_res_entry); if (ret != 0) return ret; @@ -973,7 +999,7 @@ int extract_wim_resource_to_fd(const struct lookup_table_entry *lte, int fd, u64 size) { u64 bytes_remaining = size; - char buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; + u8 buf[min(WIM_CHUNK_SIZE, bytes_remaining)]; u64 offset = 0; int ret = 0; u8 hash[SHA1_HASH_SIZE]; @@ -987,7 +1013,7 @@ int extract_wim_resource_to_fd(const struct lookup_table_entry *lte, int fd, if (ret != 0) break; sha1_update(&ctx, buf, to_read); - if (full_write(fd, buf, to_read) < 0) { + if (full_write(fd, buf, to_read) < to_read) { ERROR_WITH_ERRNO("Error extracting WIM resource"); return WIMLIB_ERR_WRITE; } @@ -1066,8 +1092,8 @@ int write_dentry_resources(struct dentry *dentry, void *wim_p) printf("Writing streams for `%s'\n", dentry->full_path_utf8); } - for (unsigned i = 0; i <= dentry->num_ads; i++) { - lte = dentry_stream_lte(dentry, i, w->lookup_table); + for (unsigned i = 0; i <= dentry->d_inode->num_ads; i++) { + lte = inode_stream_lte(dentry->d_inode, i, w->lookup_table); if (lte && ++lte->out_refcnt == 1) { ret = write_wim_resource(lte, w->out_fp, ctype, <e->output_resource_entry); @@ -1099,14 +1125,14 @@ int write_dentry_resources(struct dentry *dentry, void *wim_p) int read_metadata_resource(WIMStruct *w, struct image_metadata *imd) { u8 *buf; - int ctype; u32 dentry_offset; int ret; struct dentry *dentry; - struct link_group_table *lgt; + struct inode_table inode_tab; const struct lookup_table_entry *metadata_lte; u64 metadata_len; u64 metadata_offset; + struct hlist_head inode_list; metadata_lte = imd->metadata_lte; metadata_len = wim_resource_size(metadata_lte); @@ -1120,7 +1146,7 @@ int read_metadata_resource(WIMStruct *w, struct image_metadata *imd) * no security descriptors) and WIM_DENTRY_DISK_SIZE is for the root * dentry. */ if (metadata_len < 8 + WIM_DENTRY_DISK_SIZE) { - ERROR("Expected at least %zu bytes for the metadata resource", + ERROR("Expected at least %u bytes for the metadata resource", 8 + WIM_DENTRY_DISK_SIZE); return WIMLIB_ERR_INVALID_RESOURCE_SIZE; } @@ -1178,6 +1204,7 @@ int read_metadata_resource(WIMStruct *w, struct image_metadata *imd) dentry->prev = dentry; if (ret != 0) goto out_free_dentry_tree; + inode_add_dentry(dentry, dentry->d_inode); /* Now read the entire directory entry tree into memory. */ DEBUG("Reading dentry tree"); @@ -1193,30 +1220,29 @@ int read_metadata_resource(WIMStruct *w, struct image_metadata *imd) /* Build hash table that maps hard link group IDs to dentry sets */ DEBUG("Building link group table"); - lgt = new_link_group_table(9001); - if (!lgt) - goto out_free_dentry_tree; - ret = for_dentry_in_tree(dentry, link_group_table_insert, lgt); + ret = init_inode_table(&inode_tab, 9001); if (ret != 0) - goto out_free_lgt; + goto out_free_dentry_tree; - DEBUG("Fixing inconsistencies in the link groups"); - ret = fix_link_groups(lgt); + for_dentry_in_tree(dentry, inode_table_insert, &inode_tab); + + DEBUG("Fixing inconsistencies in the hard link groups"); + ret = fix_inodes(&inode_tab, &inode_list); + destroy_inode_table(&inode_tab); if (ret != 0) - goto out_free_lgt; + goto out_free_dentry_tree; DEBUG("Running miscellaneous verifications on the dentry tree"); + for_lookup_table_entry(w->lookup_table, lte_zero_real_refcnt, NULL); ret = for_dentry_in_tree(dentry, verify_dentry, w); if (ret != 0) - goto out_free_lgt; + goto out_free_dentry_tree; DEBUG("Done reading image metadata"); - imd->lgt = lgt; - imd->root_dentry = dentry; + imd->root_dentry = dentry; + imd->inode_list = inode_list; goto out_free_buf; -out_free_lgt: - free_link_group_table(lgt); out_free_dentry_tree: free_dentry_tree(dentry, NULL); out_free_security_data: @@ -1235,7 +1261,7 @@ int write_metadata_resource(WIMStruct *w) int ret; u64 subdir_offset; struct dentry *root; - struct lookup_table_entry *lte, *duplicate_lte; + struct lookup_table_entry *lte; u64 metadata_original_size; const struct wim_security_data *sd; const unsigned random_tail_len = 20; @@ -1308,8 +1334,9 @@ int write_metadata_resource(WIMStruct *w) if (ret != 0) goto out; - /* It's very likely the SHA1 message digest of the metadata resource, so - * re-insert the lookup table entry into the lookup table. */ + /* It's very likely the SHA1 message digest of the metadata resource + * changed, so re-insert the lookup table entry into the lookup table. + * */ lookup_table_unlink(w->lookup_table, lte); lookup_table_insert(w->lookup_table, lte);