*/
/*
- * 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 "wimlib_internal.h"
#include <errno.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 (!fp) {
ERROR_WITH_ERRNO("Failed to open the file "
"`%s'", lte->file_on_disk);
+ return WIMLIB_ERR_OPEN;
}
}
ret = read_uncompressed_resource(fp, offset, size, buf);
memcpy(buf, lte->attached_buffer + offset, size);
return 0;
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 {
+ ERROR_WITH_ERRNO("Error reading NTFS attribute "
+ "at `%s'",
+ lte->ntfs_loc->path_utf8);
+ return WIMLIB_ERR_NTFS_3G;
+ }
+ } else {
+ wimlib_assert(0);
+ }
+ break;
+#endif
default:
assert(0);
}
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;
}
struct chunk_table *chunk_tab = NULL;
bool raw;
off_t file_offset;
+#ifdef WITH_NTFS_3G
+ 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 */
goto out;
}
}
+#ifdef WITH_NTFS_3G
+ else if (lte->resource_location == RESOURCE_IN_NTFS_VOLUME
+ && !lte->attr)
+ {
+ struct ntfs_location *loc = lte->ntfs_loc;
+ wimlib_assert(loc);
+ ni = ntfs_pathname_to_inode(*loc->ntfs_vol_p, NULL, loc->path_utf8);
+ 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) {
+ ERROR_WITH_ERRNO("Failed to open attribute of `%s' in "
+ "NTFS volume", loc->path_utf8);
+ ret = WIMLIB_ERR_NTFS_3G;
+ goto out_fclose;
+ }
+ }
+#endif
/* If we aren't doing a raw copy, we will compute the SHA1 message
* digest of the resource as we read it, and verify it's the same as the
}
}
- if (new_compressed_size > original_size) {
+ if (new_compressed_size >= original_size &&
+ out_ctype != WIM_COMPRESSION_TYPE_NONE && !raw)
+ {
/* 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;
fclose(lte->file_on_disk_fp);
lte->file_on_disk_fp = NULL;
}
+#ifdef WITH_NTFS_3G
+ 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:
FREE(chunk_tab);
return ret;
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];
*
* @return: Zero on success, nonzero on failure.
*/
-int read_metadata_resource(FILE *fp, int wim_ctype, struct image_metadata *imd)
+int read_metadata_resource(WIMStruct *w, struct image_metadata *imd)
{
u8 *buf;
- int ctype;
u32 dentry_offset;
int ret;
struct dentry *dentry;
- struct wim_security_data *sd;
struct link_group_table *lgt;
const struct lookup_table_entry *metadata_lte;
- const struct resource_entry *res_entry;
+ u64 metadata_len;
+ u64 metadata_offset;
metadata_lte = imd->metadata_lte;
- res_entry = &metadata_lte->resource_entry;
+ metadata_len = wim_resource_size(metadata_lte);
+ metadata_offset = metadata_lte->resource_entry.offset;
DEBUG("Reading metadata resource: length = %"PRIu64", "
- "offset = %"PRIu64"",
- res_entry->original_size, res_entry->offset);
-
- if (res_entry->original_size < 8) {
- ERROR("Expected at least 8 bytes for the metadata resource");
+ "offset = %"PRIu64"", metadata_len, metadata_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
+ * dentry. */
+ 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_RESOURCE_SIZE;
}
/* Allocate memory for the uncompressed metadata resource. */
- buf = MALLOC(res_entry->original_size);
+ buf = MALLOC(metadata_len);
if (!buf) {
ERROR("Failed to allocate %"PRIu64" bytes for uncompressed "
- "metadata resource", res_entry->original_size);
+ "metadata resource", metadata_len);
return WIMLIB_ERR_NOMEM;
}
- /* Determine the compression type of the metadata resource. */
-
/* Read the metadata resource into memory. (It may be compressed.) */
ret = read_full_wim_resource(metadata_lte, buf);
if (ret != 0)
DEBUG("Finished reading metadata resource into memory.");
- /* The root directory entry starts after security data, on an 8-byte
- * aligned address.
+ /* The root directory entry starts after security data, aligned on an
+ * 8-byte boundary within the metadata resource.
*
* The security data starts with a 4-byte integer giving its total
- * length. */
+ * length, so if we round that up to an 8-byte boundary that gives us
+ * the offset of the root dentry.
+ *
+ * Here we read the security data into a wim_security_data structure,
+ * and if successful, go ahead and calculate the offset in the metadata
+ * resource of the root dentry. */
- /* Read the security data into a wim_security_data structure. */
- ret = read_security_data(buf, res_entry->original_size, &sd);
+ ret = read_security_data(buf, metadata_len, &imd->security_data);
if (ret != 0)
goto out_free_buf;
+ get_u32(buf, &dentry_offset);
+ if (dentry_offset == 0)
+ dentry_offset = 8;
+ dentry_offset = (dentry_offset + 7) & ~7;
+
+ /* Allocate memory for the root dentry and read it into memory */
dentry = MALLOC(sizeof(struct dentry));
if (!dentry) {
ERROR("Failed to allocate %zu bytes for root dentry",
ret = WIMLIB_ERR_NOMEM;
goto out_free_security_data;
}
-
- get_u32(buf, &dentry_offset);
- if (dentry_offset == 0)
- dentry_offset = 8;
- dentry_offset = (dentry_offset + 7) & ~7;
- ret = read_dentry(buf, res_entry->original_size, dentry_offset, dentry);
+ ret = read_dentry(buf, metadata_len, dentry_offset, dentry);
+
/* This is the root dentry, so set its pointers correctly. */
dentry->parent = dentry;
dentry->next = dentry;
if (ret != 0)
goto out_free_dentry_tree;
+ /* Now read the entire directory entry tree into memory. */
DEBUG("Reading dentry tree");
- /* Now read the entire directory entry tree. */
- ret = read_dentry_tree(buf, res_entry->original_size, dentry);
+ ret = read_dentry_tree(buf, metadata_len, dentry);
if (ret != 0)
goto out_free_dentry_tree;
- DEBUG("Calculating dentry full paths");
/* Calculate the full paths in the dentry tree. */
+ DEBUG("Calculating dentry full paths");
ret = for_dentry_in_tree(dentry, calculate_dentry_full_path, NULL);
if (ret != 0)
goto out_free_dentry_tree;
- DEBUG("Building link group table");
/* 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;
if (ret != 0)
goto out_free_lgt;
- DEBUG("Freeing duplicate ADS entries in link group table");
- ret = link_groups_free_duplicate_data(lgt);
+ DEBUG("Fixing inconsistencies in the link groups");
+ ret = fix_link_groups(lgt);
if (ret != 0)
goto out_free_lgt;
+
+ DEBUG("Running miscellaneous verifications on the dentry tree");
+ ret = for_dentry_in_tree(dentry, verify_dentry, w);
+ if (ret != 0)
+ goto out_free_lgt;
+
DEBUG("Done reading image metadata");
imd->lgt = lgt;
- imd->security_data = sd;
imd->root_dentry = dentry;
goto out_free_buf;
out_free_lgt:
out_free_dentry_tree:
free_dentry_tree(dentry, NULL);
out_free_security_data:
- free_security_data(sd);
+ free_security_data(imd->security_data);
+ imd->security_data = NULL;
out_free_buf:
FREE(buf);
return ret;
int ret;
u64 subdir_offset;
struct dentry *root;
- struct lookup_table_entry *lte, *duplicate_lte;
+ struct lookup_table_entry *lte;
u64 metadata_original_size;
-
- /*
- * We append 20 random bytes to the metadata resource so that we don't
- * have identical metadata resources if we happen to append exactly the
- * same image twice without any changes in timestamps. If this were to
- * happen, it would cause confusion about the number and order of images
- * in the WIM.
- */
+ const struct wim_security_data *sd;
const unsigned random_tail_len = 20;
DEBUG("Writing metadata resource for image %d", w->current_image);
root = wim_root_dentry(w);
+ sd = wim_security_data(w);
- const struct wim_security_data *sd = wim_security_data(w);
+ /* We do not allow the security data pointer to be NULL, although it may
+ * point to an empty security data with no entries. */
wimlib_assert(sd);
- subdir_offset = sd->total_length + root->length + 8;
+
+ /* Offset of first child of the root dentry. It's equal to:
+ * - The total length of the security data, rounded to the next 8-byte
+ * boundary,
+ * - plus the total length of the root dentry,
+ * - plus 8 bytes for an end-of-directory entry following the root
+ * dentry (shouldn't really be needed, but just in case...)
+ */
+ subdir_offset = ((sd->total_length + 7) & ~7) +
+ dentry_correct_total_length(root) + 8;
+
+ /* Calculate the subdirectory offsets for the entire dentry tree. */
calculate_subdir_offsets(root, &subdir_offset);
+
+ /* Total length of the metadata resource (uncompressed) */
metadata_original_size = subdir_offset + random_tail_len;
+
+ /* Allocate a buffer to contain the uncompressed metadata resource */
buf = MALLOC(metadata_original_size);
if (!buf) {
ERROR("Failed to allocate %"PRIu64" bytes for "
return WIMLIB_ERR_NOMEM;
}
+ /* Write the security data into the resource buffer */
p = write_security_data(sd, buf);
+ /* Write the dentry tree into the resource buffer */
DEBUG("Writing dentry tree.");
p = write_dentry_tree(root, p);
+
+ /*
+ * Append 20 random bytes to the metadata resource so that we don't have
+ * identical metadata resources if we happen to append exactly the same
+ * image twice without any changes in timestamps. If this were to
+ * happen, it would cause confusion about the number and order of images
+ * in the WIM.
+ */
randomize_byte_array(p, random_tail_len);
+
+ /* We MUST have exactly filled the buffer; otherwise we calculated its
+ * size incorrectly or wrote the data incorrectly. */
wimlib_assert(p - buf + random_tail_len == metadata_original_size);
+ /* Get the lookup table entry for the metadata resource so we can update
+ * it. */
lte = wim_metadata_lookup_table_entry(w);
+ /* Write the metadata resource to the output WIM using the proper
+ * compression type. The lookup table entry for the metadata resource
+ * is updated. */
ret = write_wim_resource_from_buffer(buf, metadata_original_size,
w->out_fp,
wimlib_get_compression_type(w),
<e->output_resource_entry,
lte->hash);
+ 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. */
lookup_table_unlink(w->lookup_table, lte);
lookup_table_insert(w->lookup_table, lte);
+
+ /* We do not allow a metadata resource to be referenced multiple times,
+ * and the 20 random bytes appended to it should make it extremely
+ * likely for each metadata resource to be unique, even if the exact
+ * same image is captured. */
wimlib_assert(lte->out_refcnt == 0);
lte->out_refcnt = 1;
+
+ /* Make sure that the resource entry is written marked with the metadata
+ * flag. */
lte->output_resource_entry.flags |= WIM_RESHDR_FLAG_METADATA;
out:
+ /* All the data has been written to the new WIM; no need for the buffer
+ * anymore */
FREE(buf);
return ret;
}
git://wimlib.net / wimlib / blobdiff