*/
/*
- * 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 <stdlib.h>
+#include <stdarg.h>
+
+#ifdef WITH_NTFS_3G
+#include <ntfs-3g/attrib.h>
+#include <ntfs-3g/inode.h>
+#include <ntfs-3g/dir.h>
+#endif
+
#include "wimlib_internal.h"
#include "lookup_table.h"
#include "io.h"
#include "xpress.h"
#include "sha1.h"
#include "dentry.h"
-#include "config.h"
#include <unistd.h>
#include <errno.h>
+#ifdef HAVE_ALLOCA_H
#include <alloca.h>
-
-#ifdef WITH_NTFS_3G
-#include <ntfs-3g/attrib.h>
-#include <ntfs-3g/inode.h>
-#include <ntfs-3g/dir.h>
#endif
+
/*
* Reads all or part of a compressed resource into an in-memory buffer.
*
if (chunk_entry_size == 4) {
u32 *entries = (u32*)chunk_tab_buf;
while (num_needed_chunk_entries--)
- *chunk_tab_p++ = to_le32(*entries++);
+ *chunk_tab_p++ = le32_to_cpu(*entries++);
} else {
u64 *entries = (u64*)chunk_tab_buf;
while (num_needed_chunk_entries--)
- *chunk_tab_p++ = to_le64(*entries++);
+ *chunk_tab_p++ = le64_to_cpu(*entries++);
}
/* Done with the chunk table now. We must now seek to the first chunk
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 {
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:
} 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);
{
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;
}
if (chunk_tab->bytes_per_chunk_entry == 8) {
- array_to_le64(chunk_tab->offsets, chunk_tab->num_chunks);
+ array_cpu_to_le64(chunk_tab->offsets, chunk_tab->num_chunks);
} else {
for (u64 i = 0; i < chunk_tab->num_chunks; i++)
((u32*)chunk_tab->offsets)[i] =
- to_le32(chunk_tab->offsets[i]);
+ cpu_to_le32(chunk_tab->offsets[i]);
}
bytes_written = fwrite((u8*)chunk_tab->offsets +
chunk_tab->bytes_per_chunk_entry,
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);
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 */
}
#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);
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
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
}
}
- 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;
}
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;
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:
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;
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];
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;
}
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);
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);
* 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;
}
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");
/* 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:
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;
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);
git://wimlib.net / wimlib / blobdiff