Initial update functionality (library only)
authorEric Biggers <ebiggers3@gmail.com>
Sat, 11 May 2013 05:54:57 +0000 (00:54 -0500)
committerEric Biggers <ebiggers3@gmail.com>
Sat, 11 May 2013 05:54:57 +0000 (00:54 -0500)
16 files changed:
Makefile.am
src/add_image.c
src/capture_common.c [new file with mode: 0644]
src/dentry.c
src/extract_image.c
src/hardlink.c
src/mount_image.c
src/security.c
src/security.h
src/unix_capture.c [new file with mode: 0644]
src/update_image.c [new file with mode: 0644]
src/util.c
src/wim.c
src/wimlib.h
src/wimlib_internal.h
src/win32.c

index 94af43d..788a723 100644 (file)
@@ -11,6 +11,7 @@ libwim_la_LDFLAGS = -version-info 6:0:0 $(WINDOWS_LDFLAGS)
 libwim_la_SOURCES =            \
        src/add_image.c         \
        src/buffer_io.h         \
+       src/capture_common.c    \
        src/compress.c          \
        src/compress.h          \
        src/decompress.c        \
@@ -46,6 +47,7 @@ libwim_la_SOURCES =           \
        src/split.c             \
        src/reparse.c           \
        src/timestamp.h         \
+       src/update_image.c      \
        src/util.c              \
        src/util.h              \
        src/verify.c            \
@@ -106,6 +108,8 @@ imagex_SOURCES += programs/imagex-win32.c   \
                  programs/wgetopt.h
 
 libwim_la_SOURCES += src/win32.c
+else
+libwim_la_SOURCES += src/unix_capture.c
 endif
 
 install-exec-hook:
index c39ded6..74d93f9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * add_image.c
+ * add_image.c - Add an image to a WIM file.
  */
 
 /*
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
-#include "config.h"
-
-#ifdef __WIN32__
-#  include "win32.h"
-#else
-#  include <dirent.h>
-#  include <sys/stat.h>
-#  include <fnmatch.h>
-#  include "timestamp.h"
-#endif
-
 #include "wimlib_internal.h"
-#include "dentry.h"
 #include "lookup_table.h"
 #include "xml.h"
-#include "security.h"
-
-#include <ctype.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <string.h>
-
-#include <unistd.h>
-
-#ifdef HAVE_ALLOCA_H
-#  include <alloca.h>
-#endif
 
 /*
  * Adds the dentry tree and security data for a new image to the image metadata
  * array of the WIMStruct.
  */
 static int
-add_new_dentry_tree(WIMStruct *w, struct wim_dentry *root_dentry,
+add_new_dentry_tree(WIMStruct *wim, struct wim_dentry *root_dentry,
                    struct wim_security_data *sd)
 {
        struct wim_image_metadata *new_imd;
@@ -80,954 +55,154 @@ add_new_dentry_tree(WIMStruct *w, struct wim_dentry *root_dentry,
        new_imd->security_data  = sd;
        new_imd->modified       = 1;
 
-       ret = append_image_metadata(w, new_imd);
+       ret = append_image_metadata(wim, new_imd);
        if (ret)
                put_image_metadata(new_imd, NULL);
        return ret;
-
-}
-
-#ifndef __WIN32__
-
-static int
-unix_capture_regular_file(const char *path,
-                         u64 size,
-                         struct wim_inode *inode,
-                         struct wim_lookup_table *lookup_table)
-{
-       inode->i_attributes = FILE_ATTRIBUTE_NORMAL;
-
-       /* Empty files do not have to have a lookup table entry. */
-       if (size != 0) {
-               struct wim_lookup_table_entry *lte;
-               char *file_on_disk;
-
-               file_on_disk = STRDUP(path);
-               if (!file_on_disk)
-                       return WIMLIB_ERR_NOMEM;
-               lte = new_lookup_table_entry();
-               if (!lte) {
-                       FREE(file_on_disk);
-                       return WIMLIB_ERR_NOMEM;
-               }
-               lte->file_on_disk = file_on_disk;
-               lte->resource_location = RESOURCE_IN_FILE_ON_DISK;
-               lte->resource_entry.original_size = size;
-               lookup_table_insert_unhashed(lookup_table, lte, inode, 0);
-               inode->i_lte = lte;
-       }
-       return 0;
-}
-
-static int
-unix_build_dentry_tree_recursive(struct wim_dentry **root_ret,
-                                char *path,
-                                size_t path_len,
-                                struct add_image_params *params);
-
-static int
-unix_capture_directory(struct wim_dentry *dir_dentry,
-                      char *path,
-                      size_t path_len,
-                      struct add_image_params *params)
-{
-
-       DIR *dir;
-       struct dirent *entry;
-       struct wim_dentry *child;
-       int ret;
-
-       dir_dentry->d_inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY;
-       dir = opendir(path);
-       if (!dir) {
-               ERROR_WITH_ERRNO("Failed to open the directory `%s'",
-                                path);
-               return WIMLIB_ERR_OPEN;
-       }
-
-       /* Recurse on directory contents */
-       ret = 0;
-       for (;;) {
-               errno = 0;
-               entry = readdir(dir);
-               if (!entry) {
-                       if (errno) {
-                               ret = WIMLIB_ERR_READ;
-                               ERROR_WITH_ERRNO("Error reading the "
-                                                "directory `%s'", path);
-                       }
-                       break;
-               }
-
-               if (entry->d_name[0] == '.' && (entry->d_name[1] == '\0'
-                     || (entry->d_name[1] == '.' && entry->d_name[2] == '\0')))
-                               continue;
-
-               size_t name_len = strlen(entry->d_name);
-
-               path[path_len] = '/';
-               memcpy(&path[path_len + 1], entry->d_name, name_len + 1);
-               ret = unix_build_dentry_tree_recursive(&child,
-                                                      path,
-                                                      path_len + 1 + name_len,
-                                                      params);
-               if (ret)
-                       break;
-               if (child)
-                       dentry_add_child(dir_dentry, child);
-       }
-       closedir(dir);
-       return ret;
 }
 
-static int
-unix_capture_symlink(struct wim_dentry **root_p,
-                    const char *path,
-                    struct wim_inode *inode,
-                    struct add_image_params *params)
+/* Append an empty image to the WIMStruct. */
+WIMLIBAPI int
+wimlib_add_empty_image(WIMStruct *wim, const tchar *name, int *new_idx_ret)
 {
-       char deref_name_buf[4096];
-       ssize_t deref_name_len;
        int ret;
+       struct wim_security_data *sd;
 
-       inode->i_attributes = FILE_ATTRIBUTE_REPARSE_POINT;
-       inode->i_reparse_tag = WIM_IO_REPARSE_TAG_SYMLINK;
-
-       /* The idea here is to call readlink() to get the UNIX target of
-        * the symbolic link, then turn the target into a reparse point
-        * data buffer that contains a relative or absolute symbolic
-        * link (NOT a junction point or *full* path symbolic link with
-        * drive letter).
-        */
-       deref_name_len = readlink(path, deref_name_buf,
-                                 sizeof(deref_name_buf) - 1);
-       if (deref_name_len >= 0) {
-               char *dest = deref_name_buf;
-
-               dest[deref_name_len] = '\0';
-               DEBUG("Read symlink `%s'", dest);
-
-               if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_RPFIX) &&
-                    dest[0] == '/')
-               {
-                       dest = capture_fixup_absolute_symlink(dest,
-                                                             params->capture_root_ino,
-                                                             params->capture_root_dev);
-                       if (!dest) {
-                               WARNING("Ignoring out of tree absolute symlink "
-                                       "\"%s\" -> \"%s\"\n"
-                                       "          (Use --norpfix to capture "
-                                       "absolute symlinks as-is)",
-                                       path, deref_name_buf);
-                               free_dentry(*root_p);
-                               *root_p = NULL;
-                               return 0;
-                       }
-                       inode->i_not_rpfixed = 0;
-               }
-               ret = wim_inode_set_symlink(inode, dest, params->lookup_table);
-               if (ret == 0) {
-                       /* Unfortunately, Windows seems to have the concept of
-                        * "file" symbolic links as being different from
-                        * "directory" symbolic links...  so
-                        * FILE_ATTRIBUTE_DIRECTORY needs to be set on the
-                        * symbolic link if the *target* of the symbolic link is
-                        * a directory.  */
-                       struct stat stbuf;
-                       if (stat(path, &stbuf) == 0 && S_ISDIR(stbuf.st_mode))
-                               inode->i_attributes |= FILE_ATTRIBUTE_DIRECTORY;
-               }
-       } else {
-               ERROR_WITH_ERRNO("Failed to read target of "
-                                "symbolic link `%s'", path);
-               ret = WIMLIB_ERR_READLINK;
-       }
-       return ret;
-}
-
-static int
-unix_build_dentry_tree_recursive(struct wim_dentry **root_ret,
-                                char *path,
-                                size_t path_len,
-                                struct add_image_params *params)
-{
-       struct wim_dentry *root = NULL;
-       int ret = 0;
-       struct wim_inode *inode;
+       DEBUG("Adding empty image \"%"TS"\"", name);
 
-       if (exclude_path(path, path_len, params->config, true)) {
-               if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE)
-                   && params->progress_func)
-               {
-                       union wimlib_progress_info info;
-                       info.scan.cur_path = path;
-                       info.scan.excluded = true;
-                       params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
-               }
+       if (name == NULL || name[0] == T('\0')) {
+               ERROR("Must specify a non-empty string for the image name");
+               ret = WIMLIB_ERR_INVALID_PARAM;
                goto out;
        }
 
