/*
- * update_image.c - Update a WIM image.
+ * update_image.c - see description below
*/
/*
* along with this file; if not, see http://www.gnu.org/licenses/.
*/
+/*
+ * This file contains the implementation of wimlib_update_image(), which is one
+ * of the two ways by which library users can make changes to a WIM image. (The
+ * other way is by mounting an image read-write.) wimlib_update_image() is also
+ * used in the implementation of wimlib_add_image(), since "create a WIM image
+ * from this directory tree" is equivalent to "create an empty WIM image, then
+ * update it to add this directory tree as the root".
+ *
+ * wimlib_update_image() processes a list of commands passed to it. Currently,
+ * the following types of commands are supported:
+ *
+ * - Add a directory tree from an external source (filesystem or NTFS volume).
+ * This can be used to add new files or to replace existing files.
+ * - Delete a file or directory tree.
+ * - Rename a file or directory tree.
+ *
+ * Not supported are creating links to existing files or changing metadata of
+ * existing files.
+ *
+ * wimlib_update_image() is atomic. If it cannot complete successfully, then
+ * all changes are rolled back and the WIMStruct is left unchanged. Rollback is
+ * implemented by breaking the commands into primitive operations such as "link
+ * this dentry tree here" which can be undone by doing the opposite operations
+ * in reverse order.
+ */
+
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
+#include <errno.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include "wimlib/alloca.h"
+#include "wimlib/assert.h"
+#include "wimlib/blob_table.h"
#include "wimlib/capture.h"
#include "wimlib/dentry.h"
#include "wimlib/encoding.h"
#include "wimlib/endianness.h"
#include "wimlib/error.h"
-#include "wimlib/lookup_table.h"
#include "wimlib/metadata.h"
-#ifdef WITH_NTFS_3G
-# include "wimlib/ntfs_3g.h" /* for do_ntfs_umount() */
-#endif
#include "wimlib/paths.h"
#include "wimlib/progress.h"
#include "wimlib/xml.h"
-#include <errno.h>
-#include <sys/stat.h>
-#include <stdlib.h>
-
-#ifdef HAVE_ALLOCA_H
-# include <alloca.h>
-#endif
-
/* Saved specification of a "primitive" update operation that was performed. */
struct update_primitive {
enum {
/* Location of the WIM image's root pointer. */
struct wim_dentry **root_p;
- /* Pointer to the lookup table of the WIM (may needed for rollback) */
- struct wim_lookup_table *lookup_table;
+ /* Pointer to the blob table of the WIM (may needed for rollback) */
+ struct blob_table *blob_table;
/* List of dentries that are currently unlinked from the WIM image.
* These must be freed when no longer needed for commit or rollback. */
* commands. */
static struct update_command_journal *
new_update_command_journal(size_t num_cmds, struct wim_dentry **root_p,
- struct wim_lookup_table *lookup_table)
+ struct blob_table *blob_table)
{
struct update_command_journal *j;
j->num_cmds = num_cmds;
j->cur_cmd = 0;
j->root_p = root_p;
- j->lookup_table = lookup_table;
+ j->blob_table = blob_table;
INIT_LIST_HEAD(&j->orphans);
for (size_t i = 0; i < num_cmds; i++)
init_update_primitive_list(&j->cmd_prims[i]);
/* Free orphaned dentry trees */
while (!list_empty(&j->orphans)) {
orphan = list_first_entry(&j->orphans,
- struct wim_dentry, tmp_list);
- list_del(&orphan->tmp_list);
- free_dentry_tree(orphan, j->lookup_table);
+ struct wim_dentry, d_tmp_list);
+ list_del(&orphan->d_tmp_list);
+ free_dentry_tree(orphan, j->blob_table);
}
for (size_t i = 0; i < j->num_cmds; i++)
do_unlink(subject, parent, root_p);
/* @subject is now unlinked. Add it to orphans. */
- list_add(&subject->tmp_list, orphans);
- subject->is_orphan = 1;
+ list_add(&subject->d_tmp_list, orphans);
+ subject->d_is_orphan = 1;
}
/* Undo an unlink operation. */
do_link(subject, parent, root_p);
/* @subject is no longer unlinked. Delete it from orphans. */
- list_del(&subject->tmp_list);
- subject->is_orphan = 0;
+ list_del(&subject->d_tmp_list);
+ subject->d_is_orphan = 0;
}
/* Rollback a name change operation. */
FREE(*name_ptr);
if (old_name) {
*name_ptr = old_name;
- *name_nbytes_ptr = utf16le_strlen(old_name);
+ *name_nbytes_ptr = utf16le_len_bytes(old_name);
} else {
*name_ptr = NULL;
*name_nbytes_ptr = 0;
break;
case CHANGE_FILE_NAME:
rollback_name_change(prim->name.old_name,
- &prim->name.subject->file_name,
- &prim->name.subject->file_name_nbytes);
+ &prim->name.subject->d_name,
+ &prim->name.subject->d_name_nbytes);
break;
case CHANGE_SHORT_NAME:
rollback_name_change(prim->name.old_name,
- &prim->name.subject->short_name,
- &prim->name.subject->short_name_nbytes);
+ &prim->name.subject->d_short_name,
+ &prim->name.subject->d_short_name_nbytes);
break;
}
}
do_link(subject, parent, j->root_p);
- if (subject->is_orphan) {
- list_del(&subject->tmp_list);
- subject->is_orphan = 0;
+ if (subject->d_is_orphan) {
+ list_del(&subject->d_tmp_list);
+ subject->d_is_orphan = 0;
}
return 0;
}
do_unlink(subject, parent, j->root_p);
- list_add(&subject->tmp_list, &j->orphans);
- subject->is_orphan = 1;
+ list_add(&subject->d_tmp_list, &j->orphans);
+ subject->d_is_orphan = 1;
return 0;
}
prim.type = CHANGE_FILE_NAME;
prim.name.subject = dentry;
- prim.name.old_name = dentry->file_name;
+ prim.name.old_name = dentry->d_name;
ret = record_update_primitive(j, prim);
if (ret) {
FREE(new_name);
return ret;
}
- dentry->file_name = new_name;
- dentry->file_name_nbytes = new_name_nbytes;
+ dentry->d_name = new_name;
+ dentry->d_name_nbytes = new_name_nbytes;
/* Clear the short name. */
prim.type = CHANGE_SHORT_NAME;
prim.name.subject = dentry;
- prim.name.old_name = dentry->short_name;
+ prim.name.old_name = dentry->d_short_name;
ret = record_update_primitive(j, prim);
if (ret)
return ret;
- dentry->short_name = NULL;
- dentry->short_name_nbytes = 0;
+ dentry->d_short_name = NULL;
+ dentry->d_short_name_nbytes = 0;
return 0;
}
existing_child =
get_dentry_child_with_utf16le_name(existing,
- new_child->file_name,
- new_child->file_name_nbytes,
+ new_child->d_name,
+ new_child->d_name_nbytes,
WIMLIB_CASE_PLATFORM_DEFAULT);
unlink_dentry(new_child);
if (existing_child) {
return ret;
}
}
- free_dentry(branch);
+ free_dentry_tree(branch, j->blob_table);
return 0;
} else if (add_flags & WIMLIB_ADD_FLAG_NO_REPLACE) {
/* Can't replace nondirectory file */
if (add_flags & WIMLIB_ADD_FLAG_VERBOSE) {
union wimlib_progress_info info;
- info.replace.path_in_wim = existing->_full_path;
+ info.replace.path_in_wim = existing->d_full_path;
ret = call_progress(progfunc,
WIMLIB_PROGRESS_MSG_REPLACE_FILE_IN_WIM,
&info, progctx);
out_free_target:
tstr_put_utf16le(target);
out_free_branch:
- free_dentry_tree(branch, j->lookup_table);
+ free_dentry_tree(branch, j->blob_table);
out:
return ret;
}
const struct wimlib_update_command *add_cmd,
struct wim_inode_table *inode_table,
struct wim_sd_set *sd_set,
- struct list_head *unhashed_streams)
+ struct list_head *unhashed_blobs)
{
int ret;
int add_flags;
tchar *fs_source_path;
tchar *wim_target_path;
const tchar *config_file;
- struct add_image_params params;
+ struct capture_params params;
struct capture_config config;
capture_tree_t capture_tree = platform_default_capture_tree;
-#ifdef WITH_NTFS_3G
- struct _ntfs_volume *ntfs_vol = NULL;
-#endif
- void *extra_arg = NULL;
struct wim_dentry *branch;
add_flags = add_cmd->add.add_flags;
memset(¶ms, 0, sizeof(params));
#ifdef WITH_NTFS_3G
- if (add_flags & WIMLIB_ADD_FLAG_NTFS) {
- capture_tree = build_dentry_tree_ntfs;
- extra_arg = &ntfs_vol;
- if (wim_get_current_image_metadata(wim)->ntfs_vol != NULL) {
- ERROR("NTFS volume already set");
- ret = WIMLIB_ERR_INVALID_PARAM;
- goto out;
- }
- }
+ if (add_flags & WIMLIB_ADD_FLAG_NTFS)
+ capture_tree = ntfs_3g_build_dentry_tree;
#endif
ret = get_capture_config(config_file, &config,
if (ret)
goto out;
- params.lookup_table = wim->lookup_table;
- params.unhashed_streams = unhashed_streams;
+ params.blob_table = wim->blob_table;
+ params.unhashed_blobs = unhashed_blobs;
params.inode_table = inode_table;
params.sd_set = sd_set;
params.config = &config;
params.add_flags = add_flags;
- params.extra_arg = extra_arg;
params.progfunc = wim->progfunc;
params.progctx = wim->progctx;
ret = call_progress(params.progfunc, WIMLIB_PROGRESS_MSG_SCAN_END,
¶ms.progress, params.progctx);
if (ret) {
- free_dentry_tree(branch, wim->lookup_table);
- goto out_cleanup_after_capture;
+ free_dentry_tree(branch, wim->blob_table);
+ goto out_destroy_config;
}
if (WIMLIB_IS_WIM_ROOT_PATH(wim_target_path) &&
{
ERROR("\"%"TS"\" is not a directory!", fs_source_path);
ret = WIMLIB_ERR_NOTDIR;
- free_dentry_tree(branch, wim->lookup_table);
- goto out_cleanup_after_capture;
+ free_dentry_tree(branch, wim->blob_table);
+ goto out_destroy_config;
}
ret = attach_branch(branch, wim_target_path, j,
add_flags, params.progfunc, params.progctx);
if (ret)
- goto out_cleanup_after_capture;
+ goto out_destroy_config;
if (config_file && (add_flags & WIMLIB_ADD_FLAG_WIMBOOT) &&
WIMLIB_IS_WIM_ROOT_PATH(wim_target_path))
* /Windows/System32/WimBootCompress.ini in the WIM image. */
ret = platform_default_capture_tree(&branch, config_file, ¶ms);
if (ret)
- goto out_cleanup_after_capture;
+ goto out_destroy_config;
ret = attach_branch(branch, wimboot_cfgfile, j, 0, NULL, NULL);
if (ret)
- goto out_cleanup_after_capture;
+ goto out_destroy_config;
}
-#ifdef WITH_NTFS_3G
- wim_get_current_image_metadata(wim)->ntfs_vol = ntfs_vol;
-#endif
ret = 0;
- goto out_destroy_config;
-out_cleanup_after_capture:
-#ifdef WITH_NTFS_3G
- if (ntfs_vol)
- do_ntfs_umount(ntfs_vol);
-#endif
out_destroy_config:
destroy_capture_config(&config);
out:
static int
free_dentry_full_path(struct wim_dentry *dentry, void *_ignore)
{
- FREE(dentry->_full_path);
- dentry->_full_path = NULL;
+ FREE(dentry->d_full_path);
+ dentry->d_full_path = NULL;
return 0;
}
return -ENOMEM;
if (dst) {
unlink_dentry(dst);
- free_dentry_tree(dst, wim->lookup_table);
+ free_dentry_tree(dst, wim->blob_table);
}
unlink_dentry(src);
dentry_add_child(parent_of_dst, src);
}
- if (src->_full_path)
+ if (src->d_full_path)
for_dentry_in_tree(src, free_dentry_full_path, NULL);
return 0;
}
{
struct wim_inode_table *inode_table;
struct wim_sd_set *sd_set;
- struct list_head unhashed_streams;
+ struct list_head unhashed_blobs;
struct update_command_journal *j;
union wimlib_progress_info info;
int ret;
if (ret)
goto out_destroy_inode_table;
- INIT_LIST_HEAD(&unhashed_streams);
+ INIT_LIST_HEAD(&unhashed_blobs);
} else {
inode_table = NULL;
sd_set = NULL;
*/
j = new_update_command_journal(num_cmds,
&wim_get_current_image_metadata(wim)->root_dentry,
- wim->lookup_table);
+ wim->blob_table);
if (!j) {
ret = WIMLIB_ERR_NOMEM;
goto out_destroy_sd_set;
switch (cmds[i].op) {
case WIMLIB_UPDATE_OP_ADD:
ret = execute_add_command(j, wim, &cmds[i], inode_table,
- sd_set, &unhashed_streams);
+ sd_set, &unhashed_blobs);
break;
case WIMLIB_UPDATE_OP_DELETE:
ret = execute_delete_command(j, wim, &cmds[i]);
imd = wim_get_current_image_metadata(wim);
- list_splice_tail(&unhashed_streams, &imd->unhashed_streams);
+ list_splice_tail(&unhashed_blobs, &imd->unhashed_blobs);
inode_table_prepare_inode_list(inode_table, &imd->inode_list);
}
goto out_destroy_sd_set;
#ifndef WITH_NTFS_3G
if (add_flags & WIMLIB_ADD_FLAG_NTFS) {
- ERROR("wimlib was compiled without support for NTFS-3g, so\n"
- " we cannot capture a WIM image directly "
- "from an NTFS volume");
+ ERROR("NTFS-3g capture mode is unsupported because wimlib "
+ "was compiled --without-ntfs-3g");
return WIMLIB_ERR_UNSUPPORTED;
}
#endif
}
if (!is_entire_image) {
- if (add_flags & WIMLIB_ADD_FLAG_NTFS) {
- ERROR("Cannot add directly from an NTFS volume "
- "when not capturing a full image!");
- return WIMLIB_ERR_INVALID_PARAM;
- }
-
if (add_flags & WIMLIB_ADD_FLAG_RPFIX) {
ERROR("Cannot do reparse point fixups when "
"not capturing a full image!");
git://wimlib.net / wimlib / blobdiff