imagex-extract initial implementation
authorEric Biggers <ebiggers3@gmail.com>
Sun, 5 May 2013 17:19:26 +0000 (12:19 -0500)
committerEric Biggers <ebiggers3@gmail.com>
Sun, 5 May 2013 17:19:26 +0000 (12:19 -0500)
programs/imagex.c
src/add_image.c
src/dentry.c
src/dentry.h
src/extract_image.c
src/util.c
src/util.h
src/wimlib.h
src/wimlib_internal.h

index 0bba3546bd55a8c7fc381f63cafa8d196b2477e3..275f48d1d051549dd5f2dde8b46e89aa5d1a2408 100644 (file)
@@ -68,6 +68,7 @@ enum imagex_op_type {
        DELETE,
        DIR,
        EXPORT,
+       EXTRACT,
        INFO,
        JOIN,
        MOUNT,
@@ -122,6 +123,12 @@ IMAGEX_PROGNAME" export SRC_WIMFILE (SRC_IMAGE_NUM | SRC_IMAGE_NAME | all ) \n"
 "              [--boot] [--check] [--compress=TYPE] [--ref=\"GLOB\"]\n"
 "              [--threads=NUM_THREADS] [--rebuild]\n"
 ),
+[EXTRACT] =
+T(
+IMAGEX_PROGNAME" extract SRC_WIMFILE (SRC_IMAGE_NUM | SRC_IMAGE_NAME) [PATH...]\n"
+"              [--check] [--ref=\"GLOB\"] [--verbose] [--unix-data] [--no-acls]\n"
+"              [--strict-acls] [--to-stdout] [--dest-dir=DIR]\n"
+),
 [INFO] =
 T(
 IMAGEX_PROGNAME" info WIMFILE [IMAGE_NUM | IMAGE_NAME] [NEW_NAME]\n"
@@ -168,14 +175,15 @@ enum {
        IMAGEX_CONFIG_OPTION,
        IMAGEX_DEBUG_OPTION,
        IMAGEX_DEREFERENCE_OPTION,
+       IMAGEX_DEST_DIR_OPTION,
        IMAGEX_EXTRACT_XML_OPTION,
        IMAGEX_FLAGS_OPTION,
        IMAGEX_HARDLINK_OPTION,
        IMAGEX_HEADER_OPTION,
        IMAGEX_LOOKUP_TABLE_OPTION,
        IMAGEX_METADATA_OPTION,
-       IMAGEX_NO_ACLS_OPTION,
        IMAGEX_NORPFIX_OPTION,
+       IMAGEX_NO_ACLS_OPTION,
        IMAGEX_REBULID_OPTION,
        IMAGEX_RECOMPRESS_OPTION,
        IMAGEX_REF_OPTION,
@@ -187,6 +195,7 @@ enum {
        IMAGEX_STRICT_ACLS_OPTION,
        IMAGEX_SYMLINK_OPTION,
        IMAGEX_THREADS_OPTION,
+       IMAGEX_TO_STDOUT_OPTION,
        IMAGEX_UNIX_DATA_OPTION,
        IMAGEX_VERBOSE_OPTION,
        IMAGEX_XML_OPTION,
@@ -241,6 +250,19 @@ static const struct option export_options[] = {
        {NULL, 0, NULL, 0},
 };
 
+static const struct option extract_options[] = {
+       {T("check"),       no_argument,       NULL, IMAGEX_CHECK_OPTION},
+       {T("verbose"),     no_argument,       NULL, IMAGEX_VERBOSE_OPTION},
+       {T("ref"),         required_argument, NULL, IMAGEX_REF_OPTION},
+       {T("unix-data"),   no_argument,       NULL, IMAGEX_UNIX_DATA_OPTION},
+       {T("noacls"),      no_argument,       NULL, IMAGEX_NO_ACLS_OPTION},
+       {T("no-acls"),     no_argument,       NULL, IMAGEX_NO_ACLS_OPTION},
+       {T("strict-acls"), no_argument,       NULL, IMAGEX_STRICT_ACLS_OPTION},
+       {T("dest-dir"),    required_argument, NULL, IMAGEX_DEST_DIR_OPTION},
+       {T("to-stdout"),   no_argument,       NULL, IMAGEX_TO_STDOUT_OPTION},
+       {NULL, 0, NULL, 0},
+};
+
 static const struct option info_options[] = {
        {T("boot"),         no_argument,       NULL, IMAGEX_BOOT_OPTION},
        {T("check"),        no_argument,       NULL, IMAGEX_CHECK_OPTION},
@@ -991,7 +1013,7 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                        tputchar(T('\n'));
                break;
        case WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN:
-               tprintf(T("Applying image %d (%"TS") from \"%"TS"\" "
+               tprintf(T("Applying image %d (\"%"TS"\") from \"%"TS"\" "
                          "to %"TS" \"%"TS"\"\n"),
                        info->extract.image,
                        info->extract.image_name,
@@ -1000,6 +1022,15 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                         T("NTFS volume") : T("directory")),
                        info->extract.target);
                break;
+       case WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN:
+               tprintf(T("Extracting \"%"TS"\" from image %d (\"%"TS"\") "
+                         "in \"%"TS"\" to \"%"TS"\"\n"),
+                       info->extract.extract_root_wim_source_path,
+                       info->extract.image,
+                       info->extract.image_name,
+                       info->extract.wimfile_name,
+                       info->extract.target);
+               break;
        /*case WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_BEGIN:*/
                /*tprintf(T("Applying directory structure to %"TS"\n"),*/
                        /*info->extract.target);*/
@@ -1019,7 +1050,8 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                tprintf(T("%"TS"\n"), info->extract.cur_path);
                break;
        case WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS:
-               tprintf(T("Setting timestamps on all extracted files...\n"));
+               if (info->extract.extract_root_wim_source_path[0] == T('\0'))
+                       tprintf(T("Setting timestamps on all extracted files...\n"));
                break;
        case WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END:
                if (info->extract.extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
@@ -1815,6 +1847,183 @@ out:
        return ret;
 }
 
+static bool
+is_root_wim_path(const tchar *path)
+{
+       const tchar *p;
+       for (p = path; *p; p++)
+               if (*p != T('\\') && *p != T('\\'))
+                       return false;
+       return true;
+}
+
+static void
+free_extract_commands(struct wimlib_extract_command *cmds, size_t num_cmds,
+                     tchar *dest_dir)
+{
+       for (size_t i = 0; i < num_cmds; i++)
+               if (cmds[i].fs_dest_path != dest_dir)
+                               free(cmds[i].fs_dest_path);
+       free(cmds);
+}
+
+static struct wimlib_extract_command *
+prepare_extract_commands(tchar **argv, int argc, int extract_flags,
+                        tchar *dest_dir, size_t *num_cmds_ret)
+{
+       struct wimlib_extract_command *cmds;
+       size_t num_cmds;
+       tchar *emptystr = T("");
+
+       num_cmds = argc;
+       if (argc == 0) {
+               num_cmds = 1;
+               argv = &emptystr;
+       }
+       cmds = calloc(num_cmds, sizeof(cmds[0]));
+       if (!cmds) {
+               imagex_error("Out of memory!");
+               return NULL;
+       }
+
+       for (size_t i = 0; i < num_cmds; i++) {
+               cmds[i].extract_flags = extract_flags;
+               cmds[i].wim_source_path = argv[i];
+               if (is_root_wim_path(argv[i])) {
+                       cmds[i].fs_dest_path = dest_dir;
+               } else {
+                       size_t len = tstrlen(dest_dir) + 1 + tstrlen(argv[i]);
+                       cmds[i].fs_dest_path = malloc((len + 1) * sizeof(tchar));
+                       if (!cmds[i].fs_dest_path)
+                               goto oom;
+                       tsprintf(cmds[i].fs_dest_path, "%"TS"/%"TS, dest_dir, tbasename(argv[i]));
+               }
+       }
+
+       *num_cmds_ret = num_cmds;
+       return cmds;
+oom:
+       free_extract_commands(cmds, num_cmds, dest_dir);
+       return NULL;
+}
+
+static int
+imagex_extract(int argc, tchar **argv)
+{
+       int c;
+       int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
+       int image;
+       WIMStruct *wim;
+       int ret;
+       const tchar *wimfile;
+       const tchar *image_num_or_name;
+       tchar *dest_dir = T(".");
+       int extract_flags = WIMLIB_EXTRACT_FLAG_SEQUENTIAL;
+
+       const tchar *swm_glob = NULL;
+       WIMStruct **additional_swms = NULL;
+       unsigned num_additional_swms = 0;
+
+       struct wimlib_extract_command *cmds;
+       size_t num_cmds;
+
+       for_opt(c, extract_options) {
+               switch (c) {
+               case IMAGEX_CHECK_OPTION:
+                       open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+                       break;
+               case IMAGEX_VERBOSE_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
+                       break;
+               case IMAGEX_REF_OPTION:
+                       swm_glob = optarg;
+                       break;
+               case IMAGEX_UNIX_DATA_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_UNIX_DATA;
+                       break;
+               case IMAGEX_NO_ACLS_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_NO_ACLS;
+                       break;
+               case IMAGEX_STRICT_ACLS_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_STRICT_ACLS;
+                       break;
+               case IMAGEX_DEST_DIR_OPTION:
+                       dest_dir = optarg;
+                       break;
+               case IMAGEX_TO_STDOUT_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_TO_STDOUT;
+                       break;
+               default:
+                       usage(EXTRACT);
+                       ret = -1;
+                       goto out;
+               }
+       }
+       argc -= optind;
+       argv += optind;
+
+       if (argc < 2) {
+               usage(EXTRACT);
+               ret = -1;
+               goto out;
+       }
+       wimfile = argv[0];
+       image_num_or_name = argv[1];
+
+       argc -= 2;
+       argv += 2;
+
+       cmds = prepare_extract_commands(argv, argc, extract_flags, dest_dir,
+                                       &num_cmds);
+       if (!cmds) {
+               ret = -1;
+               goto out;
+       }
+
+       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+       if (ret)
+               goto out_free_cmds;
+
+       image = wimlib_resolve_image(wim, image_num_or_name);
+       ret = verify_image_exists_and_is_single(image,
+                                               image_num_or_name,
+                                               wimfile);
+       if (ret)
+               goto out_wimlib_free;
+
+       if (swm_glob) {
+               ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
+                                         &additional_swms,
+                                         &num_additional_swms);
+               if (ret)
+                       goto out_wimlib_free;
+       }
+
+#ifdef __WIN32__
+       win32_acquire_restore_privileges();
+#endif
+
+       ret = wimlib_extract_files(wim, image, 0, cmds, num_cmds,
+                                  additional_swms, num_additional_swms,
+                                  imagex_progress_func);
+       if (ret == 0)
+               tprintf(T("Done extracting files.\n"));
+#ifdef __WIN32__
+       win32_release_restore_privileges();
+#endif
+       if (additional_swms) {
+               for (unsigned i = 0; i < num_additional_swms; i++)
+                       wimlib_free(additional_swms[i]);
+               free(additional_swms);
+       }
+out_wimlib_free:
+       wimlib_free(wim);
+out_free_cmds:
+       free_extract_commands(cmds, num_cmds, dest_dir);
+out:
+       return ret;
+}
+
 /* Prints information about a WIM file; also can mark an image as bootable,
  * change the name of an image, or change the description of an image. */
 static int
@@ -2443,6 +2652,7 @@ static const struct imagex_command imagex_commands[] = {
        {T("delete"),  imagex_delete,            DELETE},
        {T("dir"),     imagex_dir,               DIR},
        {T("export"),  imagex_export,            EXPORT},
+       {T("extract"), imagex_extract,           EXTRACT},
        {T("info"),    imagex_info,              INFO},
        {T("join"),    imagex_join,              JOIN},
        {T("mount"),   imagex_mount_rw_or_ro,    MOUNT},
index 9bd597a131a1c9bdb71fff0a177b17b0f71d923c..c39ded67c3903ec1ba1b8458a504fd0ae07665eb 100644 (file)
@@ -478,29 +478,6 @@ exclude_path(const tchar *path, size_t path_len,
 
 }
 
-/* Strip leading and trailing forward slashes from a string.  Modifies it in
- * place and returns the stripped string. */
-static const tchar *
-canonicalize_target_path(tchar *target_path)
-{
-       tchar *p;
-       if (target_path == NULL)
-               return T("");
-       for (;;) {
-               if (*target_path == T('\0'))
-                       return target_path;
-               else if (*target_path == T('/'))
-                       target_path++;
-               else
-                       break;
-       }
-
-       p = tstrchr(target_path, T('\0')) - 1;
-       while (*p == T('/'))
-               *p-- = T('\0');
-       return target_path;
-}
-
 /* Strip leading and trailing slashes from the target paths, and translate all
  * backslashes in the source and target paths into forward slashes. */
 static void
@@ -515,12 +492,8 @@ canonicalize_sources_and_targets(struct wimlib_capture_source *sources,
                /* The Windows API can handle forward slashes.  Just get rid of
                 * backslashes to avoid confusing other parts of the library
                 * code. */
-               zap_backslashes(sources->fs_source_path);
-               if (sources->wim_target_path)
-                       zap_backslashes(sources->wim_target_path);
-
-               sources->wim_target_path =
-                       (tchar*)canonicalize_target_path(sources->wim_target_path);
+               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++;
        }
index 73dba52b26fa68943a8f827389018b59598295b7..2e5090f2509ba24fd43697bb726fae80fb8ddbbf 100644 (file)
@@ -1270,13 +1270,13 @@ replace_forbidden_characters(utf16lechar *name)
        #ifdef __WIN32__
                if (wcschr(L"<>:\"/\\|?*", (wchar_t)*p))
        #else
-               if (*p == '/')
+               if (*p == cpu_to_le16('/'))
        #endif
                {
                #ifdef __WIN32__
                        *p = cpu_to_le16(0xfffd);
                #else
-                       *p = '?';
+                       *p = cpu_to_le16('?');
                #endif
                        if (name) {
                                WARNING("File, directory, or stream name \"%"WS"\"\n"
index 1629111d83d1ccc5d662436aef09e7f0a2d00e98..d3060be99048e22db5957b98d69a99e47318907c 100644 (file)
@@ -232,6 +232,8 @@ struct wim_inode {
        /* %true iff verify_inode() has run on this inode. */
        u8 i_verified : 1;
 
+       u8 i_visited : 1;
+
        /* Used only in NTFS-mode extraction */
        u8 i_dos_name_extracted : 1;
 
index cd23e45d4b4cf050da22bb1ae1ca431f7c761255..5522a1fcfee417c55d99b07d17e5f715ba824a99 100644 (file)
@@ -57,6 +57,7 @@
 #  include <alloca.h>
 #endif
 
+
 #ifndef __WIN32__
 
 /* Returns the number of components of @path.  */
@@ -450,7 +451,7 @@ unix_do_apply_dentry(const char *output_path, size_t output_path_len,
 static int
 unix_do_apply_dentry_timestamps(const char *output_path,
                                size_t output_path_len,
-                               const struct wim_dentry *dentry,
+                               struct wim_dentry *dentry,
                                struct apply_args *args)
 {
        int ret;
@@ -508,29 +509,42 @@ unix_do_apply_dentry_timestamps(const char *output_path,
 }
 #endif /* !__WIN32__ */
 
+static int
+do_apply_op(struct wim_dentry *dentry, struct apply_args *args,
+           int (*apply_dentry_func)(const tchar *, size_t,
+                                    struct wim_dentry *, struct apply_args *))
+{
+       tchar *p;
+       const tchar *full_path = dentry->_full_path + 1;
+       size_t full_path_nchars = dentry->full_path_nbytes / sizeof(tchar) - 1;
+
+       tchar output_path[args->target_nchars + 1 +
+                        (full_path_nchars - args->wim_source_path_nchars) + 1];
+       p = output_path;
+
+       tmemcpy(p, args->target, args->target_nchars);
+       p += args->target_nchars;
+
+       if (dentry != args->extract_root) {
+               *p++ = T('/');
+               tmemcpy(p, full_path + args->wim_source_path_nchars,
+                       full_path_nchars - args->wim_source_path_nchars);
+               p += full_path_nchars - args->wim_source_path_nchars;
+       }
+       *p = T('\0');
+       return (*apply_dentry_func)(output_path, p - output_path,
+                                   dentry, args);
+}
+
+
 /* Extracts a file, directory, or symbolic link from the WIM archive. */
 static int
 apply_dentry_normal(struct wim_dentry *dentry, void *arg)
 {
-       struct apply_args *args = arg;
-       size_t len;
-       tchar *output_path;
-
-       len = tstrlen(args->target);
-       if (dentry_is_root(dentry)) {
-               output_path = (tchar*)args->target;
-       } else {
-               output_path = alloca(len * sizeof(tchar) + dentry->full_path_nbytes +
-                                    sizeof(tchar));
-               memcpy(output_path, args->target, len * sizeof(tchar));
-               memcpy(output_path + len, dentry->_full_path, dentry->full_path_nbytes);
-               len += dentry->full_path_nbytes / sizeof(tchar);
-               output_path[len] = T('\0');
-       }
 #ifdef __WIN32__
-       return win32_do_apply_dentry(output_path, len, dentry, args);
+       return do_apply_op(dentry, arg, win32_do_apply_dentry);
 #else
-       return unix_do_apply_dentry(output_path, len, dentry, args);
+       return do_apply_op(dentry, arg, unix_do_apply_dentry);
 #endif
 }
 
@@ -539,26 +553,10 @@ apply_dentry_normal(struct wim_dentry *dentry, void *arg)
 static int
 apply_dentry_timestamps_normal(struct wim_dentry *dentry, void *arg)
 {
-       struct apply_args *args = arg;
-       size_t len;
-       tchar *output_path;
-
-       len = tstrlen(args->target);
-       if (dentry_is_root(dentry)) {
-               output_path = (tchar*)args->target;
-       } else {
-               output_path = alloca(len * sizeof(tchar) + dentry->full_path_nbytes +
-                                    sizeof(tchar));
-               memcpy(output_path, args->target, len * sizeof(tchar));
-               memcpy(output_path + len, dentry->_full_path, dentry->full_path_nbytes);
-               len += dentry->full_path_nbytes / sizeof(tchar);
-               output_path[len] = T('\0');
-       }
-
 #ifdef __WIN32__
-       return win32_do_apply_dentry_timestamps(output_path, len, dentry, args);
+       return do_apply_op(dentry, arg, win32_do_apply_dentry_timestamps);
 #else
-       return unix_do_apply_dentry_timestamps(output_path, len, dentry, args);
+       return do_apply_op(dentry, arg, unix_do_apply_dentry_timestamps);
 #endif
 }
 
@@ -679,25 +677,62 @@ inode_find_streams_for_extraction(struct wim_inode *inode,
        }
 }
 
+struct find_streams_ctx {
+       struct list_head stream_list;
+       int extract_flags;
+};
+
+static int
+dentry_find_streams_to_extract(struct wim_dentry *dentry, void *_ctx)
+{
+       struct find_streams_ctx *ctx = _ctx;
+       struct wim_inode *inode = dentry->d_inode;
+
+       dentry->is_extracted = 0;
+       if (!inode->i_visited) {
+               inode_find_streams_for_extraction(inode, &ctx->stream_list,
+                                                 ctx->extract_flags);
+               inode->i_visited = 1;
+       }
+       return 0;
+}
+
+static int
+dentry_resolve_and_zero_lte_refcnt(struct wim_dentry *dentry, void *_lookup_table)
+{
+       struct wim_inode *inode = dentry->d_inode;
+       struct wim_lookup_table *lookup_table = _lookup_table;
+       struct wim_lookup_table_entry *lte;
+
+       inode_resolve_ltes(inode, lookup_table);
+       for (unsigned i = 0; i <= inode->i_num_ads; i++) {
+               lte = inode_stream_lte_resolved(inode, i);
+               if (lte)
+                       lte->out_refcnt = 0;
+       }
+       return 0;
+}
+
 static void
-find_streams_for_extraction(struct wim_image_metadata *imd,
+find_streams_for_extraction(struct wim_dentry *root,
                            struct list_head *stream_list,
                            struct wim_lookup_table *lookup_table,
                            int extract_flags)
 {
-       struct wim_inode *inode;
-       struct wim_dentry *dentry;
+       struct find_streams_ctx ctx;
 
-       for_lookup_table_entry(lookup_table, lte_zero_out_refcnt, NULL);
-       INIT_LIST_HEAD(stream_list);
-       image_for_each_inode(inode, imd) {
-               if (!inode->i_resolved)
-                       inode_resolve_ltes(inode, lookup_table);
-               inode_for_each_dentry(dentry, inode)
-                       dentry->is_extracted = 0;
-               inode_find_streams_for_extraction(inode, stream_list,
-                                                 extract_flags);
-       }
+       INIT_LIST_HEAD(&ctx.stream_list);
+       ctx.extract_flags = extract_flags;
+       for_dentry_in_tree(root, dentry_resolve_and_zero_lte_refcnt, lookup_table);
+       for_dentry_in_tree(root, dentry_find_streams_to_extract, &ctx);
+       list_transfer(&ctx.stream_list, stream_list);
+}
+
+static int
+dentry_mark_inode_unvisited(struct wim_dentry *dentry, void *_ignore)
+{
+       dentry->d_inode->i_visited = 0;
+       return 0;
 }
 
 struct apply_operations {
@@ -806,32 +841,33 @@ sort_stream_list_by_wim_position(struct list_head *stream_list)
 }
 
 
-/* Extracts the image @image from the WIM @w to the directory or NTFS volume
- * @target. */
 static int
-extract_single_image(WIMStruct *w, int image,
-                    const tchar *target, int extract_flags,
-                    wimlib_progress_func_t progress_func)
+extract_tree(WIMStruct *wim, int image,
+            const tchar *wim_source_path, const tchar *target,
+            int extract_flags, wimlib_progress_func_t progress_func)
 {
        int ret;
        struct list_head stream_list;
-
        struct apply_args args;
        const struct apply_operations *ops;
+       struct wim_dentry *root;
 
        memset(&args, 0, sizeof(args));
 
-       args.w                  = w;
-       args.target             = target;
-       args.extract_flags      = extract_flags;
-       args.progress_func      = progress_func;
+       args.w                      = wim;
+       args.target                 = target;
+       args.extract_flags          = extract_flags;
+       args.progress_func          = progress_func;
+       args.target_nchars          = tstrlen(target);
+       args.wim_source_path_nchars = tstrlen(wim_source_path);
 
        if (progress_func) {
-               args.progress.extract.wimfile_name = w->filename;
+               args.progress.extract.wimfile_name = wim->filename;
                args.progress.extract.image = image;
                args.progress.extract.extract_flags = (extract_flags &
                                                       WIMLIB_EXTRACT_MASK_PUBLIC);
-               args.progress.extract.image_name = wimlib_get_image_name(w, image);
+               args.progress.extract.image_name = wimlib_get_image_name(wim, image);
+               args.progress.extract.extract_root_wim_source_path = wim_source_path;
                args.progress.extract.target = target;
        }
 
@@ -841,28 +877,35 @@ extract_single_image(WIMStruct *w, int image,
                if (!args.vol) {
                        ERROR_WITH_ERRNO("Failed to mount NTFS volume `%"TS"'",
                                         target);
-                       return WIMLIB_ERR_NTFS_3G;
+                       ret = WIMLIB_ERR_NTFS_3G;
+                       goto out;
                }
                ops = &ntfs_apply_operations;
        } else
 #endif
                ops = &normal_apply_operations;
 
-       ret = select_wim_image(w, image);
-       if (ret)
-               goto out;
+       root = get_dentry(wim, wim_source_path);
+       if (!root) {
+               ERROR("Path \"%"TS"\" does not exist in WIM image %d",
+                     wim_source_path, image);
+               ret = WIMLIB_ERR_PATH_DOES_NOT_EXIST;
+               goto out_ntfs_umount;
+       }
+       args.extract_root = root;
 
        /* Build a list of the streams that need to be extracted */
-       find_streams_for_extraction(wim_get_current_image_metadata(w),
+       find_streams_for_extraction(root,
                                    &stream_list,
-                                   w->lookup_table, extract_flags);
+                                   wim->lookup_table, extract_flags);
 
        /* Calculate the number of bytes of data that will be extracted */
        calculate_bytes_to_extract(&stream_list, extract_flags,
                                   &args.progress);
 
        if (progress_func) {
-               progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN,
+               progress_func(*wim_source_path ? WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN :
+                             WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN,
                              &args.progress);
        }
 
@@ -882,17 +925,17 @@ extract_single_image(WIMStruct *w, int image,
                              &args.progress);
        }
 
-       ret = calculate_dentry_tree_full_paths(wim_root_dentry(w));
+       ret = calculate_dentry_tree_full_paths(root);
        if (ret)
-               goto out;
+               goto out_mark_inodes_unvisited;
 
        /* Make the directory structure and extract empty files */
        args.extract_flags |= WIMLIB_EXTRACT_FLAG_NO_STREAMS;
        args.apply_dentry = ops->apply_dentry;
-       ret = for_dentry_in_tree(wim_root_dentry(w), maybe_apply_dentry, &args);
+       ret = for_dentry_in_tree(root, maybe_apply_dentry, &args);
        args.extract_flags &= ~WIMLIB_EXTRACT_FLAG_NO_STREAMS;
        if (ret)
-               goto out;
+               goto out_mark_inodes_unvisited;
 
        if (progress_func) {
                progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_END,
@@ -901,8 +944,10 @@ extract_single_image(WIMStruct *w, int image,
 
        if (extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) {
                args.target_realpath = realpath(target, NULL);
-               if (!args.target_realpath)
-                       return WIMLIB_ERR_NOMEM;
+               if (!args.target_realpath) {
+                       ret = WIMLIB_ERR_NOMEM;
+                       goto out_mark_inodes_unvisited;
+               }
                args.target_realpath_len = tstrlen(args.target_realpath);
        }
 
@@ -917,18 +962,21 @@ extract_single_image(WIMStruct *w, int image,
        }
 
        /* Apply timestamps */
-       ret = for_dentry_in_tree_depth(wim_root_dentry(w),
+       ret = for_dentry_in_tree_depth(root,
                                       ops->apply_dentry_timestamps, &args);
        if (ret)
                goto out_free_target_realpath;
 
        if (progress_func) {
-               progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END,
+               progress_func(*wim_source_path ? WIMLIB_PROGRESS_MSG_EXTRACT_TREE_END :
+                             WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END,
                              &args.progress);
        }
 out_free_target_realpath:
        FREE(args.target_realpath);
-out:
+out_mark_inodes_unvisited:
+       for_dentry_in_tree(root, dentry_mark_inode_unvisited, NULL);
+out_ntfs_umount:
 #ifdef WITH_NTFS_3G
        /* Unmount the NTFS volume */
        if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
@@ -940,6 +988,237 @@ out:
                }
        }
 #endif
+out:
+       return ret;
+}
+
+static int
+check_extract_command(struct wimlib_extract_command *cmd,
+                     bool multiple_commands,
+                     int wim_header_flags)
+{
+       int extract_flags;
+       bool is_entire_image = (cmd->wim_source_path == T('\0'));
+
+       if (cmd->fs_dest_path[0] == T('\0'))
+               return WIMLIB_ERR_INVALID_PARAM;
+
+       extract_flags = cmd->extract_flags;
+
+       if ((extract_flags &
+            (WIMLIB_EXTRACT_FLAG_SYMLINK |
+             WIMLIB_EXTRACT_FLAG_HARDLINK)) == (WIMLIB_EXTRACT_FLAG_SYMLINK |
+                                                WIMLIB_EXTRACT_FLAG_HARDLINK))
+               return WIMLIB_ERR_INVALID_PARAM;
+
+#ifdef __WIN32__
+       if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) {
+               ERROR("Extracting UNIX data is not supported on Windows");
+               return WIMLIB_ERR_INVALID_PARAM;
+       }
+       if (extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK |
+                            WIMLIB_EXTRACT_FLAG_HARDLINK))
+       {
+               ERROR("Linked extraction modes are not supported on Windows");
+               return WIMLIB_ERR_INVALID_PARAM;
+       }
+#endif
+
+       if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
+#ifdef WITH_NTFS_3G
+               if ((extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))) {
+                       ERROR("Cannot specify symlink or hardlink flags when applying\n"
+                             "        directly to a NTFS volume");
+                       return WIMLIB_ERR_INVALID_PARAM;
+               }
+               if (!is_entire_image &&
+                   (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS))
+               {
+                       ERROR("Can only extract entire image when applying "
+                             "directly to a NTFS volume");
+                       return WIMLIB_ERR_INVALID_PARAM;
+               }
+               if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) {
+                       ERROR("Cannot restore UNIX-specific data in "
+                             "the NTFS extraction mode");
+                       return WIMLIB_ERR_INVALID_PARAM;
+               }
+#else
+               ERROR("wimlib was compiled without support for NTFS-3g, so");
+               ERROR("we cannot apply a WIM image directly to a NTFS volume");
+               return WIMLIB_ERR_UNSUPPORTED;
+#endif
+       }
+
+       if ((extract_flags & (WIMLIB_EXTRACT_FLAG_RPFIX |
+                             WIMLIB_EXTRACT_FLAG_NORPFIX)) ==
+               (WIMLIB_EXTRACT_FLAG_RPFIX | WIMLIB_EXTRACT_FLAG_NORPFIX))
+       {
+               ERROR("Cannot specify RPFIX and NORPFIX flags at the same time!");
+               return WIMLIB_ERR_INVALID_PARAM;
+       }
+
+       if ((extract_flags & (WIMLIB_EXTRACT_FLAG_RPFIX |
+                             WIMLIB_EXTRACT_FLAG_NORPFIX)) == 0)
+       {
+               if ((wim_header_flags & WIM_HDR_FLAG_RP_FIX) && is_entire_image)
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_RPFIX;
+       }
+
+       if (!is_entire_image && (extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX)) {
+               ERROR("Cannot specify --rpfix when not extracting entire image");
+               return WIMLIB_ERR_INVALID_PARAM;
+       }
+
+       cmd->extract_flags = extract_flags;
+       return 0;
+}
+
+
+static int
+do_wimlib_extract_files(WIMStruct *wim,
+                       int image,
+                       struct wimlib_extract_command *cmds,
+                       size_t num_cmds,
+                       wimlib_progress_func_t progress_func)
+{
+       int ret;
+       bool found_link_cmd = false;
+       bool found_nolink_cmd = false;
+
+       ret = select_wim_image(wim, image);
+       if (ret)
+               return ret;
+
+       ret = wim_checksum_unhashed_streams(wim);
+       if (ret)
+               return ret;
+
+       for (size_t i = 0; i < num_cmds; i++) {
+               ret = check_extract_command(&cmds[i], num_cmds > 1,
+                                           wim->hdr.flags);
+               if (ret)
+                       return ret;
+               if (cmds[i].extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK |
+                                            WIMLIB_EXTRACT_FLAG_HARDLINK)) {
+                       found_link_cmd = true;
+               } else {
+                       found_nolink_cmd = true;
+               }
+               if (found_link_cmd && found_nolink_cmd) {
+                       ERROR("Symlink or hardlink extraction mode must "
+                             "be set on all extraction commands");
+                       return WIMLIB_ERR_INVALID_PARAM;
+               }
+       }
+
+       for (size_t i = 0; i < num_cmds; i++) {
+               ret = extract_tree(wim, image,
+                                  cmds[i].wim_source_path,
+                                  cmds[i].fs_dest_path,
+                                  cmds[i].extract_flags,
+                                  progress_func);
+               if (ret)
+                       return ret;
+       }
+       return 0;
+}
+
+WIMLIBAPI int
+wimlib_extract_files(WIMStruct *wim,
+                    int image,
+                    int default_extract_flags,
+                    const struct wimlib_extract_command *cmds,
+                    size_t num_cmds,
+                    WIMStruct **additional_swms,
+                    unsigned num_additional_swms,
+                    wimlib_progress_func_t progress_func)
+{
+       int ret;
+       struct wimlib_extract_command *cmds_copy;
+       struct wim_lookup_table *wim_tab_save, *joined_tab;
+       int all_flags = 0;
+
+       default_extract_flags &= WIMLIB_EXTRACT_MASK_PUBLIC;
+
+       ret = verify_swm_set(wim, additional_swms, num_additional_swms);
+       if (ret)
+               goto out;
+
+       if (num_additional_swms) {
+               ret = new_joined_lookup_table(wim, additional_swms,
+                                             num_additional_swms,
+                                             &joined_tab);
+               if (ret)
+                       goto out;
+               wim_tab_save = wim->lookup_table;
+               wim->lookup_table = joined_tab;
+       }
+
+       cmds_copy = CALLOC(num_cmds, sizeof(cmds[0]));
+       if (!cmds_copy) {
+               ret = WIMLIB_ERR_NOMEM;
+               goto out_restore_lookup_table;
+       }
+
+       for (size_t i = 0; i < num_cmds; i++) {
+               cmds_copy[i].extract_flags = (default_extract_flags |
+                                                cmds[i].extract_flags)
+                                               & WIMLIB_EXTRACT_MASK_PUBLIC;
+               all_flags |= cmds_copy[i].extract_flags;
+
+               cmds_copy[i].wim_source_path = canonicalize_wim_path(cmds[i].wim_source_path);
+               if (!cmds_copy[i].wim_source_path) {
+                       ret = WIMLIB_ERR_NOMEM;
+                       goto out_free_cmds_copy;
+               }
+
+               cmds_copy[i].fs_dest_path = canonicalize_fs_path(cmds[i].fs_dest_path);
+               if (!cmds_copy[i].fs_dest_path) {
+                       ret = WIMLIB_ERR_NOMEM;
+                       goto out_free_cmds_copy;
+               }
+
+       }
+       ret = do_wimlib_extract_files(wim, image,
+                                     cmds_copy, num_cmds,
+                                     progress_func);
+
+       if (all_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK |
+                        WIMLIB_EXTRACT_FLAG_HARDLINK))
+       {
+               for_lookup_table_entry(wim->lookup_table,
+                                      lte_free_extracted_file, NULL);
+       }
+out_free_cmds_copy:
+       for (size_t i = 0; i < num_cmds; i++) {
+               FREE(cmds_copy[i].wim_source_path);
+               FREE(cmds_copy[i].fs_dest_path);
+       }
+       FREE(cmds_copy);
+out_restore_lookup_table:
+       if (num_additional_swms) {
+               free_lookup_table(wim->lookup_table);
+               wim->lookup_table = wim_tab_save;
+       }
+out:
+       return ret;
+}
+
+static int
+extract_single_image(WIMStruct *wim, int image,
+                    const tchar *target, int extract_flags,
+                    wimlib_progress_func_t progress_func)
+{
+       int ret;
+       tchar *target_copy = canonicalize_fs_path(target);
+       struct wimlib_extract_command cmd = {
+               .wim_source_path = T(""),
+               .fs_dest_path = target_copy,
+               .extract_flags = extract_flags,
+       };
+       ret = do_wimlib_extract_files(wim, image, &cmd, 1, progress_func);
+       FREE(target_copy);
        return ret;
 }
 
@@ -964,12 +1243,12 @@ image_name_ok_as_dir(const tchar *image_name)
 /* Extracts all images from the WIM to the directory @target, with the images
  * placed in subdirectories named by their image names. */
 static int
-extract_all_images(WIMStruct *w,
+extract_all_images(WIMStruct *wim,
                   const tchar *target,
                   int extract_flags,
                   wimlib_progress_func_t progress_func)
 {
-       size_t image_name_max_len = max(xml_get_max_image_name_len(w), 20);
+       size_t image_name_max_len = max(xml_get_max_image_name_len(wim), 20);
        size_t output_path_len = tstrlen(target);
        tchar buf[output_path_len + 1 + image_name_max_len + 1];
        int ret;
@@ -982,8 +1261,8 @@ extract_all_images(WIMStruct *w,
 
        tmemcpy(buf, target, output_path_len);
        buf[output_path_len] = T('/');
-       for (image = 1; image <= w->hdr.image_count; image++) {
-               image_name = wimlib_get_image_name(w, image);
+       for (image = 1; image <= wim->hdr.image_count; image++) {
+               image_name = wimlib_get_image_name(wim, image);
                if (image_name_ok_as_dir(image_name)) {
                        tstrcpy(buf + output_path_len + 1, image_name);
                } else {
@@ -991,9 +1270,9 @@ extract_all_images(WIMStruct *w,
                         * characters. */
                        tsprintf(buf + output_path_len + 1, T("%d"), image);
                }
-               ret = extract_single_image(w, image, buf, extract_flags,
+               ret = extract_single_image(wim, image, buf, extract_flags,
                                           progress_func);
-               if (ret != 0)
+               if (ret)
                        return ret;
        }
        return 0;
@@ -1002,7 +1281,7 @@ extract_all_images(WIMStruct *w,
 /* Extracts a single image or all images from a WIM file to a directory or NTFS
  * volume. */
 WIMLIBAPI int
-wimlib_extract_image(WIMStruct *w,
+wimlib_extract_image(WIMStruct *wim,
                     int image,
                     const tchar *target,
                     int extract_flags,
@@ -1010,103 +1289,44 @@ wimlib_extract_image(WIMStruct *w,
                     unsigned num_additional_swms,
                     wimlib_progress_func_t progress_func)
 {
-       struct wim_lookup_table *joined_tab, *w_tab_save;
+       struct wim_lookup_table *joined_tab, *wim_tab_save;
        int ret;
 
-       if (!target)
-               return WIMLIB_ERR_INVALID_PARAM;
-
        extract_flags &= WIMLIB_EXTRACT_MASK_PUBLIC;
 
-       if ((extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))
-                       == (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))
-               return WIMLIB_ERR_INVALID_PARAM;
-
-#ifdef __WIN32__
-       if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) {
-               ERROR("Extracting UNIX data is not supported on Windows");
-               return WIMLIB_ERR_INVALID_PARAM;
-       }
-       if (extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK)) {
-               ERROR("Linked extraction modes are not supported on Windows");
-               return WIMLIB_ERR_INVALID_PARAM;
-       }
-#endif
-
-       if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
-#ifdef WITH_NTFS_3G
-               if ((extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))) {
-                       ERROR("Cannot specify symlink or hardlink flags when applying\n"
-                             "        directly to a NTFS volume");
-                       return WIMLIB_ERR_INVALID_PARAM;
-               }
-               if (image == WIMLIB_ALL_IMAGES) {
-                       ERROR("Can only apply a single image when applying "
-                             "directly to a NTFS volume");
-                       return WIMLIB_ERR_INVALID_PARAM;
-               }
-               if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) {
-                       ERROR("Cannot restore UNIX-specific data in the NTFS extraction mode");
-                       return WIMLIB_ERR_INVALID_PARAM;
-               }
-#else
-               ERROR("wimlib was compiled without support for NTFS-3g, so");
-               ERROR("we cannot apply a WIM image directly to a NTFS volume");
-               return WIMLIB_ERR_UNSUPPORTED;
-#endif
-       }
-
-       if ((extract_flags & (WIMLIB_EXTRACT_FLAG_RPFIX |
-                             WIMLIB_EXTRACT_FLAG_RPFIX)) ==
-               (WIMLIB_EXTRACT_FLAG_RPFIX | WIMLIB_EXTRACT_FLAG_NORPFIX))
-       {
-               ERROR("Cannot specify RPFIX and NORPFIX flags at the same time!");
-               return WIMLIB_ERR_INVALID_PARAM;
-       }
-
-       if ((extract_flags & (WIMLIB_EXTRACT_FLAG_RPFIX |
-                             WIMLIB_EXTRACT_FLAG_NORPFIX)) == 0)
-               if (w->hdr.flags & WIM_HDR_FLAG_RP_FIX)
-                       extract_flags |= WIMLIB_EXTRACT_FLAG_RPFIX;
-
-       ret = verify_swm_set(w, additional_swms, num_additional_swms);
-       if (ret)
-               return ret;
-
-       ret = wim_checksum_unhashed_streams(w);
+       ret = verify_swm_set(wim, additional_swms, num_additional_swms);
        if (ret)
                return ret;
 
        if (num_additional_swms) {
-               ret = new_joined_lookup_table(w, additional_swms,
+               ret = new_joined_lookup_table(wim, additional_swms,
                                              num_additional_swms, &joined_tab);
                if (ret)
                        return ret;
-               w_tab_save = w->lookup_table;
-               w->lookup_table = joined_tab;
+               wim_tab_save = wim->lookup_table;
+               wim->lookup_table = joined_tab;
        }
 
        if (image == WIMLIB_ALL_IMAGES) {
                extract_flags |= WIMLIB_EXTRACT_FLAG_MULTI_IMAGE;
-               ret = extract_all_images(w, target, extract_flags,
+               ret = extract_all_images(wim, target, extract_flags,
                                         progress_func);
        } else {
                extract_flags &= ~WIMLIB_EXTRACT_FLAG_MULTI_IMAGE;
-               ret = extract_single_image(w, image, target, extract_flags,
+               ret = extract_single_image(wim, image, target, extract_flags,
                                           progress_func);
        }
 
        if (extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK |
                             WIMLIB_EXTRACT_FLAG_HARDLINK))
        {
-               for_lookup_table_entry(w->lookup_table,
+               for_lookup_table_entry(wim->lookup_table,
                                       lte_free_extracted_file,
                                       NULL);
        }
-
        if (num_additional_swms) {
-               free_lookup_table(w->lookup_table);
-               w->lookup_table = w_tab_save;
+               free_lookup_table(wim->lookup_table);
+               wim->lookup_table = wim_tab_save;
        }
        return ret;
 }
index 5421a6b5c53beab448e4c23a9d9be1004b92f8ea..35fbf6f11092270554918c02dc84fbfcc2da27f1 100644 (file)
@@ -347,6 +347,8 @@ static const tchar *error_strings[] = {
                = T("Failed to open a file"),
        [WIMLIB_ERR_OPENDIR]
                = T("Failed to open a directory"),
+       [WIMLIB_ERR_PATH_DOES_NOT_EXIST]
+               = T("The path does not exist in the WIM image"),
        [WIMLIB_ERR_READ]
                = T("Could not read data from a file"),
        [WIMLIB_ERR_READLINK]
@@ -570,6 +572,45 @@ zap_backslashes(tchar *s)
        }
 }
 
+tchar *
+canonicalize_fs_path(const tchar *fs_path)
+{
+       tchar *canonical_path;
+
+       if (!fs_path)
+               fs_path = T("");
+       canonical_path = TSTRDUP(fs_path);
+       zap_backslashes(canonical_path);
+       return canonical_path;
+}
+
+/* Strip leading and trailing slashes from a string.  Also translates
+ * backslashes into forward slashes.  */
+tchar *
+canonicalize_wim_path(const tchar *wim_path)
+{
+       tchar *p;
+       tchar *canonical_path;
+
+       if (wim_path == NULL) {
+               wim_path = T("");
+       } else {
+               while (*wim_path == T('/') || *wim_path == T('\\'))
+                       wim_path++;
+       }
+       canonical_path = TSTRDUP(wim_path);
+       if (canonical_path) {
+               zap_backslashes(canonical_path);
+               for (p = tstrchr(canonical_path, T('\0')) - 1;
+                    p >= canonical_path && *p == T('/');
+                    p--)
+               {
+                       *p = T('\0');
+               }
+       }
+       return canonical_path;
+}
+
 /* Like read(), but keep trying until everything has been written or we know for
  * sure that there was an error (or end-of-file). */
 size_t
index 660dcf996071c51a8a5b823df5044e109c23d37c..3d22cf40101009f5f65722681f87208a0aa55c25 100644 (file)
@@ -279,6 +279,12 @@ wimlib_printf(const tchar *format, ...) FORMAT(printf, 1, 2);
 extern void
 zap_backslashes(tchar *s);
 
+extern tchar *
+canonicalize_wim_path(const tchar *wim_path);
+
+extern tchar *
+canonicalize_fs_path(const tchar *fs_path);
+
 static inline u64
 hash_u64(u64 n)
 {
index 7a2fad7d8c3c87b595f848db31ba7876307fd39d..c4979458c46a6a362799b1eae24c0767684e4ce2 100644 (file)
@@ -302,6 +302,9 @@ enum wimlib_progress_msg {
         * ::wimlib_progress_info.extract. */
        WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN,
 
+       /** XXX */
+       WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN,
+
        /** The directory structure of the WIM image is about to be extracted.
         * @a info will point to ::wimlib_progress_info.extract. */
        WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_BEGIN,
@@ -328,6 +331,9 @@ enum wimlib_progress_msg {
         * ::wimlib_progress_info.extract. */
        WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END,
 
+       /** XXX */
+       WIMLIB_PROGRESS_MSG_EXTRACT_TREE_END,
+
        /** The directory or NTFS volume is about to be scanned to build a tree
         * of WIM dentries in-memory.  @a info will point to
         * ::wimlib_progress_info.scan. */
@@ -497,6 +503,11 @@ union wimlib_progress_info {
                 * special cases (hard links, symbolic links, and alternate data
                 * streams.) */
                uint64_t num_streams;
+
+               /** Path to the root dentry within the WIM for the tree that is
+                * being extracted.  Will be the empty string when extracting a
+                * full image. */
+               const wimlib_tchar *extract_root_wim_source_path;
        } extract;
 
        /** Valid on messages ::WIMLIB_PROGRESS_MSG_RENAME. */
@@ -767,6 +778,9 @@ struct wimlib_capture_config {
  * WIM_HDR_FLAG_RP_FIX flag in the WIM header. */
 #define WIMLIB_EXTRACT_FLAG_NORPFIX                    0x00000200
 
+/** Ignore the target directory; only extract file data to standard output. */
+#define WIMLIB_EXTRACT_FLAG_TO_STDOUT                  0x00000400
+
 /******************************
  * WIMLIB_MOUNT_FLAG_*        *
  ******************************/
@@ -858,67 +872,38 @@ struct wimlib_capture_config {
  * locale's character encoding. */
 #define WIMLIB_INIT_FLAG_ASSUME_UTF8                   0x00000001
 
-
-#if 0
-/****************************************************************
- * Definition of struct wimlib_modify_command, with various flags
- ****************************************************************/
-
-enum {
-       WIMLIB_MOVE_TREE_FLAG_OVERWRITE_ALL                     = 0x1,
-       WIMLIB_MOVE_TREE_FLAG_OVERWRITE_NONDIRECTORIES          = 0x2,
-       WIMLIB_MOVE_TREE_FLAG_OVERWRITE_EMPTY_DIRECTORIES       = 0x4,
-       WIMLIB_MOVE_TREE_FLAG_OVERWRITE_DIRECTORIES             = 0x8,
-};
-
-enum {
-       WIMLIB_DELETE_TREE_FLAG_FORCE                   = 0x1,
-       WIMLIB_DELETE_TREE_FLAG_RECURSIVE               = 0x2,
-       WIMLIB_DELETE_TREE_FLAG_REMOVE_EMPTY_DIR        = 0x4,
-};
-
-enum {
-       WIMLIB_ADD_TREE_FLAG_DEREFERENCE                = 0x1,
-       WIMLIB_ADD_TREE_FLAG_VERBOSE                    = 0x2,
-       WIMLIB_ADD_TREE_FLAG_UNIX_DATA                  = 0x4,
-       WIMLIB_ADD_TREE_FLAG_NOACLS                     = 0x8,
-       WIMLIB_ADD_TREE_FLAG_NTFS_VOLUME                = 0x01,
-       WIMLIB_ADD_TREE_FLAG_OVERLAY                    = 0x02,
-       WIMLIB_ADD_TREE_FLAG_MAKE_NECESSARY_DIRS        = 0x04,
-};
-
-enum wimlib_modify_op {
-       WIMLIB_MODIFY_OP_DELETE_TREE,
-       WIMLIB_MODIFY_OP_ADD_TREE,
-       WIMLIB_MODIFY_OP_MOVE_TREE,
-};
-
-struct wimlib_modify_command {
-       enum wimlib_modify_op op;
+/** XXX */
+struct wimlib_update_command {
+       enum {
+               WIMLIB_UPDATE_OP_ADD,
+               WIMLIB_UPDATE_OP_DELETE,
+               WIMLIB_UPDATE_OP_MOVE,
+       } op;
        union {
-               struct wimlib_modify_command_delete_tree {
-                       int delete_tree_flags;
-                       const wimlib_tchar *tree_wim_path;
-                       unsigned long reserved;
-               } delete_tree;
-
-               struct wimlib_modify_command_add_tree {
-                       int add_tree_flags;
+               struct {
                        const wimlib_tchar *fs_source_path;
                        const wimlib_tchar *wim_target_path;
-                       unsigned long reserved;
-               } add_tree;
-
-               struct wimlib_modify_command_move_tree {
-                       int move_tree_flags;
+                       const struct wimlib_capture_config *config;
+                       int add_flags;
+               } add;
+               struct {
+                       const wimlib_tchar *path_in_wim;
+                       int delete_flags;
+               } delete;
+               struct {
                        const wimlib_tchar *wim_source_path;
                        const wimlib_tchar *wim_target_path;
-                       unsigned long reserved;
-               } move_tree;
+                       int rename_flags;
+               } rename;
        };
 };
-#endif
 
+/** XXX */
+struct wimlib_extract_command {
+       wimlib_tchar *wim_source_path;
+       wimlib_tchar *fs_dest_path;
+       int extract_flags;
+};
 
 /**
  * Possible values of the error code returned by many functions in wimlib.
@@ -991,6 +976,7 @@ enum wimlib_error_code {
        WIMLIB_ERR_VOLUME_LACKS_FEATURES,
        WIMLIB_ERR_WRITE,
        WIMLIB_ERR_XML,
+       WIMLIB_ERR_PATH_DOES_NOT_EXIST,
 };
 
 
@@ -1302,6 +1288,17 @@ wimlib_export_image(WIMStruct *src_wim, int src_image,
                    unsigned num_additional_swms,
                    wimlib_progress_func_t progress_func);
 
+/** XXX */
+extern int
+wimlib_extract_files(WIMStruct *wim,
+                    int image,
+                    int default_extract_flags,
+                    const struct wimlib_extract_command *cmds,
+                    size_t num_cmds,
+                    WIMStruct **additional_swms,
+                    unsigned num_additional_swms,
+                    wimlib_progress_func_t progress_func);
+
 /**
  * Extracts an image, or all images, from a standalone or split WIM file to a
  * directory or a NTFS volume.
index 82eb42ee90bc131356eb13134b29b58219753c7d..1ddec8e3c84f38fcfdc36c562131fa95eecf50b0 100644 (file)
@@ -539,6 +539,9 @@ write_metadata_resource(WIMStruct *w);
 struct apply_args {
        WIMStruct *w;
        const tchar *target;
+       unsigned target_nchars;
+       unsigned wim_source_path_nchars;
+       struct wim_dentry *extract_root;
        tchar *target_realpath;
        unsigned target_realpath_len;
        int extract_flags;