-       if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE)
-           && params->progress_func)
-       {
-               union wimlib_progress_info info;
-               info.scan.cur_path = path;
-               info.scan.excluded = false;
-               params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
+       if (wim->hdr.total_parts != 1) {
+               ERROR("Cannot add an image to a split WIM");
+               ret = WIMLIB_ERR_SPLIT_UNSUPPORTED;
+               goto out;
        }
 
-       struct stat stbuf;
-       int (*stat_fn)(const char *restrict, struct stat *restrict);
-       if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE) ||
-           (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT))
-               stat_fn = stat;
-       else
-               stat_fn = lstat;
-
-       ret = (*stat_fn)(path, &stbuf);
-       if (ret != 0) {
-               ERROR_WITH_ERRNO("Failed to stat `%s'", path);
+       if (wimlib_image_name_in_use(wim, name)) {
+               ERROR("There is already an image named \"%"TS"\" in the WIM!",
+                     name);
+               ret = WIMLIB_ERR_IMAGE_NAME_COLLISION;
                goto out;
        }
-       if (!S_ISREG(stbuf.st_mode) && !S_ISDIR(stbuf.st_mode)
-           && !S_ISLNK(stbuf.st_mode)) {
-               ERROR("`%s' is not a regular file, directory, or symbolic link.",
-                     path);
-               ret = WIMLIB_ERR_SPECIAL_FILE;
+
+       sd = new_wim_security_data();
+       if (!sd) {
+               ret = WIMLIB_ERR_NOMEM;
                goto out;
        }
 
-       ret = inode_table_new_dentry(params->inode_table,
-                                    path_basename_with_len(path, path_len),
-                                    stbuf.st_ino, stbuf.st_dev, false, &root);
+       ret = add_new_dentry_tree(wim, NULL, sd);
        if (ret)
-               goto out;
-
-       inode = root->d_inode;
-
-       if (inode->i_nlink > 1) /* Already captured this inode? */
-               goto out;
+               goto out_free_security_data;
 
-#ifdef HAVE_STAT_NANOSECOND_PRECISION
-       inode->i_creation_time = timespec_to_wim_timestamp(stbuf.st_mtim);
-       inode->i_last_write_time = timespec_to_wim_timestamp(stbuf.st_mtim);
-       inode->i_last_access_time = timespec_to_wim_timestamp(stbuf.st_atim);
-#else
-       inode->i_creation_time = unix_timestamp_to_wim(stbuf.st_mtime);
-       inode->i_last_write_time = unix_timestamp_to_wim(stbuf.st_mtime);
-       inode->i_last_access_time = unix_timestamp_to_wim(stbuf.st_atime);
-#endif
-       inode->i_resolved = 1;
-       if (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) {
-               ret = inode_set_unix_data(inode, stbuf.st_uid,
-                                         stbuf.st_gid,
-                                         stbuf.st_mode,
-                                         params->lookup_table,
-                                         UNIX_DATA_ALL | UNIX_DATA_CREATE);
-               if (ret)
-                       goto out;
-       }
-       params->add_image_flags &=
-               ~(WIMLIB_ADD_IMAGE_FLAG_ROOT | WIMLIB_ADD_IMAGE_FLAG_SOURCE);
-       if (S_ISREG(stbuf.st_mode))
-               ret = unix_capture_regular_file(path, stbuf.st_size,
-                                               inode, params->lookup_table);
-       else if (S_ISDIR(stbuf.st_mode))
-               ret = unix_capture_directory(root, path, path_len, params);
-       else
-               ret = unix_capture_symlink(&root, path, inode, params);
+       ret = xml_add_image(wim, name);
+       if (ret)
+               goto out_put_image_metadata;
+
+       if (new_idx_ret)
+               *new_idx_ret = wim->hdr.image_count;
+       DEBUG("Successfully added new image (index %d)",
+             wim->hdr.image_count);
+       goto out;
+out_put_image_metadata:
+       put_image_metadata(wim->image_metadata[--wim->hdr.image_count],
+                          wim->lookup_table);
+       goto out;
+out_free_security_data:
+       free_security_data(sd);
 out:
-       if (ret == 0)
-               *root_ret = root;
-       else
-               free_dentry_tree(root, params->lookup_table);
-       return ret;
-}
-
-/*
- * unix_build_dentry_tree():
- *     Builds a tree of WIM dentries from an on-disk directory tree (UNIX
- *     version; no NTFS-specific data is captured).
- *
- * @root_ret:   Place to return a pointer to the root of the dentry tree.  Only
- *             modified if successful.  Set to NULL if the file or directory was
- *             excluded from capture.
- *
- * @root_disk_path:  The path to the root of the directory tree on disk.
- *
- * @params:     See doc for `struct add_image_params'.
- *
- * @return:    0 on success, nonzero on failure.  It is a failure if any of
- *             the files cannot be `stat'ed, or if any of the needed
- *             directories cannot be opened or read.  Failure to add the files
- *             to the WIM may still occur later when trying to actually read
- *             the on-disk files during a call to wimlib_write() or
- *             wimlib_overwrite().
- */
-static int
-unix_build_dentry_tree(struct wim_dentry **root_ret,
-                      const char *root_disk_path,
-                      struct add_image_params *params)
-{
-       char *path_buf;
-       int ret;
-       size_t path_len;
-       size_t path_bufsz;
-
-       {
-               struct stat root_stbuf;
-               if (stat(root_disk_path, &root_stbuf)) {
-                       ERROR_WITH_ERRNO("Failed to stat \"%s\"", root_disk_path);
-                       return WIMLIB_ERR_STAT;
-               }
-
-               if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT) &&
-                   !S_ISDIR(root_stbuf.st_mode))
-               {
-                       ERROR("Root of capture \"%s\" is not a directory",
-                             root_disk_path);
-                       return WIMLIB_ERR_NOTDIR;
-               }
-               params->capture_root_ino = root_stbuf.st_ino;
-               params->capture_root_dev = root_stbuf.st_dev;
-       }
-
-       path_bufsz = min(32790, PATH_MAX + 1);
-       path_len = strlen(root_disk_path);
-
-       if (path_len >= path_bufsz)
-               return WIMLIB_ERR_INVALID_PARAM;
-
-       path_buf = MALLOC(path_bufsz);
-       if (!path_buf)
-               return WIMLIB_ERR_NOMEM;
-       memcpy(path_buf, root_disk_path, path_len + 1);
-
-       ret = unix_build_dentry_tree_recursive(root_ret, path_buf,
-                                              path_len, params);
-       FREE(path_buf);
-       return ret;
-}
-#endif /* !__WIN32__ */
-
-static bool
-match_pattern(const tchar *path,
-             const tchar *path_basename,
-             const struct wimlib_pattern_list *list)
-{
-       for (size_t i = 0; i < list->num_pats; i++) {
-
-               const tchar *pat = list->pats[i];
-               const tchar *string;
-
-               if (*pat == T('/')) {
-                       /* Absolute path from root of capture */
-                       string = path;
-               } else {
-                       if (tstrchr(pat, T('/')))
-                               /* Relative path from root of capture */
-                               string = path + 1;
-                       else
-                               /* A file name pattern */
-                               string = path_basename;
-               }
-
-               /* Warning: on Windows native builds, fnmatch() calls the
-                * replacement function in win32.c. */
-               if (fnmatch(pat, string, FNM_PATHNAME | FNM_NOESCAPE
-                               #ifdef FNM_CASEFOLD
-                                       | FNM_CASEFOLD
-                               #endif
-                           ) == 0)
-               {
-                       DEBUG("\"%"TS"\" matches the pattern \"%"TS"\"",
-                             string, pat);
-                       return true;
-               } else {
-                       DEBUG2("\"%"TS"\" does not match the pattern \"%"TS"\"",
-                              string, pat);
-               }
-       }
-       return false;
-}
-
-/* Return true if the image capture configuration file indicates we should
- * exclude the filename @path from capture.
- *
- * If @exclude_prefix is %true, the part of the path up and including the name
- * of the directory being captured is not included in the path for matching
- * purposes.  This allows, for example, a pattern like /hiberfil.sys to match a
- * file /mnt/windows7/hiberfil.sys if we are capturing the /mnt/windows7
- * directory.
- */
-bool
-exclude_path(const tchar *path, size_t path_len,
-            const struct wimlib_capture_config *config, bool exclude_prefix)
-{
-       const tchar *basename = path_basename_with_len(path, path_len);
-       if (exclude_prefix) {
-               wimlib_assert(path_len >= config->_prefix_num_tchars);
-               if (!tmemcmp(config->_prefix, path, config->_prefix_num_tchars) &&
-                   path[config->_prefix_num_tchars] == T('/'))
-               {
-                       path += config->_prefix_num_tchars;
-               }
-       }
-       return match_pattern(path, basename, &config->exclusion_pats) &&
-               !match_pattern(path, basename, &config->exclusion_exception_pats);
-
-}
-
-/* Strip leading and trailing slashes from the target paths, and translate all
- * backslashes in the source and target paths into forward slashes. */
-static void
-canonicalize_sources_and_targets(struct wimlib_capture_source *sources,
-                                size_t num_sources)
-{
-       while (num_sources--) {
-               DEBUG("Canonicalizing { source: \"%"TS"\", target=\"%"TS"\"}",
-                     sources->fs_source_path,
-                     sources->wim_target_path);
-
-               /* The Windows API can handle forward slashes.  Just get rid of
-                * backslashes to avoid confusing other parts of the library
-                * code. */
-               sources->fs_source_path = canonicalize_fs_path(sources->fs_source_path);
-               sources->wim_target_path = canonicalize_wim_path(sources->wim_target_path);
-               DEBUG("Canonical target: \"%"TS"\"", sources->wim_target_path);
-               sources++;
-       }
-}
-
-static int
-capture_source_cmp(const void *p1, const void *p2)
-{
-       const struct wimlib_capture_source *s1 = p1, *s2 = p2;
-       return tstrcmp(s1->wim_target_path, s2->wim_target_path);
-}
-
-/* Sorts the capture sources lexicographically by target path.  This occurs
- * after leading and trailing forward slashes are stripped.
- *
- * One purpose of this is to make sure that target paths that are inside other
- * target paths are added after the containing target paths. */
-static void
-sort_sources(struct wimlib_capture_source *sources, size_t num_sources)
-{
-       qsort(sources, num_sources, sizeof(sources[0]), capture_source_cmp);
-}
-
-static int
-check_sorted_sources(struct wimlib_capture_source *sources, size_t num_sources,
-                    int add_image_flags)
-{
-       if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NTFS) {
-               if (num_sources != 1) {
-                       ERROR("Must specify exactly 1 capture source "
-                             "(the NTFS volume) in NTFS mode!");
-                       return WIMLIB_ERR_INVALID_PARAM;
-               }
-               if (sources[0].wim_target_path[0] != T('\0')) {
-                       ERROR("In NTFS capture mode the target path inside "
-                             "the image must be the root directory!");
-                       return WIMLIB_ERR_INVALID_PARAM;
-               }
-       } else if (num_sources != 0) {
-               /* This code is disabled because the current code
-                * unconditionally attempts to do overlays.  So, duplicate
-                * target paths are OK. */
-       #if 0
-               if (num_sources > 1 && sources[0].wim_target_path[0] == '\0') {
-                       ERROR("Cannot specify root target when using multiple "
-                             "capture sources!");
-                       return WIMLIB_ERR_INVALID_PARAM;
-               }
-               for (size_t i = 0; i < num_sources - 1; i++) {
-                       size_t len = strlen(sources[i].wim_target_path);
-                       size_t j = i + 1;
-                       const char *target1 = sources[i].wim_target_path;
-                       do {
-                               const char *target2 = sources[j].wim_target_path;
-                               DEBUG("target1=%s, target2=%s",
-                                     target1,target2);
-                               if (strncmp(target1, target2, len) ||
-                                   target2[len] > '/')
-                                       break;
-                               if (target2[len] == '/') {
-                                       ERROR("Invalid target `%s': is a prefix of `%s'",
-                                             target1, target2);
-                                       return WIMLIB_ERR_INVALID_PARAM;
-                               }
-                               if (target2[len] == '\0') {
-                                       ERROR("Invalid target `%s': is a duplicate of `%s'",
-                                             target1, target2);
-                                       return WIMLIB_ERR_INVALID_PARAM;
-                               }
-                       } while (++j != num_sources);
-               }
-       #endif
-       }
-       return 0;
-
-}
-
-/* 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;
-
-       DEBUG("Creating filler directory \"%"TS"\"", name);
-       ret = new_dentry_with_inode(name, &dentry);
-       if (ret == 0) {
-               /* 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;
-       }
        return ret;
 }
 
-/* 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);
-
-       if (!dentry_is_directory(branch) || !dentry_is_directory(target)) {
-               ERROR("Cannot overlay \"%"WS"\" onto existing dentry: "
-                     "is not directory-on-directory!", branch->file_name);
-               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);
-               struct wim_dentry *existing;
-
-               /* Move @child to the directory @target */
-               unlink_dentry(child);
-               existing = dentry_add_child(target, child);
-
-               /* File or directory with same name already exists */
-               if (existing) {
-                       int ret;
-                       ret = do_overlay(existing, child);
-                       if (ret) {
-                               /* Overlay failed.  Revert the change to avoid
-                                * leaking the directory tree rooted at @child.
-                                * */
-                               dentry_add_child(branch, child);
-                               return ret;
-                       }
-               }
-       }
-       free_dentry(branch);
-       return 0;
-}
-
-/* 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.
- * @branch
- *     Branch to add.
- * @target_path:
- *     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 *slash;
-       struct wim_dentry *dentry, *parent, *target;
-       int ret;
-
-       DEBUG("Attaching branch \"%"WS"\" => \"%"TS"\"",
-             branch->file_name, target_path);
-
-       if (*target_path == T('\0')) {
-               /* Target: root directory */
-               if (*root_p) {
-                       /* Overlay on existing root */
-                       return do_overlay(*root_p, branch);
-               } else  {
-                       /* Set as root */
-                       *root_p = branch;
-                       return 0;
-               }
-       }
-
-       /* Adding a non-root branch.  Create root if it hasn't been created
-        * already. */
-       if (!*root_p) {
-               ret  = new_filler_directory(T(""), root_p);
-               if (ret)
-                       return ret;
-       }
-
-       /* Walk the path to the branch, creating filler directories as needed.
-        * */
-       parent = *root_p;
-       while ((slash = tstrchr(target_path, T('/')))) {
-               *slash = T('\0');
-               dentry = get_dentry_child_with_name(parent, target_path);
-               if (!dentry) {
-                       ret = new_filler_directory(target_path, &dentry);
-                       if (ret)
-                               return ret;
-                       dentry_add_child(parent, dentry);
-               }
-               parent = dentry;
-               target_path = slash;
-               /* Skip over slashes.  Note: this cannot overrun the length of
-                * the string because the last character cannot be a slash, as
-                * trailing slashes were tripped.  */
-               do {
-                       ++target_path;
-               } while (*target_path == T('/'));
-       }
-
-       /* 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);
-       if (target) {
-               return do_overlay(target, branch);
-       } else {
-               dentry_add_child(parent, branch);
-               return 0;
-       }
-}
-
-static int
-canonicalize_pat(tchar **pat_p)
+static struct wimlib_update_command *
+capture_sources_to_add_cmds(const struct wimlib_capture_source *sources,
+                           size_t num_sources,
+                           int add_image_flags,
+                           const struct wimlib_capture_config *config)
 {
-       tchar *pat = *pat_p;
-
-       /* Turn all backslashes in the pattern into forward slashes. */
-       zap_backslashes(pat);
+       struct wimlib_update_command *add_cmds;
 
