X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fupdate_image.c;h=05861f2d2de0697a4d21f7573e293a975490c388;hp=96583927b517c6d3a1814a206915b6366b665ec1;hb=0e8a218c22b3c5d42ccc368b3b45d270f942cfde;hpb=5e2f9715d5c0e1f1c3fc30a53d14df69a8bdae4a diff --git a/src/update_image.c b/src/update_image.c index 96583927..05861f2d 100644 --- a/src/update_image.c +++ b/src/update_image.c @@ -3,7 +3,7 @@ */ /* - * Copyright (C) 2013 Eric Biggers + * Copyright (C) 2013, 2014 Eric Biggers * * This file is part of wimlib, a library for working with WIM files. * @@ -21,41 +21,28 @@ * 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" -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif -/* Creates a new directory to place in the WIM image. This is to create parent - * directories that are not part of any target as needed. */ -static int -new_filler_directory(const tchar *name, struct wim_dentry **dentry_ret) -{ - int ret; - struct wim_dentry *dentry; +#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" - DEBUG("Creating filler directory \"%"TS"\"", name); - ret = new_dentry_with_inode(name, &dentry); - if (ret) - goto out; - /* Leave the inode number as 0; this is allowed for non - * hard-linked files. */ - dentry->d_inode->i_resolved = 1; - dentry->d_inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY; - *dentry_ret = dentry; - ret = 0; -out: - return ret; -} +#include +#include /* Overlays @branch onto @target, both of which must be directories. */ static int do_overlay(struct wim_dentry *target, struct wim_dentry *branch) { - struct rb_root *rb_root; - DEBUG("Doing overlay \"%"WS"\" => \"%"WS"\"", branch->file_name, target->file_name); @@ -65,9 +52,9 @@ do_overlay(struct wim_dentry *target, struct wim_dentry *branch) return WIMLIB_ERR_INVALID_OVERLAY; } - rb_root = &branch->d_inode->i_children; - while (rb_root->rb_node) { /* While @branch has children... */ - struct wim_dentry *child = rbnode_dentry(rb_root->rb_node); + LIST_HEAD(moved_children); + while (dentry_has_children(branch)) { + struct wim_dentry *child = dentry_any_child(branch); struct wim_dentry *existing; /* Move @child to the directory @target */ @@ -79,12 +66,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); @@ -94,17 +86,17 @@ do_overlay(struct wim_dentry *target, struct wim_dentry *branch) /* Attach or overlay a branch onto the WIM image. * * @root_p: - * Pointer to the root of the WIM image, or pointer to NULL if it has not - * been created yet. + * Pointer to the root of the WIM image, or pointer to NULL if it has not + * been created yet. * @branch - * Branch to add. + * Branch to add. * @target_path: - * Path in the WIM image to add the branch, with leading and trailing - * slashes stripped. + * Path in the WIM image to add the branch, with leading and trailing + * slashes stripped. */ static int attach_branch(struct wim_dentry **root_p, struct wim_dentry *branch, - tchar *target_path) + tchar *target_path, CASE_SENSITIVITY_TYPE case_type) { tchar *slash; struct wim_dentry *dentry, *parent, *target; @@ -140,9 +132,10 @@ 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); + dentry = get_dentry_child_with_name(parent, target_path, + case_type); if (!dentry) { ret = new_filler_directory(target_path, &dentry); if (ret) @@ -156,13 +149,14 @@ 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. * Otherwise, set the branch as the target path. */ target = get_dentry_child_with_utf16le_name(parent, branch->file_name, - branch->file_name_nbytes); + branch->file_name_nbytes, + case_type); if (target) { return do_overlay(target, branch); } else { @@ -171,6 +165,68 @@ attach_branch(struct wim_dentry **root_p, struct wim_dentry *branch, } } +static const char wincfg[] = +"[ExclusionList]\n" +"/$ntfs.log\n" +"/hiberfil.sys\n" +"/pagefile.sys\n" +"/System Volume Information\n" +"/RECYCLER\n" +"/Windows/CSC\n"; + +static int +get_capture_config(const tchar *config_file, struct capture_config *config, + int add_flags, const tchar *fs_source_path) +{ + int ret; + tchar *tmp_config_file = NULL; + + memset(config, 0, sizeof(*config)); + + /* For WIMBoot capture, check for default capture configuration file + * unless one was explicitly specified. */ + if (!config_file && (add_flags & WIMLIB_ADD_FLAG_WIMBOOT)) { + + /* XXX: Handle loading file correctly when in NTFS volume. */ + + const tchar *wimboot_cfgfile = + T("/Windows/System32/WimBootCompress.ini"); + size_t len = tstrlen(fs_source_path) + + tstrlen(wimboot_cfgfile); + tmp_config_file = MALLOC((len + 1) * sizeof(tchar)); + struct stat st; + + tsprintf(tmp_config_file, T("%"TS"%"TS), + fs_source_path, wimboot_cfgfile); + if (!tstat(tmp_config_file, &st)) { + config_file = tmp_config_file; + add_flags &= ~WIMLIB_ADD_FLAG_WINCONFIG; + } else { + WARNING("\"%"TS"\" does not exist.\n" + " Using default capture configuration!", + tmp_config_file); + } + } + + if (add_flags & WIMLIB_ADD_FLAG_WINCONFIG) { + /* Use Windows default. */ + if (config_file) + return WIMLIB_ERR_INVALID_PARAM; + ret = do_read_capture_config_file(T("wincfg"), wincfg, + sizeof(wincfg) - 1, config); + } else if (config_file) { + /* Use the specified configuration file. */ + ret = do_read_capture_config_file(config_file, NULL, 0, config); + } else { + /* ... Or don't use any configuration file at all. No files + * will be excluded from capture, all files will be compressed, + * etc. */ + ret = 0; + } + FREE(tmp_config_file); + return ret; +} + static int execute_add_command(WIMStruct *wim, const struct wimlib_update_command *add_cmd, @@ -180,16 +236,14 @@ 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; + const tchar *config_file; + struct capture_config config; #ifdef WITH_NTFS_3G struct _ntfs_volume *ntfs_vol = NULL; #endif @@ -198,16 +252,20 @@ 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; - config = add_cmd->add.config; + config_file = add_cmd->add.config_file; + 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_IMAGE_FLAG_NTFS) { + if (add_flags & WIMLIB_ADD_FLAG_NTFS) { #ifdef WITH_NTFS_3G capture_tree = build_dentry_tree_ntfs; extra_arg = &ntfs_vol; @@ -229,65 +287,66 @@ execute_add_command(WIMStruct *wim, extra_arg = NULL; } - ret = init_inode_table(&inode_table, 9001); + ret = get_capture_config(config_file, &config, + add_flags, fs_source_path); if (ret) goto out; - ret = init_sd_set(&sd_set, imd->security_data); + ret = init_inode_table(¶ms.inode_table, 9001); + if (ret) + goto out_destroy_config; + + 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_image_flags = add_flags; - params.progress_func = progress_func; + params.unhashed_streams = &unhashed_streams; + params.config = &config; + params.add_flags = add_flags; 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); - } - config->_prefix = fs_source_path; - config->_prefix_num_tchars = tstrlen(fs_source_path); + 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); + + config.prefix = fs_source_path; + config.prefix_num_tchars = tstrlen(fs_source_path); if (wim_target_path[0] == T('\0')) - add_flags |= WIMLIB_ADD_IMAGE_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 * source. (This will also set the root dentry * of the entire image to be unnamed.) */ - ret = set_dentry_name(branch, + ret = dentry_set_name(branch, path_basename(wim_target_path)); if (ret) goto out_ntfs_umount; - ret = attach_branch(&imd->root_dentry, branch, wim_target_path); + ret = attach_branch(&imd->root_dentry, branch, wim_target_path, + WIMLIB_CASE_PLATFORM_DEFAULT); if (ret) 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_IMAGE_FLAG_RPFIX) + if (add_flags & WIMLIB_ADD_FLAG_RPFIX) wim->hdr.flags |= WIM_HDR_FLAG_RP_FIX; goto out_destroy_sd_set; out_ntfs_umount: @@ -297,9 +356,11 @@ 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_destroy_config: + destroy_capture_config(&config); out: return ret; } @@ -314,10 +375,12 @@ 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); + tree = get_dentry(wim, wim_path, WIMLIB_CASE_PLATFORM_DEFAULT); if (!tree) { /* Path to delete does not exist in the WIM. */ if (flags & WIMLIB_DELETE_FLAG_FORCE) { @@ -344,70 +407,6 @@ execute_delete_command(WIMStruct *wim, return 0; } -/* - * Rename a file or directory in the WIM. - * - * This is also called from wimfs_rename() in the FUSE mount code. - */ -int -rename_wim_path(WIMStruct *wim, const tchar *from, const tchar *to) -{ - struct wim_dentry *src; - struct wim_dentry *dst; - struct wim_dentry *parent_of_dst; - int ret; - - /* This rename() implementation currently only supports actual files - * (not alternate data streams) */ - - src = get_dentry(wim, from); - if (!src) - return -errno; - - dst = get_dentry(wim, to); - - if (dst) { - /* Destination file exists */ - - if (src == dst) /* Same file */ - return 0; - - if (!dentry_is_directory(src)) { - /* Cannot rename non-directory to directory. */ - if (dentry_is_directory(dst)) - return -EISDIR; - } else { - /* Cannot rename directory to a non-directory or a non-empty - * directory */ - if (!dentry_is_directory(dst)) - return -ENOTDIR; - if (inode_has_children(dst->d_inode)) - return -ENOTEMPTY; - } - parent_of_dst = dst->parent; - } else { - /* Destination does not exist */ - parent_of_dst = get_parent_dentry(wim, to); - if (!parent_of_dst) - return -errno; - - if (!dentry_is_directory(parent_of_dst)) - return -ENOTDIR; - } - - ret = set_dentry_name(src, path_basename(to)); - if (ret) - return -ENOMEM; - if (dst) { - unlink_dentry(dst); - free_dentry_tree(dst, wim->lookup_table); - } - unlink_dentry(src); - dentry_add_child(parent_of_dst, src); - return 0; -} - - static int execute_rename_command(WIMStruct *wim, const struct wimlib_update_command *rename_cmd) @@ -417,20 +416,28 @@ execute_rename_command(WIMStruct *wim, wimlib_assert(rename_cmd->op == WIMLIB_UPDATE_OP_RENAME); ret = rename_wim_path(wim, rename_cmd->rename.wim_source_path, - rename_cmd->rename.wim_target_path); + rename_cmd->rename.wim_target_path, + WIMLIB_CASE_PLATFORM_DEFAULT); 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 -EISDIR: + case ENOTEMPTY: + ret = WIMLIB_ERR_NOTEMPTY; + break; + case EISDIR: ret = WIMLIB_ERR_IS_DIRECTORY; break; - case -ENOENT: + case ENOENT: default: ret = WIMLIB_ERR_PATH_DOES_NOT_EXIST; break; @@ -450,7 +457,8 @@ update_op_to_str(int op) case WIMLIB_UPDATE_OP_RENAME: return T("rename"); default: - return T("???"); + wimlib_assert(0); + return NULL; } } @@ -458,41 +466,72 @@ 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: - ret = WIMLIB_ERR_INVALID_PARAM; - break; + wimlib_assert(0); } if (ret) break; - wim->image_metadata[wim->current_image - 1]->modified = 1; + 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; } + static int check_add_command(struct wimlib_update_command *cmd, const struct wim_header *hdr) { int add_flags = cmd->add.add_flags; + if (add_flags & ~(WIMLIB_ADD_FLAG_NTFS | + WIMLIB_ADD_FLAG_DEREFERENCE | + WIMLIB_ADD_FLAG_VERBOSE | + /* BOOT doesn't make sense for wimlib_update_image(). */ + /*WIMLIB_ADD_FLAG_BOOT |*/ + WIMLIB_ADD_FLAG_WIMBOOT | + WIMLIB_ADD_FLAG_UNIX_DATA | + WIMLIB_ADD_FLAG_NO_ACLS | + WIMLIB_ADD_FLAG_STRICT_ACLS | + WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE | + WIMLIB_ADD_FLAG_RPFIX | + WIMLIB_ADD_FLAG_NORPFIX | + WIMLIB_ADD_FLAG_NO_UNSUPPORTED_EXCLUDE | + WIMLIB_ADD_FLAG_WINCONFIG)) + return WIMLIB_ERR_INVALID_PARAM; + /* Are we adding the entire image or not? An empty wim_target_path * indicates that the tree we're adding is to be placed in the root of * the image. We consider this to be capturing the entire image, @@ -502,30 +541,30 @@ check_add_command(struct wimlib_update_command *cmd, #ifdef __WIN32__ /* Check for flags not supported on Windows */ - if (add_flags & WIMLIB_ADD_IMAGE_FLAG_NTFS) { + if (add_flags & WIMLIB_ADD_FLAG_NTFS) { ERROR("wimlib was compiled without support for NTFS-3g, so"); ERROR("we cannot capture a WIM image directly from a NTFS volume"); return WIMLIB_ERR_UNSUPPORTED; } - if (add_flags & WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) { + if (add_flags & WIMLIB_ADD_FLAG_UNIX_DATA) { ERROR("Capturing UNIX-specific data is not supported on Windows"); - return WIMLIB_ERR_INVALID_PARAM; + return WIMLIB_ERR_UNSUPPORTED; } - if (add_flags & WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE) { + if (add_flags & WIMLIB_ADD_FLAG_DEREFERENCE) { ERROR("Dereferencing symbolic links is not supported on Windows"); - return WIMLIB_ERR_INVALID_PARAM; + return WIMLIB_ERR_UNSUPPORTED; } #endif /* VERBOSE implies EXCLUDE_VERBOSE */ - if (add_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE) - add_flags |= WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE; + if (add_flags & WIMLIB_ADD_FLAG_VERBOSE) + add_flags |= WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE; /* Check for contradictory reparse point fixup flags */ - if ((add_flags & (WIMLIB_ADD_IMAGE_FLAG_RPFIX | - WIMLIB_ADD_IMAGE_FLAG_NORPFIX)) == - (WIMLIB_ADD_IMAGE_FLAG_RPFIX | - WIMLIB_ADD_IMAGE_FLAG_NORPFIX)) + if ((add_flags & (WIMLIB_ADD_FLAG_RPFIX | + WIMLIB_ADD_FLAG_NORPFIX)) == + (WIMLIB_ADD_FLAG_RPFIX | + WIMLIB_ADD_FLAG_NORPFIX)) { ERROR("Cannot specify RPFIX and NORPFIX flags " "at the same time!"); @@ -533,34 +572,52 @@ check_add_command(struct wimlib_update_command *cmd, } /* Set default behavior on reparse point fixups if requested */ - if ((add_flags & (WIMLIB_ADD_IMAGE_FLAG_RPFIX | - WIMLIB_ADD_IMAGE_FLAG_NORPFIX)) == 0) + if ((add_flags & (WIMLIB_ADD_FLAG_RPFIX | + WIMLIB_ADD_FLAG_NORPFIX)) == 0) { /* Do reparse-point fixups by default if we are capturing an * entire image and either the header flag is set from previous * images, or if this is the first image being added. */ if (is_entire_image && ((hdr->flags & WIM_HDR_FLAG_RP_FIX) || hdr->image_count == 1)) - add_flags |= WIMLIB_ADD_IMAGE_FLAG_RPFIX; + add_flags |= WIMLIB_ADD_FLAG_RPFIX; } if (!is_entire_image) { - if (add_flags & WIMLIB_ADD_IMAGE_FLAG_NTFS) { + if (add_flags & WIMLIB_ADD_FLAG_NTFS) { ERROR("Cannot add directly from a NTFS volume " "when not capturing a full image!"); return WIMLIB_ERR_INVALID_PARAM; } - if (add_flags & WIMLIB_ADD_IMAGE_FLAG_RPFIX) { + if (add_flags & WIMLIB_ADD_FLAG_RPFIX) { ERROR("Cannot do reparse point fixups when " "not capturing a full image!"); return WIMLIB_ERR_INVALID_PARAM; } } + /* We may have modified the add flags. */ cmd->add.add_flags = add_flags; return 0; } +static int +check_delete_command(const struct wimlib_update_command *cmd) +{ + if (cmd->delete_.delete_flags & ~(WIMLIB_DELETE_FLAG_FORCE | + WIMLIB_DELETE_FLAG_RECURSIVE)) + return WIMLIB_ERR_INVALID_PARAM; + return 0; +} + +static int +check_rename_command(const struct wimlib_update_command *cmd) +{ + if (cmd->rename.rename_flags != 0) + return WIMLIB_ERR_INVALID_PARAM; + return 0; +} + static int check_update_command(struct wimlib_update_command *cmd, const struct wim_header *hdr) @@ -569,8 +626,9 @@ check_update_command(struct wimlib_update_command *cmd, case WIMLIB_UPDATE_OP_ADD: return check_add_command(cmd, hdr); case WIMLIB_UPDATE_OP_DELETE: + return check_delete_command(cmd); case WIMLIB_UPDATE_OP_RENAME: - break; + return check_rename_command(cmd); } return 0; } @@ -589,19 +647,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); + FREE(cmds[i].add.config_file); 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); @@ -636,20 +694,19 @@ 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, - &cmds_copy[i].add.config); - if (ret) - goto err; + if (cmds[i].add.config_file) { + cmds_copy[i].add.config_file = TSTRDUP(cmds[i].add.config_file); + if (!cmds_copy[i].add.config_file) + goto oom; } 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 = @@ -677,9 +734,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, @@ -690,15 +745,24 @@ wimlib_update_image(WIMStruct *wim, { int ret; struct wimlib_update_command *cmds_copy; + bool deletion_requested = false; + + if (update_flags & ~WIMLIB_UPDATE_FLAG_SEND_PROGRESS) + return WIMLIB_ERR_INVALID_PARAM; 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); @@ -728,14 +792,17 @@ 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; + wim->image_metadata[image - 1]->modified = 1; + /* Statistics about the WIM image, such as the numbers of files and * directories, may have changed. Call xml_update_image_info() to * recalculate these statistics. */ - xml_update_image_info(wim, wim->current_image); + xml_update_image_info(wim, image); out_free_cmds_copy: free_update_commands(cmds_copy, num_cmds); out: