X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fupdate_image.c;h=c043d892e46f4056b8ed007feec99bbff19e1ce3;hp=650dfbbd07fdf0726d3ce737085cdbf214eb9ae5;hb=48fbbd68e82d879e2cb6f384c1440e81373338c7;hpb=22c0e369cb60b73a9ec209c878173001bfb43db8 diff --git a/src/update_image.c b/src/update_image.c index 650dfbbd..c043d892 100644 --- a/src/update_image.c +++ b/src/update_image.c @@ -21,11 +21,21 @@ * along with wimlib; if not, see http://www.gnu.org/licenses/. */ -#include "wimlib_internal.h" -#include "dentry.h" -#include "lookup_table.h" -#include "security.h" -#include "xml.h" +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "wimlib/capture.h" +#include "wimlib/dentry.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/xml.h" + #include /* Overlays @branch onto @target, both of which must be directories. */ @@ -44,6 +54,7 @@ do_overlay(struct wim_dentry *target, struct wim_dentry *branch) } rb_root = &branch->d_inode->i_children; + LIST_HEAD(moved_children); while (rb_root->rb_node) { /* While @branch has children... */ struct wim_dentry *child = rbnode_dentry(rb_root->rb_node); struct wim_dentry *existing; @@ -57,12 +68,17 @@ do_overlay(struct wim_dentry *target, struct wim_dentry *branch) int ret; ret = do_overlay(existing, child); if (ret) { - /* Overlay failed. Revert the change to avoid - * leaking the directory tree rooted at @child. - * */ + /* Overlay failed. Revert the changes. */ dentry_add_child(branch, child); + list_for_each_entry(child, &moved_children, tmp_list) + { + unlink_dentry(child); + dentry_add_child(branch, child); + } return ret; } + } else { + list_add(&child->tmp_list, &moved_children); } } free_dentry(branch); @@ -118,7 +134,7 @@ attach_branch(struct wim_dentry **root_p, struct wim_dentry *branch, /* Walk the path to the branch, creating filler directories as needed. * */ parent = *root_p; - while ((slash = tstrchr(target_path, T('/')))) { + while ((slash = tstrchr(target_path, WIM_PATH_SEPARATOR))) { *slash = T('\0'); dentry = get_dentry_child_with_name(parent, target_path); if (!dentry) { @@ -134,7 +150,7 @@ attach_branch(struct wim_dentry **root_p, struct wim_dentry *branch, * trailing slashes were tripped. */ do { ++target_path; - } while (*target_path == T('/')); + } while (*target_path == WIM_PATH_SEPARATOR); } /* If the target path already existed, overlay the branch onto it. @@ -158,15 +174,12 @@ execute_add_command(WIMStruct *wim, int add_flags; tchar *fs_source_path; tchar *wim_target_path; - struct wim_inode_table inode_table; - struct sd_set sd_set; struct wim_image_metadata *imd; struct list_head unhashed_streams; struct add_image_params params; int (*capture_tree)(struct wim_dentry **, const tchar *, struct add_image_params *); - union wimlib_progress_info progress; struct wimlib_capture_config *config; #ifdef WITH_NTFS_3G struct _ntfs_volume *ntfs_vol = NULL; @@ -176,6 +189,7 @@ execute_add_command(WIMStruct *wim, bool rollback_sd = true; wimlib_assert(add_cmd->op == WIMLIB_UPDATE_OP_ADD); + add_flags = add_cmd->add.add_flags; fs_source_path = add_cmd->add.fs_source_path; wim_target_path = add_cmd->add.wim_target_path; @@ -183,6 +197,8 @@ execute_add_command(WIMStruct *wim, DEBUG("fs_source_path=\"%"TS"\", wim_target_path=\"%"TS"\", add_flags=%#x", fs_source_path, wim_target_path, add_flags); + memset(¶ms, 0, sizeof(params)); + imd = wim->image_metadata[wim->current_image - 1]; if (add_flags & WIMLIB_ADD_FLAG_NTFS) { @@ -207,41 +223,38 @@ execute_add_command(WIMStruct *wim, extra_arg = NULL; } - ret = init_inode_table(&inode_table, 9001); + + ret = init_inode_table(¶ms.inode_table, 9001); if (ret) goto out; - ret = init_sd_set(&sd_set, imd->security_data); + ret = init_sd_set(¶ms.sd_set, imd->security_data); if (ret) goto out_destroy_inode_table; INIT_LIST_HEAD(&unhashed_streams); wim->lookup_table->unhashed_streams = &unhashed_streams; params.lookup_table = wim->lookup_table; - params.inode_table = &inode_table; - params.sd_set = &sd_set; params.config = config; params.add_flags = add_flags; - params.progress_func = progress_func; params.extra_arg = extra_arg; - if (progress_func) { - memset(&progress, 0, sizeof(progress)); - progress.scan.source = fs_source_path; - progress.scan.wim_target_path = wim_target_path; - progress_func(WIMLIB_PROGRESS_MSG_SCAN_BEGIN, &progress); + params.progress_func = progress_func; + params.progress.scan.source = fs_source_path; + params.progress.scan.wim_target_path = wim_target_path; + if (progress_func) + progress_func(WIMLIB_PROGRESS_MSG_SCAN_BEGIN, ¶ms.progress); + if (config) { + config->_prefix = fs_source_path; + config->_prefix_num_tchars = tstrlen(fs_source_path); } - config->_prefix = fs_source_path; - config->_prefix_num_tchars = tstrlen(fs_source_path); if (wim_target_path[0] == T('\0')) - add_flags |= WIMLIB_ADD_FLAG_ROOT; + params.add_flags |= WIMLIB_ADD_FLAG_ROOT; ret = (*capture_tree)(&branch, fs_source_path, ¶ms); - if (ret) { - ERROR("Failed to build dentry tree for \"%"TS"\"", - fs_source_path); + if (ret) goto out_destroy_sd_set; - } + if (branch) { /* Use the target name, not the source name, for * the root of each branch from a capture @@ -257,12 +270,12 @@ execute_add_command(WIMStruct *wim, goto out_ntfs_umount; } if (progress_func) - progress_func(WIMLIB_PROGRESS_MSG_SCAN_END, &progress); + progress_func(WIMLIB_PROGRESS_MSG_SCAN_END, ¶ms.progress); list_splice_tail(&unhashed_streams, &imd->unhashed_streams); #ifdef WITH_NTFS_3G imd->ntfs_vol = ntfs_vol; #endif - inode_table_prepare_inode_list(&inode_table, &imd->inode_list); + inode_table_prepare_inode_list(¶ms.inode_table, &imd->inode_list); ret = 0; rollback_sd = false; if (add_flags & WIMLIB_ADD_FLAG_RPFIX) @@ -275,9 +288,9 @@ out_ntfs_umount: #endif free_dentry_tree(branch, wim->lookup_table); out_destroy_sd_set: - destroy_sd_set(&sd_set, rollback_sd); + destroy_sd_set(¶ms.sd_set, rollback_sd); out_destroy_inode_table: - destroy_inode_table(&inode_table); + destroy_inode_table(¶ms.inode_table); out: return ret; } @@ -292,8 +305,10 @@ execute_delete_command(WIMStruct *wim, bool is_root; wimlib_assert(delete_cmd->op == WIMLIB_UPDATE_OP_DELETE); - flags = delete_cmd->delete.delete_flags; - wim_path = delete_cmd->delete.wim_path; + flags = delete_cmd->delete_.delete_flags; + wim_path = delete_cmd->delete_.wim_path; + + DEBUG("Deleting WIM path \"%"TS"\" (flags=%#x)", wim_path, flags); tree = get_dentry(wim, wim_path); if (!tree) { @@ -322,7 +337,15 @@ execute_delete_command(WIMStruct *wim, return 0; } -/* +static int +free_dentry_full_path(struct wim_dentry *dentry, void *_ignore) +{ + FREE(dentry->_full_path); + dentry->_full_path = NULL; + return 0; +} + +/* * Rename a file or directory in the WIM. * * This is also called from wimfs_rename() in the FUSE mount code. @@ -382,6 +405,8 @@ rename_wim_path(WIMStruct *wim, const tchar *from, const tchar *to) } unlink_dentry(src); dentry_add_child(parent_of_dst, src); + if (src->_full_path) + for_dentry_in_tree(src, free_dentry_full_path, NULL); return 0; } @@ -397,20 +422,25 @@ execute_rename_command(WIMStruct *wim, ret = rename_wim_path(wim, rename_cmd->rename.wim_source_path, rename_cmd->rename.wim_target_path); if (ret) { + ret = -ret; + errno = ret; + ERROR_WITH_ERRNO("Can't rename \"%"TS"\" to \"%"TS"\"", + rename_cmd->rename.wim_source_path, + rename_cmd->rename.wim_target_path); switch (ret) { - case -ENOMEM: + case ENOMEM: ret = WIMLIB_ERR_NOMEM; break; - case -ENOTDIR: + case ENOTDIR: ret = WIMLIB_ERR_NOTDIR; break; - case -ENOTEMPTY: + case ENOTEMPTY: ret = WIMLIB_ERR_NOTEMPTY; break; - case -EISDIR: + case EISDIR: ret = WIMLIB_ERR_IS_DIRECTORY; break; - case -ENOENT: + case ENOENT: default: ret = WIMLIB_ERR_PATH_DOES_NOT_EXIST; break; @@ -430,7 +460,8 @@ update_op_to_str(int op) case WIMLIB_UPDATE_OP_RENAME: return T("rename"); default: - return T("???"); + wimlib_assert(0); + return NULL; } } @@ -438,34 +469,66 @@ static int execute_update_commands(WIMStruct *wim, const struct wimlib_update_command *cmds, size_t num_cmds, + int update_flags, wimlib_progress_func_t progress_func) { int ret = 0; + union wimlib_progress_info info; + info.update.completed_commands = 0; + info.update.total_commands = num_cmds; for (size_t i = 0; i < num_cmds; i++) { DEBUG("Executing update command %zu of %zu (op=%"TS")", i + 1, num_cmds, update_op_to_str(cmds[i].op)); + if (update_flags & WIMLIB_UPDATE_FLAG_SEND_PROGRESS && + progress_func) + { + info.update.command = &cmds[i]; + (*progress_func)(WIMLIB_PROGRESS_MSG_UPDATE_BEGIN_COMMAND, + &info); + } switch (cmds[i].op) { case WIMLIB_UPDATE_OP_ADD: ret = execute_add_command(wim, &cmds[i], progress_func); break; case WIMLIB_UPDATE_OP_DELETE: ret = execute_delete_command(wim, &cmds[i]); - if (ret == 0) - wim->deletion_occurred = 1; break; case WIMLIB_UPDATE_OP_RENAME: ret = execute_rename_command(wim, &cmds[i]); break; default: wimlib_assert(0); - break; } if (ret) break; + info.update.completed_commands++; + if (update_flags & WIMLIB_UPDATE_FLAG_SEND_PROGRESS && + progress_func) + { + (*progress_func)(WIMLIB_PROGRESS_MSG_UPDATE_END_COMMAND, + &info); + } } return ret; } + +tchar *winpats[] = { + T("/$ntfs.log"), + T("/hiberfil.sys"), + T("/pagefile.sys"), + T("/System Volume Information"), + T("/RECYCLER"), + T("/Windows/CSC"), +}; + +static const struct wimlib_capture_config winconfig = { + .exclusion_pats = { + .num_pats = ARRAY_LEN(winpats), + .pats = winpats, + }, +}; + static int check_add_command(struct wimlib_update_command *cmd, const struct wim_header *hdr) @@ -569,19 +632,19 @@ check_update_commands(struct wimlib_update_command *cmds, size_t num_cmds, } -extern void +static void free_update_commands(struct wimlib_update_command *cmds, size_t num_cmds) { if (cmds) { for (size_t i = 0; i < num_cmds; i++) { - switch (cmds->op) { + switch (cmds[i].op) { case WIMLIB_UPDATE_OP_ADD: FREE(cmds[i].add.fs_source_path); FREE(cmds[i].add.wim_target_path); free_capture_config(cmds[i].add.config); break; case WIMLIB_UPDATE_OP_DELETE: - FREE(cmds[i].delete.wim_path); + FREE(cmds[i].delete_.wim_path); break; case WIMLIB_UPDATE_OP_RENAME: FREE(cmds[i].rename.wim_source_path); @@ -600,6 +663,7 @@ copy_update_commands(const struct wimlib_update_command *cmds, { int ret; struct wimlib_update_command *cmds_copy; + const struct wimlib_capture_config *config; cmds_copy = CALLOC(num_cmds, sizeof(cmds[0])); if (!cmds_copy) @@ -616,8 +680,11 @@ copy_update_commands(const struct wimlib_update_command *cmds, if (!cmds_copy[i].add.fs_source_path || !cmds_copy[i].add.wim_target_path) goto oom; - if (cmds[i].add.config) { - ret = copy_and_canonicalize_capture_config(cmds[i].add.config, + config = cmds[i].add.config; + if (cmds[i].add.add_flags & WIMLIB_ADD_FLAG_WINCONFIG) + config = &winconfig; + if (config) { + ret = copy_and_canonicalize_capture_config(config, &cmds_copy[i].add.config); if (ret) goto err; @@ -625,11 +692,11 @@ copy_update_commands(const struct wimlib_update_command *cmds, cmds_copy[i].add.add_flags = cmds[i].add.add_flags; break; case WIMLIB_UPDATE_OP_DELETE: - cmds_copy[i].delete.wim_path = - canonicalize_wim_path(cmds[i].delete.wim_path); - if (!cmds_copy[i].delete.wim_path) + cmds_copy[i].delete_.wim_path = + canonicalize_wim_path(cmds[i].delete_.wim_path); + if (!cmds_copy[i].delete_.wim_path) goto oom; - cmds_copy[i].delete.delete_flags = cmds[i].delete.delete_flags; + cmds_copy[i].delete_.delete_flags = cmds[i].delete_.delete_flags; break; case WIMLIB_UPDATE_OP_RENAME: cmds_copy[i].rename.wim_source_path = @@ -657,9 +724,7 @@ err: goto out; } -/* - * Entry point for making a series of updates to a WIM image. - */ +/* API function documented in wimlib.h */ WIMLIBAPI int wimlib_update_image(WIMStruct *wim, int image, @@ -670,15 +735,21 @@ wimlib_update_image(WIMStruct *wim, { int ret; struct wimlib_update_command *cmds_copy; + bool deletion_requested = false; DEBUG("Updating image %d with %zu commands", image, num_cmds); - /* Refuse to update a split WIM. */ - if (wim->hdr.total_parts != 1) { - ERROR("Cannot update a split WIM!"); - ret = WIMLIB_ERR_SPLIT_UNSUPPORTED; + for (size_t i = 0; i < num_cmds; i++) + if (cmds[i].op == WIMLIB_UPDATE_OP_DELETE) + deletion_requested = true; + + if (deletion_requested) + ret = can_delete_from_wim(wim); + else + ret = can_modify_wim(wim); + + if (ret) goto out; - } /* Load the metadata for the image to modify (if not loaded already) */ ret = select_wim_image(wim, image); @@ -708,7 +779,8 @@ wimlib_update_image(WIMStruct *wim, /* Actually execute the update commands. */ DEBUG("Executing %zu update commands", num_cmds); - ret = execute_update_commands(wim, cmds_copy, num_cmds, progress_func); + ret = execute_update_commands(wim, cmds_copy, num_cmds, update_flags, + progress_func); if (ret) goto out_free_cmds_copy;