-       if (*pat != T('/') && *pat != T('\0') && *(pat + 1) == T(':')) {
-               /* Pattern begins with drive letter */
-               if (*(pat + 2) != T('/')) {
-                       /* Something like c:file, which is actually a path
-                        * relative to the current working directory on the c:
-                        * drive.  We require paths with drive letters to be
-                        * absolute. */
-                       ERROR("Invalid path \"%"TS"\"; paths including drive letters "
-                             "must be absolute!", pat);
-                       ERROR("Maybe try \"%"TC":/%"TS"\"?",
-                             *pat, pat + 2);
-                       return WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
+       DEBUG("Translating %zu capture sources to wimlib_update_command's",
+             num_sources);
+       add_cmds = CALLOC(num_sources, sizeof(add_cmds[0]));
+       if (add_cmds) {
+               for (size_t i = 0; i < num_sources; i++) {
+                       DEBUG("Source %zu of %zu: fs_source_path=\"%"TS"\", "
+                             "wim_target_path=\"%"TS"\"",
+                             i + 1, num_sources,
+                             sources[i].fs_source_path,
+                             sources[i].wim_target_path);
+                       add_cmds[i].op = WIMLIB_UPDATE_OP_ADD;
+                       add_cmds[i].add.add_flags = add_image_flags;
+                       add_cmds[i].add.config = (struct wimlib_capture_config*)config;
+                       add_cmds[i].add.fs_source_path = sources[i].fs_source_path;
+                       add_cmds[i].add.wim_target_path = sources[i].wim_target_path;
                }
-
-               WARNING("Pattern \"%"TS"\" starts with a drive letter, which is "
-                       "being removed.", pat);
-               /* Strip the drive letter */
-               pat += 2;
-               *pat_p = pat;
        }
-       return 0;
-}
-
-static int
-canonicalize_pat_list(struct wimlib_pattern_list *pat_list)
-{
-       int ret = 0;
-       for (size_t i = 0; i < pat_list->num_pats; i++) {
-               ret = canonicalize_pat(&pat_list->pats[i]);
-               if (ret)
-                       break;
-       }
-       return ret;
-}
-
-static int
-canonicalize_capture_config(struct wimlib_capture_config *config)
-{
-       int ret = canonicalize_pat_list(&config->exclusion_pats);
-       if (ret)
-               return ret;
-       return canonicalize_pat_list(&config->exclusion_exception_pats);
+       return add_cmds;
 }
 
 WIMLIBAPI int
-wimlib_add_image_multisource(WIMStruct *w,
-                            struct wimlib_capture_source *sources,
+wimlib_add_image_multisource(WIMStruct *wim,
+                            const struct wimlib_capture_source *sources,
                             size_t num_sources,
                             const tchar *name,
-                            struct wimlib_capture_config *config,
+                            const struct wimlib_capture_config *config,
                             int add_image_flags,
                             wimlib_progress_func_t progress_func)
 {
-       int (*capture_tree)(struct wim_dentry **,
-                           const tchar *,
-                           struct add_image_params *);
-       void *extra_arg;
-       struct wim_dentry *root_dentry;
-       struct wim_dentry *branch;
-       struct wim_security_data *sd;
-       struct wim_image_metadata *imd;
-       struct wim_inode_table inode_table;
-       struct list_head unhashed_streams;
-       struct add_image_params params;
        int ret;
-       struct sd_set sd_set;
-#ifdef WITH_NTFS_3G
-       struct _ntfs_volume *ntfs_vol = NULL;
-#endif
-
-       if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NTFS) {
-#ifdef WITH_NTFS_3G
-               if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE) {
-                       ERROR("Cannot dereference files when capturing directly from NTFS");
-                       return WIMLIB_ERR_INVALID_PARAM;
-               }
-               if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) {
-                       ERROR("Capturing UNIX owner and mode not supported "
-                             "when capturing directly from NTFS");
-                       return WIMLIB_ERR_INVALID_PARAM;
-               }
-               capture_tree = build_dentry_tree_ntfs;
-               extra_arg = &ntfs_vol;
-#else
-               ERROR("wimlib was compiled without support for NTFS-3g, so\n"
-                     "        cannot capture a WIM image directly from a NTFS volume!");
-               return WIMLIB_ERR_UNSUPPORTED;
-#endif
-       } else {
-       #ifdef __WIN32__
-               capture_tree = win32_build_dentry_tree;
-       #else
-               capture_tree = unix_build_dentry_tree;
-       #endif
-               extra_arg = NULL;
-       }
-
-#ifdef __WIN32__
-       if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) {
-               ERROR("Capturing UNIX-specific data is not supported on Windows");
-               return WIMLIB_ERR_INVALID_PARAM;
-       }
-       if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE) {
-               ERROR("Dereferencing symbolic links is not supported on Windows");
-               return WIMLIB_ERR_INVALID_PARAM;
-       }
-#endif
-
-       if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE)
-               add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE;
-
-       if ((add_image_flags & (WIMLIB_ADD_IMAGE_FLAG_RPFIX |
-                               WIMLIB_ADD_IMAGE_FLAG_RPFIX)) ==
-               (WIMLIB_ADD_IMAGE_FLAG_RPFIX | WIMLIB_ADD_IMAGE_FLAG_NORPFIX))
-       {
-               ERROR("Cannot specify RPFIX and NORPFIX flags at the same time!");
-               return WIMLIB_ERR_INVALID_PARAM;
-       }
-
-       if ((add_image_flags & (WIMLIB_ADD_IMAGE_FLAG_RPFIX |
-                               WIMLIB_ADD_IMAGE_FLAG_NORPFIX)) == 0)
-       {
-               /* Do reparse-point fixups by default if the header flag is set
-                * from previous images, or if this is the first image being
-                * added. */
-               if ((w->hdr.flags & WIM_HDR_FLAG_RP_FIX) || w->hdr.image_count == 0)
-                       add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_RPFIX;
-       }
-
-       if (!name || !*name) {
-               ERROR("Must specify a non-empty string for the image name");
-               return WIMLIB_ERR_INVALID_PARAM;
-       }
-
-       if (w->hdr.total_parts != 1) {
-               ERROR("Cannot add an image to a split WIM");
-               return WIMLIB_ERR_SPLIT_UNSUPPORTED;
-       }
+       struct wimlib_update_command *add_cmds;
 
-       if (wimlib_image_name_in_use(w, name)) {
-               ERROR("There is already an image named \"%"TS"\" in the WIM!",
-                     name);
-               return WIMLIB_ERR_IMAGE_NAME_COLLISION;
-       }
+       DEBUG("Adding image \"%"TS"\" from %zu sources (add_image_flags=%x)",
+             name, num_sources, add_image_flags);
 
-       if (!config) {
-               DEBUG("Capture config not provided; using empty config");
-               config = alloca(sizeof(*config));
-               memset(config, 0, sizeof(*config));
-       }
-
-       ret = canonicalize_capture_config(config);
+       ret = wimlib_add_empty_image(wim, name, NULL);
        if (ret)
                goto out;
 
-       ret = init_inode_table(&inode_table, 9001);
-       if (ret)
-               goto out;
-
-       DEBUG("Allocating security data");
-       sd = CALLOC(1, sizeof(struct wim_security_data));
-       if (!sd) {
+       add_cmds = capture_sources_to_add_cmds(sources, num_sources,
+                                              add_image_flags, config);
+       if (!add_cmds) {
                ret = WIMLIB_ERR_NOMEM;
-               goto out_destroy_inode_table;
-       }
-       sd->total_length = 8;
-
-       sd_set.sd = sd;
-       sd_set.rb_root.rb_node = NULL;
-
-
-       DEBUG("Using %zu capture sources", num_sources);
-       canonicalize_sources_and_targets(sources, num_sources);
-       sort_sources(sources, num_sources);
-       ret = check_sorted_sources(sources, num_sources, add_image_flags);
-       if (ret) {
-               ret = WIMLIB_ERR_INVALID_PARAM;
-               goto out_free_security_data;
-       }
-
-       INIT_LIST_HEAD(&unhashed_streams);
-       w->lookup_table->unhashed_streams = &unhashed_streams;
-       root_dentry = NULL;
-
-       params.lookup_table = w->lookup_table;
-       params.inode_table = &inode_table;
-       params.sd_set = &sd_set;
-       params.config = config;
-       params.add_image_flags = add_image_flags;
-       params.progress_func = progress_func;
-       params.extra_arg = extra_arg;
-       for (size_t i = 0; i < num_sources; i++) {
-               int flags;
-               union wimlib_progress_info progress;
-
-               DEBUG("Building dentry tree for source %zu of %zu "
-                     "(\"%"TS"\" => \"%"TS"\")", i + 1, num_sources,
-                     sources[i].fs_source_path,
-                     sources[i].wim_target_path);
-               if (progress_func) {
-                       memset(&progress, 0, sizeof(progress));
-                       progress.scan.source = sources[i].fs_source_path;
-                       progress.scan.wim_target_path = sources[i].wim_target_path;
-                       progress_func(WIMLIB_PROGRESS_MSG_SCAN_BEGIN, &progress);
-               }
-               config->_prefix = sources[i].fs_source_path;
-               config->_prefix_num_tchars = tstrlen(sources[i].fs_source_path);
-               flags = add_image_flags | WIMLIB_ADD_IMAGE_FLAG_SOURCE;
-               if (!*sources[i].wim_target_path)
-                       flags |= WIMLIB_ADD_IMAGE_FLAG_ROOT;
-               ret = (*capture_tree)(&branch, sources[i].fs_source_path,
-                                     &params);
-               if (ret) {
-                       ERROR("Failed to build dentry tree for `%"TS"'",
-                             sources[i].fs_source_path);
-                       goto out_free_dentry_tree;
-               }
-               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,
-                                             path_basename(sources[i].wim_target_path));
-                       if (ret)
-                               goto out_free_branch;
-
-                       ret = attach_branch(&root_dentry, branch,
-                                           sources[i].wim_target_path);
-                       if (ret)
-                               goto out_free_branch;
-               }
-               if (progress_func)
-                       progress_func(WIMLIB_PROGRESS_MSG_SCAN_END, &progress);
-       }
-
-       if (root_dentry == NULL) {
-               ret = new_filler_directory(T(""), &root_dentry);
-               if (ret)
-                       goto out_free_dentry_tree;
+               goto out_delete_image;
        }
-
-       ret = add_new_dentry_tree(w, root_dentry, sd);
-
-       if (ret) {
-#ifdef WITH_NTFS_3G
-               if (ntfs_vol)
-                       do_ntfs_umount(ntfs_vol);
-#endif
-               goto out_free_dentry_tree;
-       }
-
-       imd = w->image_metadata[w->hdr.image_count - 1];
-       list_transfer(&unhashed_streams, &imd->unhashed_streams);
-
-#ifdef WITH_NTFS_3G
-       imd->ntfs_vol = ntfs_vol;
-#endif
-
-       DEBUG("Assigning hard link group IDs");
-       inode_table_prepare_inode_list(&inode_table, &imd->inode_list);
-
-       ret = xml_add_image(w, name);
+       ret = wimlib_update_image(wim, wim->hdr.image_count, add_cmds, 
+                                 num_sources, 0, progress_func);
+       FREE(add_cmds);
        if (ret)
-               goto out_put_imd;
-
+               goto out_delete_image;
        if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_BOOT)
-               wimlib_set_boot_idx(w, w->hdr.image_count);
-
-       if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_RPFIX)
-               w->hdr.flags |= WIM_HDR_FLAG_RP_FIX;
-
+               wim->hdr.boot_idx = wim->hdr.image_count;
        ret = 0;
-       goto out_destroy_inode_table;
-out_put_imd:
-       put_image_metadata(w->image_metadata[--w->hdr.image_count],
-                          w->lookup_table);
-       goto out_destroy_inode_table;
-out_free_branch:
-       free_dentry_tree(branch, w->lookup_table);
-out_free_dentry_tree:
-       free_dentry_tree(root_dentry, w->lookup_table);
-out_free_security_data:
-       free_security_data(sd);
-out_destroy_inode_table:
-       destroy_inode_table(&inode_table);
-       destroy_sd_set(&sd_set);
+       goto out;
+out_delete_image:
+       put_image_metadata(wim->image_metadata[wim->hdr.image_count - 1],
+                          wim->lookup_table);
+       xml_delete_image(&wim->wim_info, wim->hdr.image_count);
+       wim->hdr.image_count--;
 out:
        return ret;
 }
 
 WIMLIBAPI int
-wimlib_add_image(WIMStruct *w,
+wimlib_add_image(WIMStruct *wim,
                 const tchar *source,
                 const tchar *name,
-                struct wimlib_capture_config *config,
+                const struct wimlib_capture_config *config,
                 int add_image_flags,
                 wimlib_progress_func_t progress_func)
 {
-       if (!source || !*source)
-               return WIMLIB_ERR_INVALID_PARAM;
-
-       tchar *fs_source_path = TSTRDUP(source);
-       int ret;
-       struct wimlib_capture_source capture_src = {
-               .fs_source_path = fs_source_path,
+       const struct wimlib_capture_source capture_src = {
+               .fs_source_path = (tchar*)source,
                .wim_target_path = NULL,
                .reserved = 0,
        };
-       ret = wimlib_add_image_multisource(w, &capture_src, 1, name,
-                                          config, add_image_flags,
-                                          progress_func);
-       FREE(fs_source_path);
-       return ret;
+       return wimlib_add_image_multisource(wim, &capture_src, 1, name,
+                                           config, add_image_flags,
+                                           progress_func);
 }
diff --git a/src/capture_common.c b/src/capture_common.c
new file mode 100644 (file)
index 0000000..ef4fa5d
--- /dev/null
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2013 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 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 General Public License for more
+ * details.
+ *
+ * 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 <string.h>
+
+#ifdef __WIN32__
+#  include "win32.h"
+#else
+#  include <fnmatch.h>
+#endif
+
+static int
+canonicalize_pat(tchar **pat_p)
+{
+       tchar *pat = *pat_p;
+
+       /* Turn all backslashes in the pattern into forward slashes. */
+       zap_backslashes(pat);
+
+       if (*pat != T('/') && *pat != T('\0') && *(pat + 1) == T(':')) {
+               /* Pattern begins with drive letter */
+               if (*(pat + 2) != T('/')) {
+                       /* Something like c:file, which is actually a path
+                        * relative to the current working directory on the c:
+                        * drive.  We require paths with drive letters to be
+                        * absolute. */
+                       ERROR("Invalid path \"%"TS"\"; paths including drive letters "
+                             "must be absolute!", pat);
+                       ERROR("Maybe try \"%"TC":/%"TS"\"?",
+                             *pat, pat + 2);
+                       return WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
+               }
+
+               WARNING("Pattern \"%"TS"\" starts with a drive letter, which is "
+                       "being removed.", pat);
+               /* Strip the drive letter */
+               pat += 2;
+               *pat_p = pat;
+       }
+       return 0;
+}
+
+static int
+canonicalize_pat_list(struct wimlib_pattern_list *pat_list)
+{
+       int ret = 0;
+       for (size_t i = 0; i < pat_list->num_pats; i++) {
+               ret = canonicalize_pat(&pat_list->pats[i]);
+               if (ret)
+                       break;
+       }
+       return ret;
+}
+
+int
+canonicalize_capture_config(struct wimlib_capture_config *config)
+{
+       int ret = canonicalize_pat_list(&config->exclusion_pats);
+       if (ret)
+               return ret;
+       return canonicalize_pat_list(&config->exclusion_exception_pats);
+}
+
+static bool
+copy_pattern_list(struct wimlib_pattern_list *copy,
+                 const struct wimlib_pattern_list *list)
+{
+       copy->pats = CALLOC(list->num_pats, sizeof(list->pats[0]));
+       if (!copy->pats)
+               return false;
+       copy->num_pats = list->num_pats;
+       for (size_t i = 0; i < list->num_pats; i++) {
+               copy->pats[i] = TSTRDUP(list->pats[i]);
+               if (!copy->pats[i])
+                       return false;
+       }
+       return true;
+}
+
+struct wimlib_capture_config *
+copy_capture_config(const struct wimlib_capture_config *config)
+{
+       struct wimlib_capture_config *copy;
+
+       copy = CALLOC(1, sizeof(struct wimlib_capture_config));
+       if (!copy)
+               goto oom;
+       if (!copy_pattern_list(&copy->exclusion_pats, &config->exclusion_pats))
+               goto oom;
+       if (!copy_pattern_list(&copy->exclusion_exception_pats,
+                              &config->exclusion_exception_pats))
+               goto oom;
+       goto out;
+oom:
+       free_capture_config(copy);
+       copy = NULL;
+out:
+       return copy;
+}
+
+static void
+destroy_pattern_list(struct wimlib_pattern_list *list)
+{
+       for (size_t i = 0; i < list->num_pats; i++)
+               FREE(list->pats[i]);
+       FREE(list->pats);
+}
+
+void
+free_capture_config(struct wimlib_capture_config *config)
+{
+       if (config) {
+               destroy_pattern_list(&config->exclusion_pats);
+               destroy_pattern_list(&config->exclusion_exception_pats);
+               FREE(config);
+       }
+}
+
+static bool
+match_pattern(const tchar *path,
+             const tchar *path_basename,
+             const struct wimlib_pattern_list *list)
+{
+       for (size_t i = 0; i < list->num_pats; i++) {
+
+               const tchar *pat = list->pats[i];
+               const tchar *string;
+
+               if (*pat == T('/')) {
+                       /* Absolute path from root of capture */
+                       string = path;
+               } else {
+                       if (tstrchr(pat, T('/')))
+                               /* Relative path from root of capture */
+                               string = path + 1;
+                       else
+                               /* A file name pattern */
+                               string = path_basename;
+               }
+
+               /* Warning: on Windows native builds, fnmatch() calls the
+                * replacement function in win32.c. */
+               if (fnmatch(pat, string, FNM_PATHNAME | FNM_NOESCAPE
+                               #ifdef FNM_CASEFOLD
+                                       | FNM_CASEFOLD
+                               #endif
+                           ) == 0)
+               {
+                       DEBUG("\"%"TS"\" matches the pattern \"%"TS"\"",
+                             string, pat);
+                       return true;
+               } else {
+                       DEBUG2("\"%"TS"\" does not match the pattern \"%"TS"\"",
+                              string, pat);
+               }
+       }
+       return false;
+}
+
+/* Return true if the image capture configuration file indicates we should
+ * exclude the filename @path from capture.
+ *
+ * If @exclude_prefix is %true, the part of the path up and including the name
+ * of the directory being captured is not included in the path for matching
+ * purposes.  This allows, for example, a pattern like /hiberfil.sys to match a
+ * file /mnt/windows7/hiberfil.sys if we are capturing the /mnt/windows7
+ * directory.
+ */
+bool
+exclude_path(const tchar *path, size_t path_len,
+            const struct wimlib_capture_config *config, bool exclude_prefix)
+{
+       const tchar *basename = path_basename_with_len(path, path_len);
+       if (exclude_prefix) {
+               wimlib_assert(path_len >= config->_prefix_num_tchars);
+               if (!tmemcmp(config->_prefix, path, config->_prefix_num_tchars) &&
+                   path[config->_prefix_num_tchars] == T('/'))
+               {
+                       path += config->_prefix_num_tchars;
+               }
+       }
+       return match_pattern(path, basename, &config->exclusion_pats) &&
+               !match_pattern(path, basename, &config->exclusion_exception_pats);
+
+}
index 2e5090f..48b3104 100644 (file)
@@ -230,13 +230,13 @@ for_dentry_tree_in_rbtree(struct rb_node *node,
        int ret;
        if (node) {
                ret = for_dentry_tree_in_rbtree(node->rb_left, visitor, arg);
-               if (ret != 0)
+               if (ret)
                        return ret;
                ret = for_dentry_in_tree(rbnode_dentry(node), visitor, arg);
-               if (ret != 0)
+               if (ret)
                        return ret;
                ret = for_dentry_tree_in_rbtree(node->rb_right, visitor, arg);
-               if (ret != 0)
+               if (ret)
                        return ret;
        }
        return 0;
@@ -250,11 +250,15 @@ int
 for_dentry_in_tree(struct wim_dentry *root,
                   int (*visitor)(struct wim_dentry*, void*), void *arg)
 {
-       int ret = visitor(root, arg);
-       if (ret == 0) {
-               ret = for_dentry_tree_in_rbtree(root->d_inode->i_children.rb_node,
-                                               visitor,
-                                               arg);
+       int ret = 0;
+
+       if (root) {
+               int ret = visitor(root, arg);
+               if (ret == 0) {
+                       ret = for_dentry_tree_in_rbtree(root->d_inode->i_children.rb_node,
+                                                       visitor,
+                                                       arg);
+               }
        }
        return ret;
 }
@@ -265,11 +269,13 @@ int
 for_dentry_in_tree_depth(struct wim_dentry *root,
                         int (*visitor)(struct wim_dentry*, void*), void *arg)
 {
-       int ret;
-       ret = for_dentry_tree_in_rbtree_depth(root->d_inode->i_children.rb_node,
-                                             visitor, arg);
-       if (ret == 0)
-               ret = visitor(root, arg);
+       int ret = 0;
+       if (root) {
+               ret = for_dentry_tree_in_rbtree_depth(root->d_inode->i_children.rb_node,
+                                                     visitor, arg);
+               if (ret == 0)
+                       ret = visitor(root, arg);
+       }
        return ret;
 }
 
@@ -919,8 +925,7 @@ do_free_dentry(struct wim_dentry *dentry, void *__lookup_table)
 void
 free_dentry_tree(struct wim_dentry *root, struct wim_lookup_table *lookup_table)
 {
-       if (root)
-               for_dentry_in_tree_depth(root, do_free_dentry, lookup_table);
+       for_dentry_in_tree_depth(root, do_free_dentry, lookup_table);
 }
 
 /*
index f6bca15..dfb8e4c 100644 (file)
@@ -1250,6 +1250,9 @@ wimlib_extract_files(WIMStruct *wim,
        if (ret)
                goto out;
 
+       if (num_cmds == 0)
+               goto out;
+
        if (num_additional_swms) {
                ret = new_joined_lookup_table(wim, additional_swms,
                                              num_additional_swms,
index 388d125..53d03ec 100644 (file)
@@ -545,7 +545,14 @@ inode_table_prepare_inode_list(struct wim_inode_table *table,
        struct hlist_node *cur, *tmp;
        u64 cur_ino = 1;
 
-       INIT_LIST_HEAD(head);
+       list_for_each_entry(inode, head, i_list) {
+               if (inode->i_nlink > 1)
+                       inode->i_ino = cur_ino++;
+               else
+                       inode->i_ino = 0;
+               list_add_tail(&inode->i_list, head);
+       }
+
        for (size_t i = 0; i < table->capacity; i++) {
                hlist_for_each_entry_safe(inode, cur, tmp, &table->array[i], i_hlist)
                {
index b658eff..0538fbc 100644 (file)
@@ -2047,58 +2047,7 @@ wimfs_removexattr(const char *path, const char *name)
 static int
 wimfs_rename(const char *from, const char *to)
 {
-       struct wim_dentry *src;
-       struct wim_dentry *dst;
-       struct wim_dentry *parent_of_dst;
-       WIMStruct *w = wimfs_get_WIMStruct();
-       int ret;
-
-       /* This rename() implementation currently only supports actual files
-        * (not alternate data streams) */
-
-       src = get_dentry(w, from);
-       if (!src)
-               return -errno;
-
-       dst = get_dentry(w, 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(w, 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 != 0)
-               return -ENOMEM;
-       if (dst)
-               remove_dentry(dst, w->lookup_table);
-       unlink_dentry(src);
-       dentry_add_child(parent_of_dst, src);
-       return 0;
+       return rename_wim_path(wimfs_get_WIMStruct(), from, to);
 }
 
 /* Remove a directory */
index f4dfb8e..871c243 100644 (file)
@@ -149,6 +149,12 @@ empty_sacl_fixup(u8 *descr, u64 *size_p)
 #endif
 }
 
+struct wim_security_data *
+new_wim_security_data()
+{
+       return CALLOC(1, sizeof(struct wim_security_data));
+}
+
 /*
  * Reads the security data from the metadata resource.
  *
@@ -465,13 +471,20 @@ free_sd_tree(struct rb_node *node)
 
 /* Frees a security descriptor index set. */
 void
-destroy_sd_set(struct sd_set *sd_set)
+destroy_sd_set(struct sd_set *sd_set, bool rollback)
 {
+       if (rollback) {
+               struct wim_security_data *sd = sd_set->sd;
+               int32_t i;
+               for (i = sd_set->orig_num_entries; i < sd->num_entries; i++)
+                       FREE(sd->descriptors[i]);
+               sd->num_entries = sd_set->orig_num_entries;
+       }
        free_sd_tree(sd_set->rb_root.rb_node);
 }
 
 /* Inserts a a new node into the security descriptor index tree. */
-static void
+static bool
 insert_sd_node(struct sd_set *set, struct sd_node *new)
 {
        struct rb_root *root = &set->rb_root;
@@ -488,10 +501,11 @@ insert_sd_node(struct sd_set *set, struct sd_node *new)
                else if (cmp > 0)
                        p = &((*p)->rb_right);
                else
-                       wimlib_assert(0); /* Duplicate SHA1 message digest */
+                       return false; /* Duplicate SHA1 message digest */
        }
        rb_link_node(&new->rb_node, rb_parent, p);
        rb_insert_color(&new->rb_node, root);
+       return true;
 }
 
 /* Returns the index of the security descriptor having a SHA1 message digest of
@@ -531,6 +545,7 @@ sd_set_add_sd(struct sd_set *sd_set, const char descriptor[], size_t size)
        u64 *sizes;
        u8 *descr_copy;
        struct wim_security_data *sd;
+       bool bret;
 
        sha1_buffer((const u8*)descriptor, size, hash);
 
@@ -570,7 +585,8 @@ sd_set_add_sd(struct sd_set *sd_set, const char descriptor[], size_t size)
        sd->num_entries++;
        DEBUG("There are now %d security descriptors", sd->num_entries);
        sd->total_length += size + sizeof(sd->sizes[0]);
-       insert_sd_node(sd_set, new);
+       bret = insert_sd_node(sd_set, new);
+       wimlib_assert(bret);
        return new->security_id;
 out_free_descr:
        FREE(descr_copy);
@@ -579,3 +595,32 @@ out_free_node:
 out:
        return -1;
 }
+
+int
+init_sd_set(struct sd_set *sd_set, struct wim_security_data *sd)
+{
+       int ret;
+
+       sd_set->sd = sd;
+       sd_set->rb_root.rb_node = NULL;
+       sd_set->orig_num_entries = sd->num_entries;
+       for (int32_t i = 0; i < sd->num_entries; i++) {
+               struct sd_node *new;
+
+               new = MALLOC(sizeof(struct sd_node));
+               if (!new) {
+                       ret = WIMLIB_ERR_NOMEM;
+                       goto out_destroy_sd_set;
+               }
+               sha1_buffer(sd->descriptors[i], sd->sizes[i], new->hash);
+               new->security_id = i;
+               if (!insert_sd_node(sd_set, new))
+                       FREE(new); /* Ignore duplicate security descriptor */
+       }
+       ret = 0;
+       goto out;
+out_destroy_sd_set:
+       destroy_sd_set(sd_set, false);
+out:
+       return ret;
+}
index e0b83ac..e20ad16 100644 (file)
@@ -1,10 +1,3 @@
-/*
- *
- * Macros and structures for security descriptors
- *
- * From Microsoft's public documentation and the WINE project
- */
-
 #include "util.h"
 #include "rbtree.h"
 #include "sha1.h"
 struct sd_set {
        struct wim_security_data *sd;
        struct rb_root rb_root;
+       int32_t orig_num_entries;
 };
-void destroy_sd_set(struct sd_set *sd_set);
-int lookup_sd(struct sd_set *set, const u8 hash[SHA1_HASH_SIZE]);
-int sd_set_add_sd(struct sd_set *sd_set, const char descriptor[],
-                 size_t size);
+extern void
+destroy_sd_set(struct sd_set *sd_set, bool rollback);
+
+extern int
+lookup_sd(struct sd_set *set, const u8 hash[SHA1_HASH_SIZE]);
+
+extern int
+sd_set_add_sd(struct sd_set *sd_set, const char descriptor[],
+             size_t size);
+
+extern int
+init_sd_set(struct sd_set *sd_set, struct wim_security_data *sd);
 
 #endif /* _WIMLIB_SECURITY_H */
diff --git a/src/unix_capture.c b/src/unix_capture.c
new file mode 100644 (file)
index 0000000..f3e9f0e
--- /dev/null
@@ -0,0 +1,351 @@
+/*
+ * Copyright (C) 2013 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 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 General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wimlib; if not, see http://www.gnu.org/licenses/.
+ */
+
+#ifndef __WIN32__
+
+#include "wimlib_internal.h"
+#include "dentry.h"
+#include "lookup_table.h"
+#include "timestamp.h"
+
+#include <dirent.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+static int
+unix_capture_regular_file(const char *path,
+                         u64 size,
+                         struct wim_inode *inode,
+                         struct wim_lookup_table *lookup_table)
+{
+       inode->i_attributes = FILE_ATTRIBUTE_NORMAL;
+
+       /* Empty files do not have to have a lookup table entry. */
+       if (size != 0) {
+               struct wim_lookup_table_entry *lte;
+               char *file_on_disk;
+
+               file_on_disk = STRDUP(path);
+               if (!file_on_disk)
+                       return WIMLIB_ERR_NOMEM;
+               lte = new_lookup_table_entry();
+               if (!lte) {
+                       FREE(file_on_disk);
+                       return WIMLIB_ERR_NOMEM;
+               }
+               lte->file_on_disk = file_on_disk;
+               lte->resource_location = RESOURCE_IN_FILE_ON_DISK;
+               lte->resource_entry.original_size = size;
+               lookup_table_insert_unhashed(lookup_table, lte, inode, 0);
+               inode->i_lte = lte;
+       }
+       return 0;
+}
+
+static int
+unix_build_dentry_tree_recursive(struct wim_dentry **root_ret,
+                                char *path,
+                                size_t path_len,
+                                struct add_image_params *params);
+
+static int
+unix_capture_directory(struct wim_dentry *dir_dentry,
+                      char *path,
+                      size_t path_len,
+                      struct add_image_params *params)
+{
+
+       DIR *dir;
+       struct dirent *entry;
+       struct wim_dentry *child;
+       int ret;
+
+       dir_dentry->d_inode->i_attributes = FILE_ATTRIBUTE_DIRECTORY;
+       dir = opendir(path);
+       if (!dir) {
+               ERROR_WITH_ERRNO("Failed to open the directory `%s'",
+                                path);
+               return WIMLIB_ERR_OPEN;
+       }
+
+       /* Recurse on directory contents */
+       ret = 0;
+       for (;;) {
+               errno = 0;
+               entry = readdir(dir);
+               if (!entry) {
+                       if (errno) {
+                               ret = WIMLIB_ERR_READ;
+                               ERROR_WITH_ERRNO("Error reading the "
+                                                "directory `%s'", path);
+                       }
+                       break;
+               }
+
+               if (entry->d_name[0] == '.' && (entry->d_name[1] == '\0'
+                     || (entry->d_name[1] == '.' && entry->d_name[2] == '\0')))
+                               continue;
+
+               size_t name_len = strlen(entry->d_name);
+
+               path[path_len] = '/';
+               memcpy(&path[path_len + 1], entry->d_name, name_len + 1);
+               ret = unix_build_dentry_tree_recursive(&child,
+                                                      path,
+                                                      path_len + 1 + name_len,
+                                                      params);
+               if (ret)
+                       break;
+               if (child)
+                       dentry_add_child(dir_dentry, child);
+       }
+       closedir(dir);
+       return ret;
+}
+
+static int
+unix_capture_symlink(struct wim_dentry **root_p,
+                    const char *path,
+                    struct wim_inode *inode,
+                    struct add_image_params *params)
+{
+       char deref_name_buf[4096];
+       ssize_t deref_name_len;
+       int ret;
+
+       inode->i_attributes = FILE_ATTRIBUTE_REPARSE_POINT;
+       inode->i_reparse_tag = WIM_IO_REPARSE_TAG_SYMLINK;
+
+       /* The idea here is to call readlink() to get the UNIX target of
+        * the symbolic link, then turn the target into a reparse point
+        * data buffer that contains a relative or absolute symbolic
+        * link (NOT a junction point or *full* path symbolic link with
+        * drive letter).
+        */
+       deref_name_len = readlink(path, deref_name_buf,
+                                 sizeof(deref_name_buf) - 1);
+       if (deref_name_len >= 0) {
+               char *dest = deref_name_buf;
+
+               dest[deref_name_len] = '\0';
+               DEBUG("Read symlink `%s'", dest);
+
+               if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_RPFIX) &&
+                    dest[0] == '/')
+               {
+                       dest = capture_fixup_absolute_symlink(dest,
+                                                             params->capture_root_ino,
+                                                             params->capture_root_dev);
+                       if (!dest) {
+                               WARNING("Ignoring out of tree absolute symlink "
+                                       "\"%s\" -> \"%s\"\n"
+                                       "          (Use --norpfix to capture "
+                                       "absolute symlinks as-is)",
+                                       path, deref_name_buf);
+                               free_dentry(*root_p);
+                               *root_p = NULL;
+                               return 0;
+                       }
+                       inode->i_not_rpfixed = 0;
+               }
+               ret = wim_inode_set_symlink(inode, dest, params->lookup_table);
+               if (ret == 0) {
+                       /* Unfortunately, Windows seems to have the concept of
+                        * "file" symbolic links as being different from
+                        * "directory" symbolic links...  so
+                        * FILE_ATTRIBUTE_DIRECTORY needs to be set on the
+                        * symbolic link if the *target* of the symbolic link is
+                        * a directory.  */
+                       struct stat stbuf;
+                       if (stat(path, &stbuf) == 0 && S_ISDIR(stbuf.st_mode))
+                               inode->i_attributes |= FILE_ATTRIBUTE_DIRECTORY;
+               }
+       } else {
+               ERROR_WITH_ERRNO("Failed to read target of "
+                                "symbolic link `%s'", path);
+               ret = WIMLIB_ERR_READLINK;
+       }
+       return ret;
+}
+
+static int
+unix_build_dentry_tree_recursive(struct wim_dentry **root_ret,
+                                char *path,
+                                size_t path_len,
+                                struct add_image_params *params)
+{
+       struct wim_dentry *root = NULL;
+       int ret = 0;
+       struct wim_inode *inode;
+
+       if (exclude_path(path, path_len, params->config, true)) {
+               if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE)
+                   && params->progress_func)
+               {
+                       union wimlib_progress_info info;
+                       info.scan.cur_path = path;
+                       info.scan.excluded = true;
+                       params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
+               }
+               goto out;
+       }
+
+       if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE)
+           && params->progress_func)
+       {
+               union wimlib_progress_info info;
+               info.scan.cur_path = path;
+               info.scan.excluded = false;
+               params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
+       }
+
+       struct stat stbuf;
+       int (*stat_fn)(const char *restrict, struct stat *restrict);
+       if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE) ||
+           (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT))
+               stat_fn = stat;
+       else
+               stat_fn = lstat;
+
+       ret = (*stat_fn)(path, &stbuf);
+       if (ret != 0) {
+               ERROR_WITH_ERRNO("Failed to stat `%s'", path);
+               goto out;
+       }
+       if (!S_ISREG(stbuf.st_mode) && !S_ISDIR(stbuf.st_mode)
+           && !S_ISLNK(stbuf.st_mode)) {
+               ERROR("`%s' is not a regular file, directory, or symbolic link.",
+                     path);
+               ret = WIMLIB_ERR_SPECIAL_FILE;
+               goto out;
+       }
+
+       ret = inode_table_new_dentry(params->inode_table,
+                                    path_basename_with_len(path, path_len),
+                                    stbuf.st_ino, stbuf.st_dev, false, &root);
+       if (ret)
+               goto out;
+
+       inode = root->d_inode;
+
+       if (inode->i_nlink > 1) /* Already captured this inode? */
+               goto out;
+
+#ifdef HAVE_STAT_NANOSECOND_PRECISION
+       inode->i_creation_time = timespec_to_wim_timestamp(stbuf.st_mtim);
+       inode->i_last_write_time = timespec_to_wim_timestamp(stbuf.st_mtim);
+       inode->i_last_access_time = timespec_to_wim_timestamp(stbuf.st_atim);
+#else
+       inode->i_creation_time = unix_timestamp_to_wim(stbuf.st_mtime);
+       inode->i_last_write_time = unix_timestamp_to_wim(stbuf.st_mtime);
+       inode->i_last_access_time = unix_timestamp_to_wim(stbuf.st_atime);
+#endif
+       inode->i_resolved = 1;
+       if (params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) {
+               ret = inode_set_unix_data(inode, stbuf.st_uid,
+                                         stbuf.st_gid,
+                                         stbuf.st_mode,
+                                         params->lookup_table,
+                                         UNIX_DATA_ALL | UNIX_DATA_CREATE);
+               if (ret)
+                       goto out;
+       }
+       params->add_image_flags &= ~WIMLIB_ADD_IMAGE_FLAG_ROOT;
+       if (S_ISREG(stbuf.st_mode))
+               ret = unix_capture_regular_file(path, stbuf.st_size,
+                                               inode, params->lookup_table);
+       else if (S_ISDIR(stbuf.st_mode))
+               ret = unix_capture_directory(root, path, path_len, params);
+       else
+               ret = unix_capture_symlink(&root, path, inode, params);
+out:
+       if (ret == 0)
+               *root_ret = root;
+       else
+               free_dentry_tree(root, params->lookup_table);
+       return ret;
+}
+
+/*
+ * unix_build_dentry_tree():
+ *     Builds a tree of WIM dentries from an on-disk directory tree (UNIX
+ *     version; no NTFS-specific data is captured).
+ *
+ * @root_ret:   Place to return a pointer to the root of the dentry tree.  Only
+ *             modified if successful.  Set to NULL if the file or directory was
+ *             excluded from capture.
+ *
+ * @root_disk_path:  The path to the root of the directory tree on disk.
+ *
+ * @params:     See doc for `struct add_image_params'.
+ *
+ * @return:    0 on success, nonzero on failure.  It is a failure if any of
+ *             the files cannot be `stat'ed, or if any of the needed
+ *             directories cannot be opened or read.  Failure to add the files
+ *             to the WIM may still occur later when trying to actually read
+ *             the on-disk files during a call to wimlib_write() or
+ *             wimlib_overwrite().
+ */
+int
+unix_build_dentry_tree(struct wim_dentry **root_ret,
+                      const char *root_disk_path,
+                      struct add_image_params *params)
+{
+       char *path_buf;
+       int ret;
+       size_t path_len;
+       size_t path_bufsz;
+
+       {
+               struct stat root_stbuf;
+               if (stat(root_disk_path, &root_stbuf)) {
+                       ERROR_WITH_ERRNO("Failed to stat \"%s\"", root_disk_path);
+                       return WIMLIB_ERR_STAT;
+               }
+
+               if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT) &&
+                   !S_ISDIR(root_stbuf.st_mode))
+               {
+                       ERROR("Root of capture \"%s\" is not a directory",
+                             root_disk_path);
+                       return WIMLIB_ERR_NOTDIR;
+               }
+               params->capture_root_ino = root_stbuf.st_ino;
+               params->capture_root_dev = root_stbuf.st_dev;
+       }
+
+       path_bufsz = min(32790, PATH_MAX + 1);
+       path_len = strlen(root_disk_path);
+
+       if (path_len >= path_bufsz)
+               return WIMLIB_ERR_INVALID_PARAM;
+
+       path_buf = MALLOC(path_bufsz);
+       if (!path_buf)
+               return WIMLIB_ERR_NOMEM;
+       memcpy(path_buf, root_disk_path, path_len + 1);
+
+       ret = unix_build_dentry_tree_recursive(root_ret, path_buf,
+                                              path_len, params);
+       FREE(path_buf);
+       return ret;
+}
+
+#endif /* !__WIN32__ */
diff --git a/src/update_image.c b/src/update_image.c
new file mode 100644 (file)
index 0000000..ce77c68
--- /dev/null
@@ -0,0 +1,714 @@
+/*
+ * update_image.c - Update a WIM image.
+ */
+
+/*
+ * Copyright (C) 2013 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 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 General Public License for more
+ * details.
+ *
+ * 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 "dentry.h"
+#include "lookup_table.h"
+#include "security.h"
+#include <errno.h>
+
+/* 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;
+
+       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;
+}
+
+/* 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);
+
+       if (!dentry_is_directory(branch) || !dentry_is_directory(target)) {
+               ERROR("Cannot overlay \"%"WS"\" onto existing dentry: "
+                     "is not directory-on-directory!", branch->file_name);
+               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);
+               struct wim_dentry *existing;
+
+               /* Move @child to the directory @target */
+               unlink_dentry(child);
+               existing = dentry_add_child(target, child);
+
+               /* File or directory with same name already exists */
+               if (existing) {
+                       int ret;
+                       ret = do_overlay(existing, child);
+                       if (ret) {
+                               /* Overlay failed.  Revert the change to avoid
+                                * leaking the directory tree rooted at @child.
+                                * */
+                               dentry_add_child(branch, child);
+                               return ret;
+                       }
+               }
+       }
+       free_dentry(branch);
+       return 0;
+}
+
+/* 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.
+ * @branch
+ *     Branch to add.
+ * @target_path:
+ *     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 *slash;
+       struct wim_dentry *dentry, *parent, *target;
+       int ret;
+
+       DEBUG("Attaching branch \"%"WS"\" => \"%"TS"\"",
+             branch->file_name, target_path);
+
+       if (*target_path == T('\0')) {
+               /* Target: root directory */
+               if (*root_p) {
+                       /* Overlay on existing root */
+                       return do_overlay(*root_p, branch);
+               } else {
+                       if (!dentry_is_directory(branch)) {
+                               ERROR("Cannot set non-directory as root of WIM image");
+                               return WIMLIB_ERR_NOTDIR;
+                       }
+                       /* Set as root */
+                       *root_p = branch;
+                       return 0;
+               }
+       }
+
+       /* Adding a non-root branch.  Create root if it hasn't been created
+        * already. */
+       if (!*root_p) {
+               ret  = new_filler_directory(T(""), root_p);
+               if (ret)
+                       return ret;
+       }
+
+       /* Walk the path to the branch, creating filler directories as needed.
+        * */
+       parent = *root_p;
+       while ((slash = tstrchr(target_path, T('/')))) {
+               *slash = T('\0');
+               dentry = get_dentry_child_with_name(parent, target_path);
+               if (!dentry) {
+                       ret = new_filler_directory(target_path, &dentry);
+                       if (ret)
+                               return ret;
+                       dentry_add_child(parent, dentry);
+               }
+               parent = dentry;
+               target_path = slash;
+               /* Skip over slashes.  Note: this cannot overrun the length of
+                * the string because the last character cannot be a slash, as
+                * trailing slashes were tripped.  */
+               do {
+                       ++target_path;
+               } while (*target_path == T('/'));
+       }
+
+       /* 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);
+       if (target) {
+               return do_overlay(target, branch);
+       } else {
+               dentry_add_child(parent, branch);
+               return 0;
+       }
+}
+
+static int
+execute_add_command(WIMStruct *wim,
+                   const struct wimlib_update_command *add_cmd,
+                   wimlib_progress_func_t progress_func)
+{
+       int ret;
+       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;
+#endif
+       void *extra_arg;
+       struct wim_dentry *branch;
+       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;
+       DEBUG("fs_source_path=\"%"TS"\", wim_target_path=\"%"TS"\", add_flags=%#x",
+             fs_source_path, wim_target_path, add_flags);
+
+       imd = wim->image_metadata[wim->current_image - 1];
+
+       if (add_flags & WIMLIB_ADD_IMAGE_FLAG_NTFS) {
+       #ifdef WITH_NTFS_3G
+               capture_tree = build_dentry_tree_ntfs;
+               extra_arg = &ntfs_vol;
+               if (imd->ntfs_vol != NULL) {
+                       ERROR("NTFS volume already set");
+                       ret = WIMLIB_ERR_INVALID_PARAM;
+                       goto out;
+               }
+       #else
+               ret = WIMLIB_ERR_INVALID_PARAM;
+               goto out;
+       #endif
+       } else {
+       #ifdef __WIN32__
+               capture_tree = win32_build_dentry_tree;
+       #else
+               capture_tree = unix_build_dentry_tree;
+       #endif
+               extra_arg = NULL;
+       }
+
+       ret = init_inode_table(&inode_table, 9001);
+       if (ret)
+               goto out;
+
+       ret = init_sd_set(&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.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);
+
+       if (wim_target_path[0] == T('\0'))
+               add_flags |= WIMLIB_ADD_IMAGE_FLAG_ROOT;
+       ret = (*capture_tree)(&branch, fs_source_path, &params);
+       if (ret) {
+               ERROR("Failed to build dentry tree for \"%"TS"\"",
+                     fs_source_path);
+               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,
+                                     path_basename(wim_target_path));
+               if (ret)
+                       goto out_ntfs_umount;
+
+               ret = attach_branch(&imd->root_dentry, branch, wim_target_path);
+               if (ret)
+                       goto out_ntfs_umount;
+       }
+       if (progress_func)
+               progress_func(WIMLIB_PROGRESS_MSG_SCAN_END, &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);
+       ret = 0;
+       rollback_sd = false;
+       if (add_flags & WIMLIB_ADD_IMAGE_FLAG_RPFIX)
+               wim->hdr.flags |= WIM_HDR_FLAG_RP_FIX;
+       goto out_destroy_sd_set;
+out_ntfs_umount:
+#ifdef WITH_NTFS_3G
+       if (ntfs_vol)
+               do_ntfs_umount(ntfs_vol);
+#endif
+       free_dentry_tree(branch, wim->lookup_table);
+out_destroy_sd_set:
+       destroy_sd_set(&sd_set, rollback_sd);
+out_destroy_inode_table:
+       destroy_inode_table(&inode_table);
+out:
+       return ret;
+}
+
+static int
+execute_delete_command(WIMStruct *wim,
+                      const struct wimlib_update_command *delete_cmd)
+{
+       int flags;
+       const tchar *wim_path;
+       struct wim_dentry *tree;
+       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;
+
+       tree = get_dentry(wim, wim_path);
+       if (!tree) {
+               /* Path to delete does not exist in the WIM. */
+               if (flags & WIMLIB_DELETE_FLAG_FORCE) {
+                       return 0;
+               } else {
+                       ERROR("Path \"%"TS"\" does not exist in WIM image %d",
+                             wim_path, wim->current_image);
+                       return WIMLIB_ERR_PATH_DOES_NOT_EXIST;
+               }
+       }
+
+       if (dentry_is_directory(tree) && !(flags & WIMLIB_DELETE_FLAG_RECURSIVE)) {
+               ERROR("Path \"%"TS"\" in WIM image %d is a directory "
+                     "but a recursive delete was not requested",
+                     wim_path, wim->current_image);
+               return WIMLIB_ERR_IS_DIRECTORY;
+       }
+
+       is_root = dentry_is_root(tree);
+       unlink_dentry(tree);
+       free_dentry_tree(tree, wim->lookup_table);
+       if (is_root)
+               wim->image_metadata[wim->current_image - 1]->root_dentry = NULL;
+       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)
+{
+       int ret;
+
+       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);
+       if (ret) {
+               switch (ret) {
+               case -ENOMEM:
+                       ret = WIMLIB_ERR_NOMEM;
+                       break;
+               case -ENOTDIR:
+                       ret = WIMLIB_ERR_NOTDIR;
+                       break;
+               case -ENOTEMPTY:
+               case -EISDIR:
+                       ret = WIMLIB_ERR_IS_DIRECTORY;
+                       break;
+               case -ENOENT:
+               default:
+                       ret = WIMLIB_ERR_PATH_DOES_NOT_EXIST;
+                       break;
+               }
+       }
+       return ret;
+}
+
+static inline const tchar *
+update_op_to_str(int op)
+{
+       switch (op) {
+       case WIMLIB_UPDATE_OP_ADD:
+               return T("add");
+       case WIMLIB_UPDATE_OP_DELETE:
+               return T("delete");
+       case WIMLIB_UPDATE_OP_RENAME:
+               return T("rename");
+       default:
+               return T("???");
+       }
+}
+
+static int
+execute_update_commands(WIMStruct *wim,
+                       const struct wimlib_update_command *cmds,
+                       size_t num_cmds,
+                       wimlib_progress_func_t progress_func)
+{
+       int ret = 0;
+       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));
+               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]);
+                       break;
+               case WIMLIB_UPDATE_OP_RENAME:
+                       ret = execute_rename_command(wim, &cmds[i]);
+                       break;
+               default:
+                       ret = WIMLIB_ERR_INVALID_PARAM;
+                       break;
+               }
+               if (ret)
+                       break;
+       }
+       return ret;
+}
+
+static int
+check_add_command(struct wimlib_update_command *cmd,
+                 const struct wim_header *hdr)
+{
+       int add_flags = cmd->add.add_flags;
+       bool is_entire_image = cmd->add.wim_target_path[0] == T('\0');
+       int ret;
+#ifdef __WIN32__
+       if (add_flags & WIMLIB_ADD_IMAGE_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) {
+               ERROR("Capturing UNIX-specific data is not supported on Windows");
+               return WIMLIB_ERR_INVALID_PARAM;
+       }
+       if (add_flags & WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE) {
+               ERROR("Dereferencing symbolic links is not supported on Windows");
+               return WIMLIB_ERR_INVALID_PARAM;
+       }
+#endif
+
+       if (add_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE)
+               add_flags |= WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE;
+
+       if ((add_flags & (WIMLIB_ADD_IMAGE_FLAG_RPFIX |
+                         WIMLIB_ADD_IMAGE_FLAG_NORPFIX)) ==
+               (WIMLIB_ADD_IMAGE_FLAG_RPFIX |
+                WIMLIB_ADD_IMAGE_FLAG_NORPFIX))
+       {
+               ERROR("Cannot specify RPFIX and NORPFIX flags "
+                     "at the same time!");
+               return WIMLIB_ERR_INVALID_PARAM;
+       }
+
+       if ((add_flags & (WIMLIB_ADD_IMAGE_FLAG_RPFIX |
+                         WIMLIB_ADD_IMAGE_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;
+       }
+
+       if (!is_entire_image) {
+               if (add_flags & WIMLIB_ADD_IMAGE_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) {
+                       ERROR("Cannot do reparse point fixups when "
+                             "not capturing a full image!");
+                       return WIMLIB_ERR_INVALID_PARAM;
+               }
+       }
+       ret = canonicalize_capture_config(cmd->add.config);
+       if (ret)
+               return ret;
+       cmd->add.add_flags = add_flags;
+       return 0;
+}
+
+static int
+check_update_command(struct wimlib_update_command *cmd,
+                    const struct wim_header *hdr)
+{
+       switch (cmd->op) {
+       case WIMLIB_UPDATE_OP_ADD:
+               return check_add_command(cmd, hdr);
+       case WIMLIB_UPDATE_OP_DELETE:
+       case WIMLIB_UPDATE_OP_RENAME:
+               break;
+       }
+       return 0;
+}
+
+static int
+check_update_commands(struct wimlib_update_command *cmds, size_t num_cmds,
+                     const struct wim_header *hdr)
+{
+       int ret = 0;
+       for (size_t i = 0; i < num_cmds; i++) {
+               ret = check_update_command(&cmds[i], hdr);
+               if (ret)
+                       break;
+       }
+       return ret;
+}
+
+
+extern 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) {
+                       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);
+                               break;
+                       case WIMLIB_UPDATE_OP_RENAME:
+                               FREE(cmds[i].rename.wim_source_path);
+                               FREE(cmds[i].rename.wim_target_path);
+                               break;
+                       }
+               }
+               FREE(cmds);
+       }
+}
+
+static int
+copy_update_commands(const struct wimlib_update_command *cmds,
+                    size_t num_cmds,
+                    struct wimlib_update_command **cmds_copy_ret)
+{
+       int ret;
+       struct wimlib_update_command *cmds_copy;
+
+       cmds_copy = CALLOC(num_cmds, sizeof(cmds[0]));
+       if (!cmds_copy)
+               goto oom;
+
+       for (size_t i = 0; i < num_cmds; i++) {
+               switch (cmds[i].op) {
+               case WIMLIB_UPDATE_OP_ADD:
+                       cmds_copy[i].add.fs_source_path =
+                               canonicalize_fs_path(cmds[i].add.fs_source_path);
+                       cmds_copy[i].add.wim_target_path =
+                               canonicalize_wim_path(cmds[i].add.wim_target_path);
+                       if (!cmds_copy[i].add.fs_source_path ||
+                           !cmds_copy[i].add.wim_target_path)
+                               goto oom;
+                       if (cmds[i].add.config) {
+                               cmds_copy[i].add.config =
+                                       copy_capture_config(cmds[i].add.config);
+                               if (!cmds_copy[i].add.config)
+                                       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)
+                               goto oom;
+                       cmds_copy[i].delete.delete_flags = cmds[i].delete.delete_flags;
+                       break;
+               case WIMLIB_UPDATE_OP_RENAME:
+                       cmds_copy[i].rename.wim_source_path =
+                               canonicalize_wim_path(cmds[i].rename.wim_source_path);
+                       cmds_copy[i].rename.wim_target_path =
+                               canonicalize_wim_path(cmds[i].rename.wim_target_path);
+                       if (!cmds_copy[i].rename.wim_source_path ||
+                           !cmds_copy[i].rename.wim_target_path)
+                               goto oom;
+                       break;
+               default:
+                       ERROR("Unknown update operation %u", cmds[i].op);
+                       ret = WIMLIB_ERR_INVALID_PARAM;
+                       goto err;
+               }
+       }
+       *cmds_copy_ret = cmds_copy;
+       ret = 0;
+out:
+       return ret;
+oom:
+       ret = WIMLIB_ERR_NOMEM;
+err:
+       free_update_commands(cmds_copy, num_cmds);
+       goto out;
+}
+
+WIMLIBAPI int
+wimlib_update_image(WIMStruct *wim,
+                   int image,
+                   const struct wimlib_update_command *cmds,
+                   size_t num_cmds,
+                   int update_flags,
+                   wimlib_progress_func_t progress_func)
+{
+       int ret;
+       struct wimlib_update_command *cmds_copy;
+
+       DEBUG("Updating image %d with %zu commands", image, num_cmds);
+
+       if (wim->hdr.total_parts != 1) {
+               ERROR("Cannot update a split WIM!");
+               ret = WIMLIB_ERR_SPLIT_UNSUPPORTED;
+               goto out;
+       }
+
+       ret = select_wim_image(wim, image);
+       if (ret)
+               goto out;
+
+       DEBUG("Selected image %d for update", image);
+
+       if (num_cmds == 0)
+               goto out;
+
+       DEBUG("Preparing update commands");
+
+       ret = copy_update_commands(cmds, num_cmds, &cmds_copy);
+       if (ret)
+               goto out;
+
+       ret = check_update_commands(cmds_copy, num_cmds, &wim->hdr);
+       if (ret)
+               goto out_free_cmds_copy;
+
+       DEBUG("Executing update commands");
+
+       ret = execute_update_commands(wim, cmds_copy, num_cmds, progress_func);
+
+out_free_cmds_copy:
+       free_update_commands(cmds_copy, num_cmds);
+out:
+       return ret;
+}
index 901d89c..7350111 100644 (file)
@@ -322,6 +322,8 @@ static const tchar *error_strings[] = {
                = T("A string provided as input by the user was not a valid UTF-8 string"),
        [WIMLIB_ERR_INVALID_UTF16_STRING]
                = T("A string in a WIM dentry is not a valid UTF-16LE string"),
+       [WIMLIB_ERR_IS_DIRECTORY]
+               = T("One of the specified paths to delete was a directory"),
        [WIMLIB_ERR_LIBXML_UTF16_HANDLER_NOT_AVAILABLE]
                = T("libxml2 was unable to find a character encoding conversion handler "
                  "for UTF-16LE"),
index 9be0f95..8022423 100644 (file)
--- a/src/wim.c
+++ b/src/wim.c
@@ -197,7 +197,7 @@ select_wim_image(WIMStruct *w, int image)
        }
        w->current_image = image;
        imd = wim_get_current_image_metadata(w);
-       if (imd->root_dentry) {
+       if (imd->root_dentry || imd->modified) {
                ret = 0;
        } else {
                #ifdef ENABLE_DEBUG
index 3b3f7f2..72854e1 100644 (file)
@@ -657,7 +657,7 @@ struct wimlib_capture_config {
        struct wimlib_pattern_list reserved2;
 
        /** Library internal use only. */
-       wimlib_tchar *_prefix;
+       const wimlib_tchar *_prefix;
 
        /** Library internal use only. */
        size_t _prefix_num_tchars;
@@ -721,10 +721,17 @@ struct wimlib_capture_config {
  * reparse point fixups enabled and currently cannot be unset. */
 #define WIMLIB_ADD_IMAGE_FLAG_RPFIX                    0x00000100
 
-/* Don't do reparse point fixups.  The default behavior is described in the
+/** Don't do reparse point fixups.  The default behavior is described in the
  * documentation for ::WIMLIB_ADD_IMAGE_FLAG_RPFIX. */
 #define WIMLIB_ADD_IMAGE_FLAG_NORPFIX                  0x00000200
 
+/** Do not issue an error if the path to delete does not exist. */
+#define WIMLIB_DELETE_FLAG_FORCE                       0x00000001
+
+/** Delete a file or directory tree recursively; if not specified, an error is
+ * issued if the path to delete is a directory. */
+#define WIMLIB_DELETE_FLAG_RECURSIVE                   0x00000002
+
 /******************************
  * WIMLIB_EXPORT_FLAG_* *
  ******************************/
@@ -880,24 +887,24 @@ struct wimlib_capture_config {
 /** XXX */
 struct wimlib_update_command {
        enum {
-               WIMLIB_UPDATE_OP_ADD,
+               WIMLIB_UPDATE_OP_ADD = 0,
                WIMLIB_UPDATE_OP_DELETE,
-               WIMLIB_UPDATE_OP_MOVE,
+               WIMLIB_UPDATE_OP_RENAME,
        } op;
        union {
                struct {
-                       const wimlib_tchar *fs_source_path;
-                       const wimlib_tchar *wim_target_path;
-                       const struct wimlib_capture_config *config;
+                       wimlib_tchar *fs_source_path;
+                       wimlib_tchar *wim_target_path;
+                       struct wimlib_capture_config *config;
                        int add_flags;
                } add;
                struct {
-                       const wimlib_tchar *path_in_wim;
+                       wimlib_tchar *wim_path;
                        int delete_flags;
                } delete;
                struct {
-                       const wimlib_tchar *wim_source_path;
-                       const wimlib_tchar *wim_target_path;
+                       wimlib_tchar *wim_source_path;
+                       wimlib_tchar *wim_target_path;
                        int rename_flags;
                } rename;
        };
@@ -990,6 +997,7 @@ enum wimlib_error_code {
        WIMLIB_ERR_XML,
        WIMLIB_ERR_PATH_DOES_NOT_EXIST,
        WIMLIB_ERR_NOT_A_REGULAR_FILE,
+       WIMLIB_ERR_IS_DIRECTORY,
 };
 
 
@@ -999,6 +1007,12 @@ enum wimlib_error_code {
 /** Used to specify all images in the WIM. */
 #define WIMLIB_ALL_IMAGES      (-1)
 
+/** XXX */
+extern int
+wimlib_add_empty_image(WIMStruct *wim,
+                      const wimlib_tchar *name,
+                      int *new_idx_ret);
+
 /**
  * Adds an image to a WIM file from an on-disk directory tree or NTFS volume.
  *
@@ -1080,7 +1094,7 @@ extern int
 wimlib_add_image(WIMStruct *wim,
                 const wimlib_tchar *source,
                 const wimlib_tchar *name,
-                struct wimlib_capture_config *config,
+                const struct wimlib_capture_config *config,
                 int add_image_flags,
                 wimlib_progress_func_t progress_func);
 
@@ -1091,11 +1105,6 @@ wimlib_add_image(WIMStruct *wim,
  * same as wimlib_add_image().  See the documentation for <b>wimlib-imagex
  * capture</b> for full details on how this mode works.
  *
- * Additional note:  @a sources is not a @c const parameter and you cannot
- * assume that its contents are valid after this function returns.  You must
- * save pointers to the strings in these structures if you need to free them
- * later, and/or save copies if needed.
- *
  * In addition to the error codes that wimlib_add_image() can return,
  * wimlib_add_image_multisource() can return ::WIMLIB_ERR_INVALID_OVERLAY
  * when trying to overlay a non-directory on a directory or when otherwise
@@ -1108,10 +1117,10 @@ wimlib_add_image(WIMStruct *wim,
  * NTFS mode.) */
 extern int
 wimlib_add_image_multisource(WIMStruct *w,
-                            struct wimlib_capture_source *sources,
+                            const struct wimlib_capture_source *sources,
                             size_t num_sources,
                             const wimlib_tchar *name,
-                            struct wimlib_capture_config *config,
+                            const struct wimlib_capture_config *config,
                             int add_image_flags,
                             wimlib_progress_func_t progress_func);
 
@@ -2493,6 +2502,15 @@ wimlib_unmount_image(const wimlib_tchar *dir,
                     int unmount_flags,
                     wimlib_progress_func_t progress_func);
 
+/** XXX */
+extern int
+wimlib_update_image(WIMStruct *wim,
+                   int image,
+                   const struct wimlib_update_command *cmds,
+                   size_t num_cmds,
+                   int update_flags,
+                   wimlib_progress_func_t progress_func);
+
 /**
  * Writes a standalone WIM to a file.
  *
index 1ddec8e..c0da1ab 100644 (file)
@@ -451,11 +451,23 @@ struct add_image_params {
        u64 capture_root_dev;
 };
 
+
+/* capture_common.c */
+
 extern bool
 exclude_path(const tchar *path, size_t path_len,
             const struct wimlib_capture_config *config,
             bool exclude_prefix);
 
+extern struct wimlib_capture_config *
+copy_capture_config(const struct wimlib_capture_config *config);
+
+extern int
+canonicalize_capture_config(struct wimlib_capture_config *config);
+
+extern void
+free_capture_config(struct wimlib_capture_config *config);
+
 /* extract_image.c */
 
 /* Internal use only */
@@ -715,6 +727,9 @@ extern int
 copy_resource(struct wim_lookup_table_entry *lte, void *w);
 
 /* security.c */
+extern struct wim_security_data *
+new_wim_security_data();
+
 extern int
 read_security_data(const u8 metadata_resource[],
                   u64 metadata_resource_len, struct wim_security_data **sd_p);
@@ -727,6 +742,18 @@ write_security_data(const struct wim_security_data *sd, u8 *p);
 extern void
 free_security_data(struct wim_security_data *sd);
 
+/* unix_capture.c */
+#ifndef __WIN32__
+extern int
+unix_build_dentry_tree(struct wim_dentry **root_ret,
+                      const char *root_disk_path,
+                      struct add_image_params *params);
+#endif
+
+/* update_image.c */
+extern int
+rename_wim_path(WIMStruct *wim, const tchar *from, const tchar *to);
+
 /* verify.c */
 
 extern int
@@ -785,10 +812,6 @@ close_wim(WIMStruct *w);
 /* We are capturing a tree to be placed in the root of the WIM image */
 #define WIMLIB_ADD_IMAGE_FLAG_ROOT     0x80000000
 
-/* We are capturing a dentry that will become the root of a tree to be added to
- * the WIM image */
-#define WIMLIB_ADD_IMAGE_FLAG_SOURCE    0x40000000
-
 extern int
 begin_write(WIMStruct *w, const tchar *path, int write_flags);
 
index 2977ffc..f49cbeb 100644 (file)
@@ -1501,7 +1501,7 @@ win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
        inode->i_last_access_time = FILETIME_to_u64(&file_info.ftLastAccessTime);
        inode->i_resolved = 1;
 
-       params->add_image_flags &= ~(WIMLIB_ADD_IMAGE_FLAG_ROOT | WIMLIB_ADD_IMAGE_FLAG_SOURCE);
+       params->add_image_flags &= ~WIMLIB_ADD_IMAGE_FLAG_ROOT;
 
        if (!(params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS)
            && (vol_flags & FILE_PERSISTENT_ACLS))