wimoptimize: Add --no-pack-streams option
[wimlib] / programs / imagex.c
index afcf8de..a9e6fa6 100644 (file)
@@ -49,7 +49,6 @@
 #ifdef __WIN32__
 #  include "imagex-win32.h"
 #  define tbasename    win32_wbasename
-#  define tglob                win32_wglob
 #  define OS_PREFERRED_PATH_SEPARATOR L'\\'
 #  define OS_PREFERRED_PATH_SEPARATOR_STRING L"\\"
 #else /* __WIN32__ */
 #  include <getopt.h>
 #  include <langinfo.h>
 #  define tbasename    basename
-#  define tglob                glob
 #  define OS_PREFERRED_PATH_SEPARATOR '/'
 #  define OS_PREFERRED_PATH_SEPARATOR_STRING "/"
+static inline void set_fd_to_binary_mode(int fd)
+{
+}
 #endif /* !__WIN32 */
 
+/* Don't confuse the user by presenting the mounting commands on Windows when
+ * they will never work.  However on UNIX-like systems we always present them,
+ * even if WITH_FUSE is not defined at this point, as to not tie the build of
+ * wimlib-imagex to a specific build of wimlib.  */
+#ifdef __WIN32__
+#  define WIM_MOUNTING_SUPPORTED 0
+#else
+#  define WIM_MOUNTING_SUPPORTED 1
+#endif
 
 #define ARRAY_LEN(array) (sizeof(array) / sizeof(array[0]))
 
 #define for_opt(c, opts) while ((c = getopt_long_only(argc, (tchar**)argv, T(""), \
                                opts, NULL)) != -1)
 
-enum imagex_op_type {
-       APPEND = 0,
-       APPLY,
-       CAPTURE,
-       DELETE,
-       DIR,
-       EXPORT,
-       EXTRACT,
-       INFO,
-       JOIN,
-       MOUNT,
-       MOUNTRW,
-       OPTIMIZE,
-       SPLIT,
-       UNMOUNT,
-       UPDATE,
+enum {
+       CMD_NONE = -1,
+       CMD_APPEND = 0,
+       CMD_APPLY,
+       CMD_CAPTURE,
+       CMD_DELETE,
+       CMD_DIR,
+       CMD_EXPORT,
+       CMD_EXTRACT,
+       CMD_INFO,
+       CMD_JOIN,
+#if WIM_MOUNTING_SUPPORTED
+       CMD_MOUNT,
+       CMD_MOUNTRW,
+#endif
+       CMD_OPTIMIZE,
+       CMD_SPLIT,
+#if WIM_MOUNTING_SUPPORTED
+       CMD_UNMOUNT,
+#endif
+       CMD_UPDATE,
+       CMD_MAX,
 };
 
-static void usage(int cmd_type);
-static void usage_all(void);
+static void usage(int cmd, FILE *fp);
+static void usage_all(FILE *fp);
+static void recommend_man_page(int cmd, FILE *fp);
+static const tchar *get_cmd_string(int cmd, bool nospace);
 
-static bool imagex_be_quiet = false;
-
-
-static const tchar *usage_strings[] = {
-[APPEND] =
-T(
-IMAGEX_PROGNAME" append (DIRECTORY | NTFS_VOLUME) WIMFILE [IMAGE_NAME]\n"
-"                     [DESCRIPTION] [--boot] [--check] [--flags EDITION_ID]\n"
-"                     [--verbose] [--dereference] [--config=FILE]\n"
-"                     [--threads=NUM_THREADS] [--rebuild] [--unix-data]\n"
-"                     [--source-list] [--no-acls] [--strict-acls]\n"
-"                     [--rpfix] [--norpfix]\n"
-),
-[APPLY] =
-T(
-IMAGEX_PROGNAME" apply WIMFILE [IMAGE_NUM | IMAGE_NAME | all]\n"
-"                    (DIRECTORY | NTFS_VOLUME) [--check] [--hardlink]\n"
-"                    [--symlink] [--verbose] [--ref=\"GLOB\"] [--unix-data]\n"
-"                    [--no-acls] [--strict-acls] [--rpfix] [--norpfix]\n"
-"                    [--include-invalid-names]\n"
-),
-[CAPTURE] =
-T(
-IMAGEX_PROGNAME" capture (DIRECTORY | NTFS_VOLUME) WIMFILE [IMAGE_NAME]\n"
-"                      [DESCRIPTION] [--boot] [--check] [--compress=TYPE]\n"
-"                      [--flags EDITION_ID] [--verbose] [--dereference]\n"
-"                      [--config=FILE] [--threads=NUM_THREADS] [--unix-data]\n"
-"                      [--source-list] [--no-acls] [--strict-acls]\n"
-"                      [--rpfix] [--norpfix]\n"
-),
-[DELETE] =
-T(
-IMAGEX_PROGNAME" delete WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--check] [--soft]\n"
-),
-[DIR] =
-T(
-IMAGEX_PROGNAME" dir WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--path=PATH]\n"
-),
-[EXPORT] =
-T(
-IMAGEX_PROGNAME" export SRC_WIMFILE (SRC_IMAGE_NUM | SRC_IMAGE_NAME | all ) \n"
-"              DEST_WIMFILE [DEST_IMAGE_NAME] [DEST_IMAGE_DESCRIPTION]\n"
-"              [--boot] [--check] [--compress=TYPE] [--ref=\"GLOB\"]\n"
-"              [--threads=NUM_THREADS] [--rebuild]\n"
-),
-[EXTRACT] =
-T(
-IMAGEX_PROGNAME" extract WIMFILE (IMAGE_NUM | IMAGE_NAME) [PATH...]\n"
-"              [--check] [--ref=\"GLOB\"] [--verbose] [--unix-data]\n"
-"              [--no-acls] [--strict-acls] [--to-stdout] [--dest-dir=DIR]\n"
-"              [--include-invalid-names]\n"
-),
-[INFO] =
-T(
-IMAGEX_PROGNAME" info WIMFILE [IMAGE_NUM | IMAGE_NAME] [NEW_NAME]\n"
-"                   [NEW_DESC] [--boot] [--check] [--header] [--lookup-table]\n"
-"                   [--xml] [--extract-xml FILE] [--metadata]\n"
-),
-[JOIN] =
-T(
-IMAGEX_PROGNAME" join [--check] WIMFILE SPLIT_WIM...\n"
-),
-[MOUNT] =
-T(
-IMAGEX_PROGNAME" mount WIMFILE (IMAGE_NUM | IMAGE_NAME) DIRECTORY\n"
-"                    [--check] [--debug] [--streams-interface=INTERFACE]\n"
-"                    [--ref=\"GLOB\"] [--unix-data] [--allow-other]\n"
-),
-[MOUNTRW] =
-T(
-IMAGEX_PROGNAME" mountrw WIMFILE [IMAGE_NUM | IMAGE_NAME] DIRECTORY\n"
-"                      [--check] [--debug] [--streams-interface=INTERFACE]\n"
-"                      [--staging-dir=DIR] [--unix-data] [--allow-other]\n"
-),
-[OPTIMIZE] =
-T(
-IMAGEX_PROGNAME" optimize WIMFILE [--check] [--recompress]\n"
-"                      [--threads=NUM_THREADS]\n"
-),
-[SPLIT] =
-T(
-IMAGEX_PROGNAME" split WIMFILE SPLIT_WIMFILE PART_SIZE_MB [--check]\n"
-),
-[UNMOUNT] =
-T(
-IMAGEX_PROGNAME" unmount DIRECTORY [--commit] [--check] [--rebuild] [--lazy]\n"
-),
-[UPDATE] =
-T(
-IMAGEX_PROGNAME" update WIMFILE [IMAGE_NUM | IMAGE_NAME] [--check] [--rebuild]\n"
-"                       [--threads=NUM_THREADS] [DEFAULT_ADD_OPTIONS]\n"
-"                       [DEFAULT_DELETE_OPTIONS] [--command=STRING] [< CMDFILE]\n"
-),
-};
+static int imagex_progress_func(enum wimlib_progress_msg msg,
+                               const union wimlib_progress_info *info);
 
+static bool imagex_be_quiet = false;
+static FILE *imagex_info_file;
 
-static void
-recommend_man_page(const tchar *cmd_name)
-{
-       const tchar *format_str;
-#ifdef __WIN32__
-       format_str = T("See "IMAGEX_PROGNAME"%"TS"%"TS".pdf in the "
-                      "doc directory for more details.\n");
-#else
-       format_str = T("Try `man "IMAGEX_PROGNAME"%"TS"%"TS"' "
-                      "for more details.\n");
-#endif
-       tprintf(format_str, *cmd_name ? T("-") : T(""), cmd_name);
-}
+#define imagex_printf(format, ...) \
+               tfprintf(imagex_info_file, format, ##__VA_ARGS__)
 
 enum {
        IMAGEX_ALLOW_OTHER_OPTION,
        IMAGEX_BOOT_OPTION,
        IMAGEX_CHECK_OPTION,
+       IMAGEX_CHUNK_SIZE_OPTION,
        IMAGEX_COMMAND_OPTION,
        IMAGEX_COMMIT_OPTION,
        IMAGEX_COMPRESS_OPTION,
+       IMAGEX_COMPRESS_SLOW_OPTION,
        IMAGEX_CONFIG_OPTION,
        IMAGEX_DEBUG_OPTION,
+       IMAGEX_DELTA_FROM_OPTION,
        IMAGEX_DEREFERENCE_OPTION,
        IMAGEX_DEST_DIR_OPTION,
        IMAGEX_EXTRACT_XML_OPTION,
@@ -220,12 +140,18 @@ enum {
        IMAGEX_LOOKUP_TABLE_OPTION,
        IMAGEX_METADATA_OPTION,
        IMAGEX_NORPFIX_OPTION,
+       IMAGEX_NOCHECK_OPTION,
        IMAGEX_NO_ACLS_OPTION,
+       IMAGEX_NO_PACK_STREAMS_OPTION,
+       IMAGEX_NOT_PIPABLE_OPTION,
+       IMAGEX_PACK_STREAMS_OPTION,
        IMAGEX_PATH_OPTION,
+       IMAGEX_PIPABLE_OPTION,
        IMAGEX_REBUILD_OPTION,
        IMAGEX_RECOMPRESS_OPTION,
        IMAGEX_RECURSIVE_OPTION,
        IMAGEX_REF_OPTION,
+       IMAGEX_RESUME_OPTION,
        IMAGEX_RPFIX_OPTION,
        IMAGEX_SOFT_OPTION,
        IMAGEX_SOURCE_LIST_OPTION,
@@ -236,6 +162,7 @@ enum {
        IMAGEX_THREADS_OPTION,
        IMAGEX_TO_STDOUT_OPTION,
        IMAGEX_UNIX_DATA_OPTION,
+       IMAGEX_UPDATE_OF_OPTION,
        IMAGEX_VERBOSE_OPTION,
        IMAGEX_XML_OPTION,
 };
@@ -253,12 +180,21 @@ static const struct option apply_options[] = {
        {T("rpfix"),       no_argument,       NULL, IMAGEX_RPFIX_OPTION},
        {T("norpfix"),     no_argument,       NULL, IMAGEX_NORPFIX_OPTION},
        {T("include-invalid-names"), no_argument,       NULL, IMAGEX_INCLUDE_INVALID_NAMES_OPTION},
+
+       /* --resume is undocumented for now as it needs improvement.  */
+       {T("resume"),      no_argument,       NULL, IMAGEX_RESUME_OPTION},
        {NULL, 0, NULL, 0},
 };
+
 static const struct option capture_or_append_options[] = {
        {T("boot"),        no_argument,       NULL, IMAGEX_BOOT_OPTION},
        {T("check"),       no_argument,       NULL, IMAGEX_CHECK_OPTION},
+       {T("no-check"),    no_argument,       NULL, IMAGEX_NOCHECK_OPTION},
+       {T("nocheck"),     no_argument,       NULL, IMAGEX_NOCHECK_OPTION},
        {T("compress"),    required_argument, NULL, IMAGEX_COMPRESS_OPTION},
+       {T("compress-slow"), no_argument,     NULL, IMAGEX_COMPRESS_SLOW_OPTION},
+       {T("chunk-size"),  required_argument, NULL, IMAGEX_CHUNK_SIZE_OPTION},
+       {T("pack-streams"), no_argument,      NULL, IMAGEX_PACK_STREAMS_OPTION},
        {T("config"),      required_argument, NULL, IMAGEX_CONFIG_OPTION},
        {T("dereference"), no_argument,       NULL, IMAGEX_DEREFERENCE_OPTION},
        {T("flags"),       required_argument, NULL, IMAGEX_FLAGS_OPTION},
@@ -272,8 +208,13 @@ static const struct option capture_or_append_options[] = {
        {T("strict-acls"), no_argument,       NULL, IMAGEX_STRICT_ACLS_OPTION},
        {T("rpfix"),       no_argument,       NULL, IMAGEX_RPFIX_OPTION},
        {T("norpfix"),     no_argument,       NULL, IMAGEX_NORPFIX_OPTION},
+       {T("pipable"),     no_argument,       NULL, IMAGEX_PIPABLE_OPTION},
+       {T("not-pipable"), no_argument,       NULL, IMAGEX_NOT_PIPABLE_OPTION},
+       {T("update-of"),   required_argument, NULL, IMAGEX_UPDATE_OF_OPTION},
+       {T("delta-from"),  required_argument, NULL, IMAGEX_DELTA_FROM_OPTION},
        {NULL, 0, NULL, 0},
 };
+
 static const struct option delete_options[] = {
        {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
        {T("soft"),  no_argument, NULL, IMAGEX_SOFT_OPTION},
@@ -286,12 +227,16 @@ static const struct option dir_options[] = {
 };
 
 static const struct option export_options[] = {
-       {T("boot"),       no_argument,       NULL, IMAGEX_BOOT_OPTION},
-       {T("check"),      no_argument,       NULL, IMAGEX_CHECK_OPTION},
-       {T("compress"),   required_argument, NULL, IMAGEX_COMPRESS_OPTION},
-       {T("ref"),        required_argument, NULL, IMAGEX_REF_OPTION},
-       {T("threads"),    required_argument, NULL, IMAGEX_THREADS_OPTION},
-       {T("rebuild"),    no_argument,       NULL, IMAGEX_REBUILD_OPTION},
+       {T("boot"),        no_argument,       NULL, IMAGEX_BOOT_OPTION},
+       {T("check"),       no_argument,       NULL, IMAGEX_CHECK_OPTION},
+       {T("nocheck"),     no_argument,       NULL, IMAGEX_NOCHECK_OPTION},
+       {T("no-check"),    no_argument,       NULL, IMAGEX_NOCHECK_OPTION},
+       {T("compress"),    required_argument, NULL, IMAGEX_COMPRESS_OPTION},
+       {T("ref"),         required_argument, NULL, IMAGEX_REF_OPTION},
+       {T("threads"),     required_argument, NULL, IMAGEX_THREADS_OPTION},
+       {T("rebuild"),     no_argument,       NULL, IMAGEX_REBUILD_OPTION},
+       {T("pipable"),     no_argument,       NULL, IMAGEX_PIPABLE_OPTION},
+       {T("not-pipable"), no_argument,       NULL, IMAGEX_NOT_PIPABLE_OPTION},
        {NULL, 0, NULL, 0},
 };
 
@@ -312,6 +257,8 @@ static const struct option extract_options[] = {
 static const struct option info_options[] = {
        {T("boot"),         no_argument,       NULL, IMAGEX_BOOT_OPTION},
        {T("check"),        no_argument,       NULL, IMAGEX_CHECK_OPTION},
+       {T("nocheck"),      no_argument,       NULL, IMAGEX_NOCHECK_OPTION},
+       {T("no-check"),     no_argument,       NULL, IMAGEX_NOCHECK_OPTION},
        {T("extract-xml"),  required_argument, NULL, IMAGEX_EXTRACT_XML_OPTION},
        {T("header"),       no_argument,       NULL, IMAGEX_HEADER_OPTION},
        {T("lookup-table"), no_argument,       NULL, IMAGEX_LOOKUP_TABLE_OPTION},
@@ -337,9 +284,19 @@ static const struct option mount_options[] = {
 };
 
 static const struct option optimize_options[] = {
-       {T("check"),      no_argument, NULL, IMAGEX_CHECK_OPTION},
-       {T("recompress"), no_argument, NULL, IMAGEX_RECOMPRESS_OPTION},
-       {T("threads"),    required_argument, NULL, IMAGEX_THREADS_OPTION},
+       {T("check"),       no_argument,       NULL, IMAGEX_CHECK_OPTION},
+       {T("nocheck"),     no_argument,       NULL, IMAGEX_NOCHECK_OPTION},
+       {T("no-check"),    no_argument,       NULL, IMAGEX_NOCHECK_OPTION},
+       {T("compress"),    required_argument, NULL, IMAGEX_COMPRESS_OPTION},
+       {T("recompress"),  no_argument,       NULL, IMAGEX_RECOMPRESS_OPTION},
+       {T("compress-slow"), no_argument,     NULL, IMAGEX_COMPRESS_SLOW_OPTION},
+       {T("recompress-slow"), no_argument,     NULL, IMAGEX_COMPRESS_SLOW_OPTION},
+       {T("chunk-size"),  required_argument, NULL, IMAGEX_CHUNK_SIZE_OPTION},
+       {T("pack-streams"),no_argument,       NULL, IMAGEX_PACK_STREAMS_OPTION},
+       {T("no-pack-streams"), no_argument,   NULL, IMAGEX_NO_PACK_STREAMS_OPTION},
+       {T("threads"),     required_argument, NULL, IMAGEX_THREADS_OPTION},
+       {T("pipable"),     no_argument,       NULL, IMAGEX_PIPABLE_OPTION},
+       {T("not-pipable"), no_argument,       NULL, IMAGEX_NOT_PIPABLE_OPTION},
        {NULL, 0, NULL, 0},
 };
 
@@ -384,7 +341,7 @@ static const struct option update_options[] = {
        {NULL, 0, NULL, 0},
 };
 
-#ifdef __GNUC__
+#if 0
 #      define _format_attribute(type, format_str, args_start) \
                        __attribute__((format(type, format_str, args_start)))
 #else
@@ -422,11 +379,13 @@ verify_image_exists(int image, const tchar *image_name, const tchar *wim_name)
        if (image == WIMLIB_NO_IMAGE) {
                imagex_error(T("\"%"TS"\" is not a valid image in \"%"TS"\"!\n"
                             "       Please specify a 1-based image index or "
-                            "image name.\n"
-                            "       You may use `"IMAGEX_PROGNAME" info' to list the images "
-                            "contained in a WIM."),
-                            image_name, wim_name);
-               return -1;
+                            "image name.  To list the images\n"
+                            "       contained in the WIM archive, run\n"
+                            "\n"
+                            "           %"TS" \"%"TS"\"\n"),
+                            image_name, wim_name,
+                            get_cmd_string(CMD_INFO, false), wim_name);
+               return WIMLIB_ERR_INVALID_IMAGE;
        }
        return 0;
 }
@@ -436,7 +395,7 @@ verify_image_is_single(int image)
 {
        if (image == WIMLIB_ALL_IMAGES) {
                imagex_error(T("Cannot specify all images for this action!"));
-               return -1;
+               return WIMLIB_ERR_INVALID_IMAGE;
        }
        return 0;
 }
@@ -460,6 +419,8 @@ get_compression_type(const tchar *optarg)
                return WIMLIB_COMPRESSION_TYPE_LZX;
        else if (!tstrcasecmp(optarg, T("fast")) || !tstrcasecmp(optarg, T("xpress")))
                return WIMLIB_COMPRESSION_TYPE_XPRESS;
+       else if (!tstrcasecmp(optarg, T("recovery")) || !tstrcasecmp(optarg, T("lzms")))
+               return WIMLIB_COMPRESSION_TYPE_LZMS;
        else if (!tstrcasecmp(optarg, T("none")))
                return WIMLIB_COMPRESSION_TYPE_NONE;
        else {
@@ -469,6 +430,103 @@ get_compression_type(const tchar *optarg)
        }
 }
 
+static int
+set_compress_slow(void)
+{
+       int ret;
+       static const struct wimlib_lzx_params slow_params = {
+               .size_of_this = sizeof(struct wimlib_lzx_params),
+               .algorithm = WIMLIB_LZX_ALGORITHM_SLOW,
+               .alg_params = {
+                       .slow = {
+                               .use_len2_matches = 1,
+                               .num_fast_bytes = 96,
+                               .num_optim_passes = 4,
+                               .max_search_depth = 100,
+                               .max_matches_per_pos = 10,
+                               .main_nostat_cost = 15,
+                               .len_nostat_cost = 15,
+                               .aligned_nostat_cost = 7,
+                       },
+               },
+       };
+       ret = wimlib_lzx_set_default_params(&slow_params);
+       if (ret)
+               imagex_error(T("Couldn't set slow compression parameters.!"));
+       return ret;
+}
+
+struct string_set {
+       const tchar **strings;
+       unsigned num_strings;
+       unsigned num_alloc_strings;
+};
+
+#define STRING_SET_INITIALIZER \
+       { .strings = NULL, .num_strings = 0, .num_alloc_strings = 0, }
+
+#define STRING_SET(_strings) \
+       struct string_set _strings = STRING_SET_INITIALIZER
+
+static int
+string_set_append(struct string_set *set, const tchar *glob)
+{
+       unsigned num_alloc_strings = set->num_alloc_strings;
+
+       if (set->num_strings == num_alloc_strings) {
+               const tchar **new_strings;
+
+               num_alloc_strings += 4;
+               new_strings = realloc(set->strings,
+                                     sizeof(set->strings[0]) * num_alloc_strings);
+               if (!new_strings) {
+                       imagex_error(T("Out of memory!"));
+                       return -1;
+               }
+               set->strings = new_strings;
+               set->num_alloc_strings = num_alloc_strings;
+       }
+       set->strings[set->num_strings++] = glob;
+       return 0;
+}
+
+static void
+string_set_destroy(struct string_set *set)
+{
+       free(set->strings);
+}
+
+static int
+wim_reference_globs(WIMStruct *wim, struct string_set *set, int open_flags)
+{
+       return wimlib_reference_resource_files(wim, set->strings,
+                                              set->num_strings,
+                                              WIMLIB_REF_FLAG_GLOB_ENABLE,
+                                              open_flags,
+                                              imagex_progress_func);
+}
+
+static void
+do_resource_not_found_warning(const tchar *wimfile,
+                             const struct wimlib_wim_info *info,
+                             const struct string_set *refglobs)
+{
+       if (info->total_parts > 1) {
+               if (refglobs->num_strings == 0) {
+                       imagex_error(T("\"%"TS"\" is part of a split WIM. "
+                                      "Use --ref to specify the other parts."),
+                                    wimfile);
+               } else {
+                       imagex_error(T("Perhaps the '--ref' argument did not "
+                                      "specify all other parts of the split "
+                                      "WIM?"));
+               }
+       } else {
+               imagex_error(T("If this is a delta WIM, use the --ref argument "
+                              "to specify the WIM(s) on which it is based."));
+       }
+}
+
 /* Returns the size of a file given its name, or -1 if the file does not exist
  * or its size cannot be determined.  */
 static off_t
@@ -481,29 +539,6 @@ file_get_size(const tchar *filename)
                return (off_t)-1;
 }
 
-tchar pat_ntfs_log[]                  = T("/$ntfs.log");
-tchar pat_hiberfil_sys[]              = T("/hiberfil.sys");
-tchar pat_pagefile_sys[]              = T("/pagefile.sys");
-tchar pat_system_volume_information[] = T("/System Volume Information");
-tchar pat_recycler[]                  = T("/RECYCLER");
-tchar pat_windows_csc[]               = T("/Windows/CSC");
-
-tchar *default_pats[] = {
-       pat_ntfs_log,
-       pat_hiberfil_sys,
-       pat_pagefile_sys,
-       pat_system_volume_information,
-       pat_recycler,
-       pat_windows_csc,
-};
-
-static struct wimlib_capture_config default_capture_config = {
-       .exclusion_pats = {
-               .num_pats = sizeof(default_pats) / sizeof(default_pats[0]),
-               .pats = default_pats,
-       },
-};
-
 enum {
        PARSE_STRING_SUCCESS = 0,
        PARSE_STRING_FAILURE = 1,
@@ -945,8 +980,8 @@ translate_text_to_tstr(char *text, size_t num_bytes, size_t *num_tchars_ret)
        size_t num_wchars;
 
        if (num_bytes >= 2 &&
-           ((text[0] == 0xff && text[1] == 0xfe) ||
-            (text[0] <= 0x7f && text[1] == 0x00)))
+           (((unsigned char)text[0] == 0xff && (unsigned char)text[1] == 0xfe) ||
+            ((unsigned char)text[0] <= 0x7f && (unsigned char)text[1] == 0x00)))
        {
                /* File begins with 0xfeff, the BOM for UTF-16LE, or it begins
                 * with something that looks like an ASCII character encoded as
@@ -996,22 +1031,6 @@ stdin_get_text_contents(size_t *num_tchars_ret)
 #define TO_PERCENT(numerator, denominator) \
        (((denominator) == 0) ? 0 : ((numerator) * 100 / (denominator)))
 
-/* Given an enumerated value for WIM compression type, return a descriptive
- * string. */
-static const tchar *
-get_data_type(int ctype)
-{
-       switch (ctype) {
-       case WIMLIB_COMPRESSION_TYPE_NONE:
-               return T("uncompressed");
-       case WIMLIB_COMPRESSION_TYPE_LZX:
-               return T("LZX-compressed");
-       case WIMLIB_COMPRESSION_TYPE_XPRESS:
-               return T("XPRESS-compressed");
-       }
-       return NULL;
-}
-
 #define GIBIBYTE_MIN_NBYTES 10000000000ULL
 #define MEBIBYTE_MIN_NBYTES 10000000ULL
 #define KIBIBYTE_MIN_NBYTES 10000ULL
@@ -1049,47 +1068,67 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                unit_shift = get_unit(info->write_streams.total_bytes, &unit_name);
                percent_done = TO_PERCENT(info->write_streams.completed_bytes,
                                          info->write_streams.total_bytes);
-               if (info->write_streams.completed_streams == 0) {
-                       const tchar *data_type;
 
-                       data_type = get_data_type(info->write_streams.compression_type);
-                       tprintf(T("Writing %"TS" data using %u thread%"TS"\n"),
-                               data_type, info->write_streams.num_threads,
+               if (info->write_streams.completed_streams == 0) {
+                       imagex_printf(T("Writing %"TS"-compressed data using %u thread%"TS"\n"),
+                               wimlib_get_compression_type_string(info->write_streams.compression_type),
+                               info->write_streams.num_threads,
                                (info->write_streams.num_threads == 1) ? T("") : T("s"));
                }
-               tprintf(T("\r%"PRIu64" %"TS" of %"PRIu64" %"TS" (uncompressed) "
-                       "written (%u%% done)"),
-                       info->write_streams.completed_bytes >> unit_shift,
-                       unit_name,
-                       info->write_streams.total_bytes >> unit_shift,
-                       unit_name,
-                       percent_done);
+               if (info->write_streams.total_parts <= 1) {
+                       imagex_printf(T("\r%"PRIu64" %"TS" of %"PRIu64" %"TS" (uncompressed) "
+                               "written (%u%% done)"),
+                               info->write_streams.completed_bytes >> unit_shift,
+                               unit_name,
+                               info->write_streams.total_bytes >> unit_shift,
+                               unit_name,
+                               percent_done);
+               } else {
+                       imagex_printf(T("\rWriting resources from part %u of %u: "
+                                 "%"PRIu64 " %"TS" of %"PRIu64" %"TS" (%u%%) written"),
+                               (info->write_streams.completed_parts ==
+                                       info->write_streams.total_parts) ?
+                                               info->write_streams.completed_parts :
+                                               info->write_streams.completed_parts + 1,
+                               info->write_streams.total_parts,
+                               info->write_streams.completed_bytes >> unit_shift,
+                               unit_name,
+                               info->write_streams.total_bytes >> unit_shift,
+                               unit_name,
+                               percent_done);
+               }
                if (info->write_streams.completed_bytes >= info->write_streams.total_bytes)
-                       tputchar(T('\n'));
+                       imagex_printf(T("\n"));
                break;
        case WIMLIB_PROGRESS_MSG_SCAN_BEGIN:
-               tprintf(T("Scanning \"%"TS"\""), info->scan.source);
+               imagex_printf(T("Scanning \"%"TS"\""), info->scan.source);
                if (*info->scan.wim_target_path) {
-                       tprintf(T(" (loading as WIM path: "
+                       imagex_printf(T(" (loading as WIM path: "
                                  "\""WIMLIB_WIM_PATH_SEPARATOR_STRING"%"TS"\")...\n"),
                               info->scan.wim_target_path);
                } else {
-                       tprintf(T(" (loading as root of WIM image)...\n"));
+                       imagex_printf(T(" (loading as root of WIM image)...\n"));
                }
                break;
        case WIMLIB_PROGRESS_MSG_SCAN_DENTRY:
-               if (info->scan.excluded)
-                       tprintf(T("Excluding \"%"TS"\" from capture\n"), info->scan.cur_path);
-               else
-                       tprintf(T("Scanning \"%"TS"\"\n"), info->scan.cur_path);
+               switch (info->scan.status) {
+               case WIMLIB_SCAN_DENTRY_OK:
+                       imagex_printf(T("Scanning \"%"TS"\"\n"), info->scan.cur_path);
+                       break;
+               case WIMLIB_SCAN_DENTRY_EXCLUDED:
+                       imagex_printf(T("Excluding \"%"TS"\" from capture\n"), info->scan.cur_path);
+                       break;
+               case WIMLIB_SCAN_DENTRY_UNSUPPORTED:
+                       imagex_printf(T("WARNING: Excluding unsupported file or directory\n"
+                                       "         \"%"TS"\" from capture\n"), info->scan.cur_path);
+                       break;
+               }
                break;
-       /*case WIMLIB_PROGRESS_MSG_SCAN_END:*/
-               /*break;*/
        case WIMLIB_PROGRESS_MSG_VERIFY_INTEGRITY:
                unit_shift = get_unit(info->integrity.total_bytes, &unit_name);
                percent_done = TO_PERCENT(info->integrity.completed_bytes,
                                          info->integrity.total_bytes);
-               tprintf(T("\rVerifying integrity of \"%"TS"\": %"PRIu64" %"TS" "
+               imagex_printf(T("\rVerifying integrity of \"%"TS"\": %"PRIu64" %"TS" "
                        "of %"PRIu64" %"TS" (%u%%) done"),
                        info->integrity.filename,
                        info->integrity.completed_bytes >> unit_shift,
@@ -1098,13 +1137,13 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                        unit_name,
                        percent_done);
                if (info->integrity.completed_bytes == info->integrity.total_bytes)
-                       tputchar(T('\n'));
+                       imagex_printf(T("\n"));
                break;
        case WIMLIB_PROGRESS_MSG_CALC_INTEGRITY:
                unit_shift = get_unit(info->integrity.total_bytes, &unit_name);
                percent_done = TO_PERCENT(info->integrity.completed_bytes,
                                          info->integrity.total_bytes);
-               tprintf(T("\rCalculating integrity table for WIM: %"PRIu64" %"TS" "
+               imagex_printf(T("\rCalculating integrity table for WIM: %"PRIu64" %"TS" "
                          "of %"PRIu64" %"TS" (%u%%) done"),
                        info->integrity.completed_bytes >> unit_shift,
                        unit_name,
@@ -1112,10 +1151,10 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                        unit_name,
                        percent_done);
                if (info->integrity.completed_bytes == info->integrity.total_bytes)
-                       tputchar(T('\n'));
+                       imagex_printf(T("\n"));
                break;
        case WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN:
-               tprintf(T("Applying image %d (\"%"TS"\") from \"%"TS"\" "
+               imagex_printf(T("Applying image %d (\"%"TS"\") from \"%"TS"\" "
                          "to %"TS" \"%"TS"\"\n"),
                        info->extract.image,
                        info->extract.image_name,
@@ -1125,7 +1164,7 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                        info->extract.target);
                break;
        case WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN:
-               tprintf(T("Extracting "
+               imagex_printf(T("Extracting "
                          "\""WIMLIB_WIM_PATH_SEPARATOR_STRING"%"TS"\" from image %d (\"%"TS"\") "
                          "in \"%"TS"\" to \"%"TS"\"\n"),
                        info->extract.extract_root_wim_source_path,
@@ -1134,15 +1173,11 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                        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);*/
-               /*break;*/
        case WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS:
                percent_done = TO_PERCENT(info->extract.completed_bytes,
                                          info->extract.total_bytes);
                unit_shift = get_unit(info->extract.total_bytes, &unit_name);
-               tprintf(T("\rExtracting files: "
+               imagex_printf(T("\rExtracting files: "
                          "%"PRIu64" %"TS" of %"PRIu64" %"TS" (%u%%) done"),
                        info->extract.completed_bytes >> unit_shift,
                        unit_name,
@@ -1150,43 +1185,34 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                        unit_name,
                        percent_done);
                if (info->extract.completed_bytes >= info->extract.total_bytes)
-                       tputchar(T('\n'));
+                       imagex_printf(T("\n"));
                break;
-       case WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY:
-               tprintf(T("%"TS"\n"), info->extract.cur_path);
+       case WIMLIB_PROGRESS_MSG_EXTRACT_SPWM_PART_BEGIN:
+               if (info->extract.total_parts != 1) {
+                       imagex_printf(T("\nReading split pipable WIM part %u of %u\n"),
+                                     info->extract.part_number,
+                                     info->extract.total_parts);
+               }
                break;
        case WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS:
                if (info->extract.extract_root_wim_source_path[0] == T('\0'))
-                       tprintf(T("Setting timestamps on all extracted files...\n"));
+                       imagex_printf(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) {
-                       tprintf(T("Unmounting NTFS volume \"%"TS"\"...\n"),
+                       imagex_printf(T("Unmounting NTFS volume \"%"TS"\"...\n"),
                                info->extract.target);
                }
                break;
-       case WIMLIB_PROGRESS_MSG_JOIN_STREAMS:
-               percent_done = TO_PERCENT(info->join.completed_bytes,
-                                         info->join.total_bytes);
-               unit_shift = get_unit(info->join.total_bytes, &unit_name);
-               tprintf(T("Writing resources from part %u of %u: "
-                         "%"PRIu64 " %"TS" of %"PRIu64" %"TS" (%u%%) written\n"),
-                       (info->join.completed_parts == info->join.total_parts) ?
-                       info->join.completed_parts : info->join.completed_parts + 1,
-                       info->join.total_parts,
-                       info->join.completed_bytes >> unit_shift,
-                       unit_name,
-                       info->join.total_bytes >> unit_shift,
-                       unit_name,
-                       percent_done);
-               break;
        case WIMLIB_PROGRESS_MSG_SPLIT_BEGIN_PART:
                percent_done = TO_PERCENT(info->split.completed_bytes,
                                          info->split.total_bytes);
                unit_shift = get_unit(info->split.total_bytes, &unit_name);
-               tprintf(T("Writing \"%"TS"\": %"PRIu64" %"TS" of "
+               imagex_printf(T("Writing \"%"TS"\" (part %u of %u): %"PRIu64" %"TS" of "
                          "%"PRIu64" %"TS" (%u%%) written\n"),
                        info->split.part_name,
+                       info->split.cur_part_number,
+                       info->split.total_parts,
                        info->split.completed_bytes >> unit_shift,
                        unit_name,
                        info->split.total_bytes >> unit_shift,
@@ -1195,19 +1221,20 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                break;
        case WIMLIB_PROGRESS_MSG_SPLIT_END_PART:
                if (info->split.completed_bytes == info->split.total_bytes) {
-                       tprintf(T("Finished writing %u split WIM parts\n"),
-                               info->split.cur_part_number);
+                       imagex_printf(T("Finished writing split WIM part %u of %u\n"),
+                               info->split.cur_part_number,
+                               info->split.total_parts);
                }
                break;
        case WIMLIB_PROGRESS_MSG_UPDATE_END_COMMAND:
                switch (info->update.command->op) {
                case WIMLIB_UPDATE_OP_DELETE:
-                       tprintf(T("Deleted WIM path "
+                       imagex_printf(T("Deleted WIM path "
                                  "\""WIMLIB_WIM_PATH_SEPARATOR_STRING "%"TS"\"\n"),
-                               info->update.command->delete.wim_path);
+                               info->update.command->delete_.wim_path);
                        break;
                case WIMLIB_UPDATE_OP_RENAME:
-                       tprintf(T("Renamed WIM path "
+                       imagex_printf(T("Renamed WIM path "
                                  "\""WIMLIB_WIM_PATH_SEPARATOR_STRING "%"TS"\" => "
                                  "\""WIMLIB_WIM_PATH_SEPARATOR_STRING "%"TS"\"\n"),
                                info->update.command->rename.wim_source_path,
@@ -1221,74 +1248,10 @@ imagex_progress_func(enum wimlib_progress_msg msg,
        default:
                break;
        }
-       fflush(stdout);
+       fflush(imagex_info_file);
        return 0;
 }
 
-/* Open all the split WIM parts that correspond to a file glob.
- *
- * @first_part specifies the first part of the split WIM and it may be either
- * included or omitted from the glob. */
-static int
-open_swms_from_glob(const tchar *swm_glob,
-                   const tchar *first_part,
-                   int open_flags,
-                   WIMStruct ***additional_swms_ret,
-                   unsigned *num_additional_swms_ret)
-{
-       unsigned num_additional_swms = 0;
-       WIMStruct **additional_swms = NULL;
-       glob_t globbuf;
-       int ret;
-
-       /* Warning: glob() is replaced in Windows native builds */
-       ret = tglob(swm_glob, GLOB_ERR | GLOB_NOSORT, NULL, &globbuf);
-       if (ret) {
-               if (ret == GLOB_NOMATCH) {
-                       imagex_error(T("Found no files for glob \"%"TS"\""),
-                                    swm_glob);
-               } else {
-                       imagex_error_with_errno(T("Failed to process glob \"%"TS"\""),
-                                               swm_glob);
-               }
-               ret = -1;
-               goto out;
-       }
-       num_additional_swms = globbuf.gl_pathc;
-       additional_swms = calloc(num_additional_swms, sizeof(additional_swms[0]));
-       if (!additional_swms) {
-               imagex_error(T("Out of memory"));
-               ret = -1;
-               goto out_globfree;
-       }
-       unsigned offset = 0;
-       for (unsigned i = 0; i < num_additional_swms; i++) {
-               if (tstrcmp(globbuf.gl_pathv[i], first_part) == 0) {
-                       offset++;
-                       continue;
-               }
-               ret = wimlib_open_wim(globbuf.gl_pathv[i],
-                                     open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK,
-                                     &additional_swms[i - offset],
-                                     imagex_progress_func);
-               if (ret)
-                       goto out_close_swms;
-       }
-       *additional_swms_ret = additional_swms;
-       *num_additional_swms_ret = num_additional_swms - offset;
-       ret = 0;
-       goto out_globfree;
-out_close_swms:
-       for (unsigned i = 0; i < num_additional_swms; i++)
-               wimlib_free(additional_swms[i]);
-       free(additional_swms);
-out_globfree:
-       globfree(&globbuf);
-out:
-       return ret;
-}
-
-
 static unsigned
 parse_num_threads(const tchar *optarg)
 {
@@ -1302,6 +1265,19 @@ parse_num_threads(const tchar *optarg)
        }
 }
 
+static uint32_t parse_chunk_size(const tchar *optarg)
+{
+       tchar *tmp;
+       unsigned long chunk_size = tstrtoul(optarg, &tmp, 10);
+       if (chunk_size >= UINT32_MAX || *tmp || tmp == optarg) {
+               imagex_error(T("Chunk size must be a non-negative integer!"));
+               return UINT32_MAX;
+       } else {
+               return chunk_size;
+       }
+}
+
+
 /*
  * Parse an option passed to an update command.
  *
@@ -1323,23 +1299,23 @@ update_command_add_option(int op, const tchar *option,
        switch (op) {
        case WIMLIB_UPDATE_OP_ADD:
                if (!tstrcmp(option, T("--verbose")))
-                       cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
+                       cmd->add.add_flags |= WIMLIB_ADD_FLAG_VERBOSE;
                else if (!tstrcmp(option, T("--unix-data")))
-                       cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA;
+                       cmd->add.add_flags |= WIMLIB_ADD_FLAG_UNIX_DATA;
                else if (!tstrcmp(option, T("--no-acls")) || !tstrcmp(option, T("--noacls")))
-                       cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_NO_ACLS;
+                       cmd->add.add_flags |= WIMLIB_ADD_FLAG_NO_ACLS;
                else if (!tstrcmp(option, T("--strict-acls")))
-                       cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_STRICT_ACLS;
+                       cmd->add.add_flags |= WIMLIB_ADD_FLAG_STRICT_ACLS;
                else if (!tstrcmp(option, T("--dereference")))
-                       cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
+                       cmd->add.add_flags |= WIMLIB_ADD_FLAG_DEREFERENCE;
                else
                        recognized = false;
                break;
        case WIMLIB_UPDATE_OP_DELETE:
                if (!tstrcmp(option, T("--force")))
-                       cmd->delete.delete_flags |= WIMLIB_DELETE_FLAG_FORCE;
+                       cmd->delete_.delete_flags |= WIMLIB_DELETE_FLAG_FORCE;
                else if (!tstrcmp(option, T("--recursive")))
-                       cmd->delete.delete_flags |= WIMLIB_DELETE_FLAG_RECURSIVE;
+                       cmd->delete_.delete_flags |= WIMLIB_DELETE_FLAG_RECURSIVE;
                else
                        recognized = false;
                break;
@@ -1370,7 +1346,7 @@ update_command_add_nonoption(int op, const tchar *nonoption,
                        cmd->add.wim_target_path = (tchar*)nonoption;
                break;
        case WIMLIB_UPDATE_OP_DELETE:
-               cmd->delete.wim_path = (tchar*)nonoption;
+               cmd->delete_.wim_path = (tchar*)nonoption;
                break;
        case WIMLIB_UPDATE_OP_RENAME:
                if (num_nonoptions == 0)
@@ -1511,22 +1487,22 @@ parse_update_command_file(tchar **cmd_file_contents_p, size_t cmd_file_nchars,
 }
 
 /* Apply one image, or all images, from a WIM file into a directory, OR apply
- * one image from a WIM file to a NTFS volume. */
+ * one image from a WIM file to a NTFS volume.  */
 static int
-imagex_apply(int argc, tchar **argv)
+imagex_apply(int argc, tchar **argv, int cmd)
 {
        int c;
-       int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
-       int image;
+       int open_flags = 0;
+       int image = WIMLIB_NO_IMAGE;
        WIMStruct *wim;
+       struct wimlib_wim_info info;
        int ret;
        const tchar *wimfile;
        const tchar *target;
+       const tchar *image_num_or_name = NULL;
        int extract_flags = WIMLIB_EXTRACT_FLAG_SEQUENTIAL;
 
-       const tchar *swm_glob = NULL;
-       WIMStruct **additional_swms;
-       unsigned num_additional_swms;
+       STRING_SET(refglobs);
 
        for_opt(c, apply_options) {
                switch (c) {
@@ -1543,7 +1519,9 @@ imagex_apply(int argc, tchar **argv)
                        extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
                        break;
                case IMAGEX_REF_OPTION:
-                       swm_glob = optarg;
+                       ret = string_set_append(&refglobs, optarg);
+                       if (ret)
+                               goto out_free_refglobs;
                        break;
                case IMAGEX_UNIX_DATA_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_UNIX_DATA;
@@ -1564,6 +1542,9 @@ imagex_apply(int argc, tchar **argv)
                        extract_flags |= WIMLIB_EXTRACT_FLAG_REPLACE_INVALID_FILENAMES;
                        extract_flags |= WIMLIB_EXTRACT_FLAG_ALL_CASE_CONFLICTS;
                        break;
+               case IMAGEX_RESUME_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_RESUME;
+                       break;
                default:
                        goto out_usage;
                }
@@ -1575,46 +1556,59 @@ imagex_apply(int argc, tchar **argv)
 
        wimfile = argv[0];
 
-       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
-       if (ret)
-               goto out;
-
-       if (argc >= 3) {
-               /* Image explicitly specified.  */
-               image = wimlib_resolve_image(wim, argv[1]);
-               ret = verify_image_exists(image, argv[1], wimfile);
-               if (ret)
-                       goto out_wimlib_free;
-               target = argv[2];
+       if (!tstrcmp(wimfile, T("-"))) {
+               /* Attempt to apply pipable WIM from standard input.  */
+               if (argc == 2) {
+                       image_num_or_name = NULL;
+                       target = argv[1];
+               } else {
+                       image_num_or_name = argv[1];
+                       target = argv[2];
+               }
+               wim = NULL;
        } else {
-               /* No image specified; default to image 1, but only if the WIM
-                * contains exactly one image.  */
-               struct wimlib_wim_info info;
+               ret = wimlib_open_wim(wimfile, open_flags, &wim,
+                                     imagex_progress_func);
+               if (ret)
+                       goto out_free_refglobs;
 
                wimlib_get_wim_info(wim, &info);
-               if (info.image_count != 1) {
-                       imagex_error(T("\"%"TS"\" contains %d images; "
-                                      "Please select one (or all)."),
-                                    wimfile, info.image_count);
-                       wimlib_free(wim);
-                       goto out_usage;
+
+               if (argc >= 3) {
+                       /* Image explicitly specified.  */
+                       image_num_or_name = argv[1];
+                       image = wimlib_resolve_image(wim, image_num_or_name);
+                       ret = verify_image_exists(image, image_num_or_name, wimfile);
+                       if (ret)
+                               goto out_wimlib_free;
+                       target = argv[2];
+               } else {
+                       /* No image specified; default to image 1, but only if the WIM
+                        * contains exactly one image.  */
+
+                       if (info.image_count != 1) {
+                               imagex_error(T("\"%"TS"\" contains %d images; "
+                                              "Please select one (or all)."),
+                                            wimfile, info.image_count);
+                               wimlib_free(wim);
+                               goto out_usage;
+                       }
+                       image = 1;
+                       target = argv[1];
                }
-               image = 1;
-               target = argv[1];
        }
 
-       if (swm_glob) {
-               ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
-                                         &additional_swms,
-                                         &num_additional_swms);
+       if (refglobs.num_strings) {
+               if (wim == NULL) {
+                       imagex_error(T("Can't specify --ref when applying from stdin!"));
+                       ret = -1;
+                       goto out_wimlib_free;
+               }
+               ret = wim_reference_globs(wim, &refglobs, open_flags);
                if (ret)
                        goto out_wimlib_free;
-       } else {
-               additional_swms = NULL;
-               num_additional_swms = 0;
        }
 
-
 #ifndef __WIN32__
        {
                /* Interpret a regular file or block device target as a NTFS
@@ -1626,7 +1620,7 @@ imagex_apply(int argc, tchar **argv)
                                imagex_error_with_errno(T("Failed to stat \"%"TS"\""),
                                                        target);
                                ret = -1;
-                               goto out_free_swms;
+                               goto out_wimlib_free;
                        }
                } else {
                        if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode))
@@ -1635,32 +1629,38 @@ imagex_apply(int argc, tchar **argv)
        }
 #endif
 
-#ifdef __WIN32__
-       win32_acquire_restore_privileges();
-#endif
-       ret = wimlib_extract_image(wim, image, target, extract_flags,
-                                  additional_swms, num_additional_swms,
-                                  imagex_progress_func);
-       if (ret == 0)
-               tprintf(T("Done applying WIM image.\n"));
-#ifdef __WIN32__
-       win32_release_restore_privileges();
-#endif
-out_free_swms:
-       if (swm_glob) {
-               for (unsigned i = 0; i < num_additional_swms; i++)
-                       wimlib_free(additional_swms[i]);
-               free(additional_swms);
+       if (wim) {
+               ret = wimlib_extract_image(wim, image, target, extract_flags,
+                                          imagex_progress_func);
+       } else {
+               set_fd_to_binary_mode(STDIN_FILENO);
+               ret = wimlib_extract_image_from_pipe(STDIN_FILENO,
+                                                    image_num_or_name,
+                                                    target, extract_flags,
+                                                    imagex_progress_func);
+       }
+       if (ret == 0) {
+               imagex_printf(T("Done applying WIM image.\n"));
+       } else if (ret == WIMLIB_ERR_RESOURCE_NOT_FOUND) {
+               if (wim) {
+                       do_resource_not_found_warning(wimfile, &info, &refglobs);
+               } else {
+                       imagex_error(T(        "If you are applying an image "
+                                              "from a split pipable WIM,\n"
+                                      "       make sure you have "
+                                      "concatenated together all parts."));
+               }
        }
 out_wimlib_free:
        wimlib_free(wim);
-out:
+out_free_refglobs:
+       string_set_destroy(&refglobs);
        return ret;
 
 out_usage:
-       usage(APPLY);
+       usage(CMD_APPLY, stderr);
        ret = -1;
-       goto out;
+       goto out_free_refglobs;
 }
 
 /* Create a WIM image from a directory tree, NTFS volume, or multiple files or
@@ -1668,20 +1668,31 @@ out_usage:
  * the desired image.  'wimlib-imagex append': add a new image to an existing
  * WIM file. */
 static int
-imagex_capture_or_append(int argc, tchar **argv)
+imagex_capture_or_append(int argc, tchar **argv, int cmd)
 {
        int c;
        int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
-       int add_image_flags = WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE;
+       int add_image_flags = WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE |
+                             WIMLIB_ADD_IMAGE_FLAG_WINCONFIG;
        int write_flags = 0;
-       int compression_type = WIMLIB_COMPRESSION_TYPE_XPRESS;
+       int compression_type = WIMLIB_COMPRESSION_TYPE_INVALID;
+       uint32_t chunk_size = UINT32_MAX;
        const tchar *wimfile;
+       int wim_fd;
        const tchar *name;
        const tchar *desc;
        const tchar *flags_element = NULL;
+
        WIMStruct *wim;
+       STRING_SET(base_wimfiles);
+       WIMStruct **base_wims;
+
+       WIMStruct *template_wim;
+       const tchar *template_wimfile = NULL;
+       const tchar *template_image_name_or_num = NULL;
+       int template_image = WIMLIB_NO_IMAGE;
+
        int ret;
-       int cmd = tstrcmp(argv[0], T("append")) ? CAPTURE : APPEND;
        unsigned num_threads = 0;
 
        tchar *source;
@@ -1692,7 +1703,7 @@ imagex_capture_or_append(int argc, tchar **argv)
        struct wimlib_capture_config *config;
 
        bool source_list = false;
-       size_t source_list_nchars;
+       size_t source_list_nchars = 0;
        tchar *source_list_contents;
        bool capture_sources_malloced;
        struct wimlib_capture_source *capture_sources;
@@ -1708,14 +1719,32 @@ imagex_capture_or_append(int argc, tchar **argv)
                        open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
                        write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
                        break;
+               case IMAGEX_NOCHECK_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY;
+                       break;
                case IMAGEX_CONFIG_OPTION:
                        config_file = optarg;
+                       add_image_flags &= ~WIMLIB_ADD_IMAGE_FLAG_WINCONFIG;
                        break;
                case IMAGEX_COMPRESS_OPTION:
                        compression_type = get_compression_type(optarg);
                        if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID)
                                goto out_err;
                        break;
+               case IMAGEX_COMPRESS_SLOW_OPTION:
+                       ret = set_compress_slow();
+                       if (ret)
+                               goto out_err;
+                       compression_type = WIMLIB_COMPRESSION_TYPE_LZX;
+                       break;
+               case IMAGEX_CHUNK_SIZE_OPTION:
+                       chunk_size = parse_chunk_size(optarg);
+                       if (chunk_size == UINT32_MAX)
+                               goto out_err;
+                       break;
+               case IMAGEX_PACK_STREAMS_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_PACK_STREAMS;
+                       break;
                case IMAGEX_FLAGS_OPTION:
                        flags_element = optarg;
                        break;
@@ -1751,6 +1780,42 @@ imagex_capture_or_append(int argc, tchar **argv)
                case IMAGEX_NORPFIX_OPTION:
                        add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_NORPFIX;
                        break;
+               case IMAGEX_PIPABLE_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_PIPABLE;
+                       break;
+               case IMAGEX_NOT_PIPABLE_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NOT_PIPABLE;
+                       break;
+               case IMAGEX_UPDATE_OF_OPTION:
+                       if (template_image_name_or_num) {
+                               imagex_error(T("'--update-of' can only be "
+                                              "specified one time!"));
+                               goto out_err;
+                       } else {
+                               tchar *colon;
+                               colon = tstrrchr(optarg, T(':'));
+
+                               if (colon) {
+                                       template_wimfile = optarg;
+                                       *colon = T('\0');
+                                       template_image_name_or_num = colon + 1;
+                               } else {
+                                       template_wimfile = NULL;
+                                       template_image_name_or_num = optarg;
+                               }
+                       }
+                       break;
+               case IMAGEX_DELTA_FROM_OPTION:
+                       if (cmd != CMD_CAPTURE) {
+                               imagex_error(T("'--delta-from' is only "
+                                              "valid for capture!"));
+                               goto out_usage;
+                       }
+                       ret = string_set_append(&base_wimfiles, optarg);
+                       if (ret)
+                               goto out_free_base_wimfiles;
+                       write_flags |= WIMLIB_WRITE_FLAG_SKIP_EXTERNAL_WIMS;
+                       break;
                default:
                        goto out_usage;
                }
@@ -1764,6 +1829,71 @@ imagex_capture_or_append(int argc, tchar **argv)
        source = argv[0];
        wimfile = argv[1];
 
+       /* Set default compression type.  */
+       if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID) {
+               struct wimlib_lzx_params params;
+               memset(&params, 0, sizeof(params));
+               params.size_of_this = sizeof(params);
+               params.algorithm = WIMLIB_LZX_ALGORITHM_FAST;
+               params.use_defaults = 1;
+
+               wimlib_lzx_set_default_params(&params);
+               compression_type = WIMLIB_COMPRESSION_TYPE_LZX;
+       }
+
+       if (!tstrcmp(wimfile, T("-"))) {
+               /* Writing captured WIM to standard output.  */
+       #if 0
+               if (!(write_flags & WIMLIB_WRITE_FLAG_PIPABLE)) {
+                       imagex_error("Can't write a non-pipable WIM to "
+                                    "standard output!  Specify --pipable\n"
+                                    "       if you want to create a pipable WIM "
+                                    "(but read the docs first).");
+                       goto out_err;
+               }
+       #else
+               write_flags |= WIMLIB_WRITE_FLAG_PIPABLE;
+       #endif
+               if (cmd == CMD_APPEND) {
+                       imagex_error(T("Using standard output for append does "
+                                      "not make sense."));
+                       goto out_err;
+               }
+               wim_fd = STDOUT_FILENO;
+               wimfile = NULL;
+               imagex_info_file = stderr;
+               set_fd_to_binary_mode(wim_fd);
+       }
+
+       /* If template image was specified using --update-of=IMAGE rather
+        * than --update-of=WIMFILE:IMAGE, set the default WIMFILE.  */
+       if (template_image_name_or_num && !template_wimfile) {
+               if (base_wimfiles.num_strings == 1) {
+                       /* Capturing delta WIM based on single WIM:  default to
+                        * base WIM.  */
+                       template_wimfile = base_wimfiles.strings[0];
+               } else if (cmd == CMD_APPEND) {
+                       /* Appending to WIM:  default to WIM being appended to.
+                        */
+                       template_wimfile = wimfile;
+               } else {
+                       /* Capturing a normal (non-delta) WIM, so the WIM file
+                        * *must* be explicitly specified.  */
+                       if (base_wimfiles.num_strings > 1) {
+                               imagex_error(T("For capture of delta WIM "
+                                              "based on multiple existing "
+                                              "WIMs,\n"
+                                              "      '--update-of' must "
+                                              "specify WIMFILE:IMAGE!"));
+                       } else {
+                               imagex_error(T("For capture of non-delta WIM, "
+                                              "'--update-of' must specify "
+                                              "WIMFILE:IMAGE!"));
+                       }
+                       goto out_usage;
+               }
+       }
+
        if (argc >= 3) {
                name = argv[2];
                name_defaulted = false;
@@ -1805,8 +1935,7 @@ imagex_capture_or_append(int argc, tchar **argv)
                }
                capture_sources_malloced = true;
        } else {
-               /* Set up capture source in non-source-list mode (could be
-                * either "normal" mode or "NTFS mode"--- see the man page). */
+               /* Set up capture source in non-source-list mode.  */
                capture_sources = alloca(sizeof(struct wimlib_capture_source));
                capture_sources[0].fs_source_path = source;
                capture_sources[0].wim_target_path = NULL;
@@ -1817,6 +1946,7 @@ imagex_capture_or_append(int argc, tchar **argv)
        }
 
        if (config_file) {
+               /* Read and parse capture configuration file.  */
                size_t config_len;
 
                config_str = file_get_text_contents(config_file, &config_len);
@@ -1830,10 +1960,14 @@ imagex_capture_or_append(int argc, tchar **argv)
                if (ret)
                        goto out_free_config;
        } else {
-               config = &default_capture_config;
+               /* No capture configuration file specified; use default
+                * configuration for capturing Windows operating systems.  */
+               config = NULL;
+               add_image_flags |= WIMLIB_ADD_FLAG_WINCONFIG;
        }
 
-       if (cmd == APPEND)
+       /* Open the existing WIM, or create a new one.  */
+       if (cmd == CMD_APPEND)
                ret = wimlib_open_wim(wimfile, open_flags, &wim,
                                      imagex_progress_func);
        else
@@ -1841,13 +1975,22 @@ imagex_capture_or_append(int argc, tchar **argv)
        if (ret)
                goto out_free_config;
 
+       /* Set chunk size if non-default.  */
+       if (chunk_size != UINT32_MAX) {
+               ret = wimlib_set_output_chunk_size(wim, chunk_size);
+               if (ret)
+                       goto out_free_wim;
+       }
+
 #ifndef __WIN32__
+       /* Detect if source is regular file or block device and set NTFS volume
+        * capture mode.  */
        if (!source_list) {
                struct stat stbuf;
 
                if (tstat(source, &stbuf) == 0) {
                        if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode)) {
-                               tprintf(T("Capturing WIM image from NTFS "
+                               imagex_printf(T("Capturing WIM image from NTFS "
                                          "filesystem on \"%"TS"\"\n"), source);
                                add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_NTFS;
                        }
@@ -1856,16 +1999,16 @@ imagex_capture_or_append(int argc, tchar **argv)
                                imagex_error_with_errno(T("Failed to stat "
                                                          "\"%"TS"\""), source);
                                ret = -1;
-                               goto out_wimlib_free;
+                               goto out_free_wim;
                        }
                }
        }
 #endif
 
-       if (cmd == APPEND && name_defaulted) {
-               /* If the user did not specify an image name, and the basename
-                * of the source already exists as an image name in the WIM
-                * file, append a suffix to make it unique. */
+       /* If the user did not specify an image name, and the basename of the
+        * source already exists as an image name in the WIM file, append a
+        * suffix to make it unique. */
+       if (cmd == CMD_APPEND && name_defaulted) {
                unsigned long conflict_idx;
                tchar *name_end = tstrchr(name, T('\0'));
                for (conflict_idx = 1;
@@ -1875,9 +2018,86 @@ imagex_capture_or_append(int argc, tchar **argv)
                        tsprintf(name_end, T(" (%lu)"), conflict_idx);
                }
        }
-#ifdef __WIN32__
-       win32_acquire_capture_privileges();
-#endif
+
+       /* If capturing a delta WIM, reference resources from the base WIMs
+        * before adding the new image.  */
+       if (base_wimfiles.num_strings) {
+               base_wims = calloc(base_wimfiles.num_strings,
+                                  sizeof(base_wims[0]));
+               if (base_wims == NULL) {
+                       imagex_error(T("Out of memory!"));
+                       ret = -1;
+                       goto out_free_wim;
+               }
+
+               for (size_t i = 0; i < base_wimfiles.num_strings; i++) {
+                       ret = wimlib_open_wim(base_wimfiles.strings[i],
+                                             open_flags, &base_wims[i],
+                                             imagex_progress_func);
+                       if (ret)
+                               goto out_free_base_wims;
+
+               }
+
+               ret = wimlib_reference_resources(wim, base_wims,
+                                                base_wimfiles.num_strings, 0);
+               if (ret)
+                       goto out_free_base_wims;
+
+               if (base_wimfiles.num_strings == 1) {
+                       imagex_printf(T("Capturing delta WIM based on \"%"TS"\"\n"),
+                                     base_wimfiles.strings[0]);
+               } else {
+                       imagex_printf(T("Capturing delta WIM based on %u WIMs\n"),
+                                     base_wimfiles.num_strings);
+               }
+
+       } else {
+               base_wims = NULL;
+       }
+
+       /* If capturing or appending as an update of an existing (template) image,
+        * open the WIM if needed and parse the image index.  */
+       if (template_image_name_or_num) {
+
+
+               if (base_wimfiles.num_strings == 1 &&
+                   template_wimfile == base_wimfiles.strings[0]) {
+                       template_wim = base_wims[0];
+               } else if (template_wimfile == wimfile) {
+                       template_wim = wim;
+               } else {
+                       ret = wimlib_open_wim(template_wimfile, open_flags,
+                                             &template_wim, imagex_progress_func);
+                       if (ret)
+                               goto out_free_base_wims;
+               }
+
+               template_image = wimlib_resolve_image(template_wim,
+                                                     template_image_name_or_num);
+
+               if (template_image_name_or_num[0] == T('-')) {
+                       tchar *tmp;
+                       unsigned long n;
+                       struct wimlib_wim_info info;
+
+                       wimlib_get_wim_info(template_wim, &info);
+                       n = tstrtoul(template_image_name_or_num + 1, &tmp, 10);
+                       if (n >= 1 && n <= info.image_count &&
+                           *tmp == T('\0') &&
+                           tmp != template_image_name_or_num + 1)
+                       {
+                               template_image = info.image_count - (n - 1);
+                       }
+               }
+               ret = verify_image_exists_and_is_single(template_image,
+                                                       template_image_name_or_num,
+                                                       template_wimfile);
+               if (ret)
+                       goto out_free_template_wim;
+       } else {
+               template_wim = NULL;
+       }
 
        ret = wimlib_add_image_multisource(wim,
                                           capture_sources,
@@ -1887,12 +2107,13 @@ imagex_capture_or_append(int argc, tchar **argv)
                                           add_image_flags,
                                           imagex_progress_func);
        if (ret)
-               goto out_release_privs;
+               goto out_free_template_wim;
 
-       if (desc || flags_element) {
-               /* User provided <DESCRIPTION> or <FLAGS> element.  Get the
-                * index of the image we just added, then use it to call the
-                * appropriate functions.  */
+       if (desc || flags_element || template_image_name_or_num) {
+               /* User provided <DESCRIPTION> or <FLAGS> element, or an image
+                * on which the added one is to be based has been specified with
+                * --update-of.  Get the index of the image we just
+                *  added, then use it to call the appropriate functions.  */
                struct wimlib_wim_info info;
 
                wimlib_get_wim_info(wim, &info);
@@ -1902,35 +2123,58 @@ imagex_capture_or_append(int argc, tchar **argv)
                                                          info.image_count,
                                                          desc);
                        if (ret)
-                               goto out_release_privs;
+                               goto out_free_template_wim;
                }
 
                if (flags_element) {
                        ret = wimlib_set_image_flags(wim, info.image_count,
                                                     flags_element);
                        if (ret)
-                               goto out_release_privs;
+                               goto out_free_template_wim;
+               }
+
+               /* Reference template image if the user provided one.  */
+               if (template_image_name_or_num) {
+                       imagex_printf(T("Using image %d "
+                                       "from \"%"TS"\" as template\n"),
+                                       template_image, template_wimfile);
+                       ret = wimlib_reference_template_image(wim,
+                                                             info.image_count,
+                                                             template_wim,
+                                                             template_image,
+                                                             0, NULL);
+                       if (ret)
+                               goto out_free_template_wim;
                }
        }
 
-       if (cmd == APPEND) {
+       /* Write the new WIM or overwrite the existing WIM with the new image
+        * appended.  */
+       if (cmd == CMD_APPEND) {
                ret = wimlib_overwrite(wim, write_flags, num_threads,
                                       imagex_progress_func);
+       } else if (wimfile) {
+               ret = wimlib_write(wim, wimfile, WIMLIB_ALL_IMAGES,
+                                  write_flags, num_threads,
+                                  imagex_progress_func);
        } else {
-               ret = wimlib_write(wim, wimfile, WIMLIB_ALL_IMAGES, write_flags,
-                                  num_threads, imagex_progress_func);
-       }
-       if (ret)
-               imagex_error(T("Failed to write the WIM file \"%"TS"\""),
-                            wimfile);
-out_release_privs:
-#ifdef __WIN32__
-       win32_release_capture_privileges();
-#endif
-out_wimlib_free:
+               ret = wimlib_write_to_fd(wim, wim_fd, WIMLIB_ALL_IMAGES,
+                                        write_flags, num_threads,
+                                        imagex_progress_func);
+       }
+out_free_template_wim:
+       /* template_wim may alias base_wims[0] or wim.  */
+       if ((base_wimfiles.num_strings != 1 || template_wim != base_wims[0]) &&
+           template_wim != wim)
+               wimlib_free(template_wim);
+out_free_base_wims:
+       for (size_t i = 0; i < base_wimfiles.num_strings; i++)
+               wimlib_free(base_wims[i]);
+       free(base_wims);
+out_free_wim:
        wimlib_free(wim);
 out_free_config:
-       if (config != &default_capture_config) {
+       if (config) {
                free(config->exclusion_pats.pats);
                free(config->exclusion_exception_pats.pats);
                free(config_str);
@@ -1940,19 +2184,20 @@ out_free_capture_sources:
                free(capture_sources);
 out_free_source_list_contents:
        free(source_list_contents);
-out:
+out_free_base_wimfiles:
+       string_set_destroy(&base_wimfiles);
        return ret;
 
 out_usage:
-       usage(cmd);
+       usage(cmd, stderr);
 out_err:
        ret = -1;
-       goto out;
+       goto out_free_base_wimfiles;
 }
 
 /* Remove image(s) from a WIM. */
 static int
-imagex_delete(int argc, tchar **argv)
+imagex_delete(int argc, tchar **argv, int cmd)
 {
        int c;
        int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
@@ -2018,7 +2263,7 @@ out:
        return ret;
 
 out_usage:
-       usage(DELETE);
+       usage(CMD_DELETE, stderr);
        ret = -1;
        goto out;
 }
@@ -2032,7 +2277,7 @@ print_full_path(const struct wimlib_dir_entry *wdentry, void *_ignore)
 
 /* Print the files contained in an image(s) in a WIM file. */
 static int
-imagex_dir(int argc, tchar **argv)
+imagex_dir(int argc, tchar **argv, int cmd)
 {
        const tchar *wimfile;
        WIMStruct *wim = NULL;
@@ -2063,8 +2308,7 @@ imagex_dir(int argc, tchar **argv)
        }
 
        wimfile = argv[0];
-       ret = wimlib_open_wim(wimfile, WIMLIB_OPEN_FLAG_SPLIT_OK, &wim,
-                             imagex_progress_func);
+       ret = wimlib_open_wim(wimfile, 0, &wim, imagex_progress_func);
        if (ret)
                goto out;
 
@@ -2099,7 +2343,7 @@ out:
        return ret;
 
 out_usage:
-       usage(DIR);
+       usage(CMD_DIR, stderr);
        ret = -1;
        goto out;
 }
@@ -2107,7 +2351,7 @@ out_usage:
 /* Exports one, or all, images from a WIM file to a new WIM file or an existing
  * WIM file. */
 static int
-imagex_export(int argc, tchar **argv)
+imagex_export(int argc, tchar **argv, int cmd)
 {
        int c;
        int open_flags = 0;
@@ -2117,17 +2361,17 @@ imagex_export(int argc, tchar **argv)
        const tchar *src_wimfile;
        const tchar *src_image_num_or_name;
        const tchar *dest_wimfile;
+       int dest_wim_fd;
        const tchar *dest_name;
        const tchar *dest_desc;
        WIMStruct *src_wim;
+       struct wimlib_wim_info src_info;
        WIMStruct *dest_wim;
        int ret;
        int image;
        struct stat stbuf;
        bool wim_is_new;
-       const tchar *swm_glob = NULL;
-       WIMStruct **additional_swms;
-       unsigned num_additional_swms;
+       STRING_SET(refglobs);
        unsigned num_threads = 0;
 
        for_opt(c, export_options) {
@@ -2139,13 +2383,18 @@ imagex_export(int argc, tchar **argv)
                        open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
                        write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
                        break;
+               case IMAGEX_NOCHECK_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY;
+                       break;
                case IMAGEX_COMPRESS_OPTION:
                        compression_type = get_compression_type(optarg);
                        if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID)
                                goto out_err;
                        break;
                case IMAGEX_REF_OPTION:
-                       swm_glob = optarg;
+                       ret = string_set_append(&refglobs, optarg);
+                       if (ret)
+                               goto out_free_refglobs;
                        break;
                case IMAGEX_THREADS_OPTION:
                        num_threads = parse_num_threads(optarg);
@@ -2155,6 +2404,12 @@ imagex_export(int argc, tchar **argv)
                case IMAGEX_REBUILD_OPTION:
                        write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
                        break;
+               case IMAGEX_PIPABLE_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_PIPABLE;
+                       break;
+               case IMAGEX_NOT_PIPABLE_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NOT_PIPABLE;
+                       break;
                default:
                        goto out_usage;
                }
@@ -2168,16 +2423,38 @@ imagex_export(int argc, tchar **argv)
        dest_wimfile          = argv[2];
        dest_name             = (argc >= 4) ? argv[3] : NULL;
        dest_desc             = (argc >= 5) ? argv[4] : NULL;
-       ret = wimlib_open_wim(src_wimfile,
-                             open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK, &src_wim,
+       ret = wimlib_open_wim(src_wimfile, open_flags, &src_wim,
                              imagex_progress_func);
        if (ret)
-               goto out;
-
-       /* Determine if the destination is an existing file or not.
-        * If so, we try to append the exported image(s) to it; otherwise, we
-        * create a new WIM containing the exported image(s). */
-       if (tstat(dest_wimfile, &stbuf) == 0) {
+               goto out_free_refglobs;
+
+       wimlib_get_wim_info(src_wim, &src_info);
+
+       /* Determine if the destination is an existing file or not.  If so, we
+        * try to append the exported image(s) to it; otherwise, we create a new
+        * WIM containing the exported image(s).  Furthermore, determine if we
+        * need to write a pipable WIM directly to standard output.  */
+
+       if (tstrcmp(dest_wimfile, T("-")) == 0) {
+       #if 0
+               if (!(write_flags & WIMLIB_WRITE_FLAG_PIPABLE)) {
+                       imagex_error("Can't write a non-pipable WIM to "
+                                    "standard output!  Specify --pipable\n"
+                                    "       if you want to create a pipable WIM "
+                                    "(but read the docs first).");
+                       ret = -1;
+                       goto out_free_src_wim;
+               }
+       #else
+               write_flags |= WIMLIB_WRITE_FLAG_PIPABLE;
+       #endif
+               dest_wimfile = NULL;
+               dest_wim_fd = STDOUT_FILENO;
+               imagex_info_file = stderr;
+               set_fd_to_binary_mode(dest_wim_fd);
+       }
+       errno = ENOENT;
+       if (dest_wimfile != NULL && tstat(dest_wimfile, &stbuf) == 0) {
                wim_is_new = false;
                /* Destination file exists. */
 
@@ -2187,7 +2464,8 @@ imagex_export(int argc, tchar **argv)
                        ret = -1;
                        goto out_free_src_wim;
                }
-               ret = wimlib_open_wim(dest_wimfile, open_flags | WIMLIB_OPEN_FLAG_WRITE_ACCESS,
+               ret = wimlib_open_wim(dest_wimfile,
+                                     open_flags | WIMLIB_OPEN_FLAG_WRITE_ACCESS,
                                      &dest_wim, imagex_progress_func);
                if (ret)
                        goto out_free_src_wim;
@@ -2224,14 +2502,13 @@ imagex_export(int argc, tchar **argv)
                        /* The user did not specify a compression type; default
                         * to that of the source WIM.  */
 
-                       struct wimlib_wim_info src_info;
-
-                       wimlib_get_wim_info(src_wim, &src_info);
                        compression_type = src_info.compression_type;
                }
                ret = wimlib_create_new_wim(compression_type, &dest_wim);
                if (ret)
                        goto out_free_src_wim;
+
+               wimlib_set_output_chunk_size(dest_wim, src_info.chunk_size);
        }
 
        image = wimlib_resolve_image(src_wim, src_image_num_or_name);
@@ -2239,48 +2516,55 @@ imagex_export(int argc, tchar **argv)
        if (ret)
                goto out_free_dest_wim;
 
-       if (swm_glob) {
-               ret = open_swms_from_glob(swm_glob, src_wimfile, open_flags,
-                                         &additional_swms,
-                                         &num_additional_swms);
+       if (refglobs.num_strings) {
+               ret = wim_reference_globs(src_wim, &refglobs, open_flags);
                if (ret)
                        goto out_free_dest_wim;
-       } else {
-               additional_swms = NULL;
-               num_additional_swms = 0;
+       }
+
+       if ((export_flags & WIMLIB_EXPORT_FLAG_BOOT) &&
+           image == WIMLIB_ALL_IMAGES && src_info.boot_index == 0)
+       {
+               imagex_error(T("--boot specified for all-images export, but source WIM "
+                              "has no bootable image."));
+               ret = -1;
+               goto out_free_dest_wim;
        }
 
        ret = wimlib_export_image(src_wim, image, dest_wim, dest_name,
-                                 dest_desc, export_flags, additional_swms,
-                                 num_additional_swms, imagex_progress_func);
-       if (ret)
-               goto out_free_swms;
+                                 dest_desc, export_flags, imagex_progress_func);
+       if (ret) {
+               if (ret == WIMLIB_ERR_RESOURCE_NOT_FOUND) {
+                       do_resource_not_found_warning(src_wimfile,
+                                                     &src_info, &refglobs);
+               }
+               goto out_free_dest_wim;
+       }
 
-       if (wim_is_new)
+       if (!wim_is_new)
+               ret = wimlib_overwrite(dest_wim, write_flags, num_threads,
+                                      imagex_progress_func);
+       else if (dest_wimfile)
                ret = wimlib_write(dest_wim, dest_wimfile, WIMLIB_ALL_IMAGES,
                                   write_flags, num_threads,
                                   imagex_progress_func);
        else
-               ret = wimlib_overwrite(dest_wim, write_flags, num_threads,
-                                      imagex_progress_func);
-out_free_swms:
-       if (swm_glob) {
-               for (unsigned i = 0; i < num_additional_swms; i++)
-                       wimlib_free(additional_swms[i]);
-               free(additional_swms);
-       }
+               ret = wimlib_write_to_fd(dest_wim, dest_wim_fd,
+                                        WIMLIB_ALL_IMAGES, write_flags,
+                                        num_threads, imagex_progress_func);
 out_free_dest_wim:
        wimlib_free(dest_wim);
 out_free_src_wim:
        wimlib_free(src_wim);
-out:
+out_free_refglobs:
+       string_set_destroy(&refglobs);
        return ret;
 
 out_usage:
-       usage(EXPORT);
+       usage(CMD_EXPORT, stderr);
 out_err:
        ret = -1;
-       goto out;
+       goto out_free_refglobs;
 }
 
 static bool
@@ -2346,10 +2630,10 @@ prepare_extract_commands(tchar **paths, unsigned num_paths,
 
 /* Extract files or directories from a WIM image */
 static int
-imagex_extract(int argc, tchar **argv)
+imagex_extract(int argc, tchar **argv, int cmd)
 {
        int c;
-       int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
+       int open_flags = 0;
        int image;
        WIMStruct *wim;
        int ret;
@@ -2358,9 +2642,7 @@ imagex_extract(int argc, tchar **argv)
        tchar *dest_dir = T(".");
        int extract_flags = WIMLIB_EXTRACT_FLAG_SEQUENTIAL | WIMLIB_EXTRACT_FLAG_NORPFIX;
 
-       const tchar *swm_glob = NULL;
-       WIMStruct **additional_swms;
-       unsigned num_additional_swms;
+       STRING_SET(refglobs);
 
        struct wimlib_extract_command *cmds;
        size_t num_cmds;
@@ -2374,7 +2656,9 @@ imagex_extract(int argc, tchar **argv)
                        extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
                        break;
                case IMAGEX_REF_OPTION:
-                       swm_glob = optarg;
+                       ret = string_set_append(&refglobs, optarg);
+                       if (ret)
+                               goto out_free_refglobs;
                        break;
                case IMAGEX_UNIX_DATA_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_UNIX_DATA;
@@ -2390,6 +2674,7 @@ imagex_extract(int argc, tchar **argv)
                        break;
                case IMAGEX_TO_STDOUT_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_TO_STDOUT;
+                       imagex_info_file = stderr;
                        imagex_be_quiet = true;
                        break;
                case IMAGEX_INCLUDE_INVALID_NAMES_OPTION:
@@ -2428,52 +2713,41 @@ imagex_extract(int argc, tchar **argv)
        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 (refglobs.num_strings) {
+               ret = wim_reference_globs(wim, &refglobs, open_flags);
                if (ret)
                        goto out_wimlib_free;
-       } else {
-               additional_swms = NULL;
-               num_additional_swms = 0;
        }
 
-#ifdef __WIN32__
-       win32_acquire_restore_privileges();
-#endif
-
        ret = wimlib_extract_files(wim, image, cmds, num_cmds, 0,
-                                  additional_swms, num_additional_swms,
                                   imagex_progress_func);
        if (ret == 0) {
                if (!imagex_be_quiet)
-                       tprintf(T("Done extracting files.\n"));
+                       imagex_printf(T("Done extracting files.\n"));
        } else if (ret == WIMLIB_ERR_PATH_DOES_NOT_EXIST) {
-               tfprintf(stderr, T("Note: You can use `"IMAGEX_PROGNAME" dir' to see what "
+               tfprintf(stderr, T("Note: You can use `%"TS"' to see what "
                                   "files and directories\n"
-                                  "      are in the WIM image.\n"));
-       }
-#ifdef __WIN32__
-       win32_release_restore_privileges();
-#endif
-       if (swm_glob) {
-               for (unsigned i = 0; i < num_additional_swms; i++)
-                       wimlib_free(additional_swms[i]);
-               free(additional_swms);
+                                  "      are in the WIM image.\n"),
+                               get_cmd_string(CMD_INFO, false));
+       } else if (ret == WIMLIB_ERR_RESOURCE_NOT_FOUND) {
+               struct wimlib_wim_info info;
+
+               wimlib_get_wim_info(wim, &info);
+               do_resource_not_found_warning(wimfile, &info, &refglobs);
        }
 out_wimlib_free:
        wimlib_free(wim);
 out_free_cmds:
        free_extract_commands(cmds, num_cmds, dest_dir);
-out:
+out_free_refglobs:
+       string_set_destroy(&refglobs);
        return ret;
 
 out_usage:
-       usage(EXTRACT);
+       usage(CMD_EXTRACT, stderr);
 out_err:
        ret = -1;
-       goto out;
+       goto out_free_refglobs;
 }
 
 static void print_byte_field(const uint8_t field[], size_t len)
@@ -2491,9 +2765,12 @@ print_wim_information(const tchar *wimfile, const struct wimlib_wim_info *info)
        tprintf(T("GUID:           0x"));
        print_byte_field(info->guid, sizeof(info->guid));
        tputchar(T('\n'));
+       tprintf(T("Version:        %u\n"), info->wim_version);
        tprintf(T("Image Count:    %d\n"), info->image_count);
        tprintf(T("Compression:    %"TS"\n"),
                wimlib_get_compression_type_string(info->compression_type));
+       tprintf(T("Chunk Size:     %"PRIu32" bytes\n"),
+               info->chunk_size);
        tprintf(T("Part Number:    %d/%d\n"), info->part_number, info->total_parts);
        tprintf(T("Boot Index:     %d\n"), info->boot_index);
        tprintf(T("Size:           %"PRIu64" bytes\n"), info->total_bytes);
@@ -2501,6 +2778,8 @@ print_wim_information(const tchar *wimfile, const struct wimlib_wim_info *info)
                info->has_integrity_table ? T("yes") : T("no"));
        tprintf(T("Relative path junction: %"TS"\n"),
                info->has_rpfix ? T("yes") : T("no"));
+       tprintf(T("Pipable:        %"TS"\n"),
+               info->pipable ? T("yes") : T("no"));
        tputchar(T('\n'));
 }
 
@@ -2508,25 +2787,33 @@ static int
 print_resource(const struct wimlib_resource_entry *resource,
               void *_ignore)
 {
-
-       tprintf(T("Uncompressed size   = %"PRIu64" bytes\n"),
+       tprintf(T("Uncompressed size     = %"PRIu64" bytes\n"),
                resource->uncompressed_size);
+       if (resource->packed) {
+               tprintf(T("Raw compressed size   = %"PRIu64" bytes\n"),
+                       resource->raw_resource_compressed_size);
 
-       tprintf(T("Compressed size     = %"PRIu64" bytes\n"),
-               resource->compressed_size);
+               tprintf(T("Raw offset in WIM     = %"PRIu64" bytes\n"),
+                       resource->raw_resource_offset_in_wim);
 
-       tprintf(T("Offset              = %"PRIu64" bytes\n"),
-               resource->offset);
+               tprintf(T("Offset in raw         = %"PRIu64" bytes\n"),
+                       resource->offset);
+       } else {
+               tprintf(T("Compressed size       = %"PRIu64" bytes\n"),
+                       resource->compressed_size);
 
+               tprintf(T("Offset in WIM         = %"PRIu64" bytes\n"),
+                       resource->offset);
+       }
 
-       tprintf(T("Part Number         = %u\n"), resource->part_number);
-       tprintf(T("Reference Count     = %u\n"), resource->reference_count);
+       tprintf(T("Part Number           = %u\n"), resource->part_number);
+       tprintf(T("Reference Count       = %u\n"), resource->reference_count);
 
-       tprintf(T("Hash                = 0x"));
+       tprintf(T("Hash                  = 0x"));
        print_byte_field(resource->sha1_hash, sizeof(resource->sha1_hash));
        tputchar(T('\n'));
 
-       tprintf(T("Flags               = "));
+       tprintf(T("Flags                 = "));
        if (resource->is_compressed)
                tprintf(T("WIM_RESHDR_FLAG_COMPRESSED  "));
        if (resource->is_metadata)
@@ -2535,6 +2822,8 @@ print_resource(const struct wimlib_resource_entry *resource,
                tprintf(T("WIM_RESHDR_FLAG_FREE  "));
        if (resource->is_spanned)
                tprintf(T("WIM_RESHDR_FLAG_SPANNED  "));
+       if (resource->packed)
+               tprintf(T("WIM_RESHDR_FLAG_PACKED_STREAMS  "));
        tputchar(T('\n'));
        tputchar(T('\n'));
        return 0;
@@ -2549,11 +2838,12 @@ print_lookup_table(WIMStruct *wim)
 /* 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
-imagex_info(int argc, tchar **argv)
+imagex_info(int argc, tchar **argv, int cmd)
 {
        int c;
        bool boot         = false;
        bool check        = false;
+       bool nocheck      = false;
        bool header       = false;
        bool lookup_table = false;
        bool xml          = false;
@@ -2567,7 +2857,7 @@ imagex_info(int argc, tchar **argv)
        WIMStruct *wim;
        int image;
        int ret;
-       int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
+       int open_flags = 0;
        struct wimlib_wim_info info;
 
        for_opt(c, info_options) {
@@ -2578,6 +2868,9 @@ imagex_info(int argc, tchar **argv)
                case IMAGEX_CHECK_OPTION:
                        check = true;
                        break;
+               case IMAGEX_NOCHECK_OPTION:
+                       nocheck = true;
+                       break;
                case IMAGEX_HEADER_OPTION:
                        header = true;
                        short_header = false;
@@ -2613,6 +2906,11 @@ imagex_info(int argc, tchar **argv)
        new_name          = (argc >= 3) ? argv[2] : NULL;
        new_desc          = (argc >= 4) ? argv[3] : NULL;
 
+       if (check && nocheck) {
+               imagex_error(T("Can't specify both --check and --nocheck"));
+               goto out_err;
+       }
+
        if (check)
                open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
 
@@ -2625,8 +2923,7 @@ imagex_info(int argc, tchar **argv)
        image = wimlib_resolve_image(wim, image_num_or_name);
        ret = WIMLIB_ERR_INVALID_IMAGE;
        if (image == WIMLIB_NO_IMAGE && tstrcmp(image_num_or_name, T("0"))) {
-               imagex_error(T("The image \"%"TS"\" does not exist in \"%"TS"\""),
-                            image_num_or_name, wimfile);
+               verify_image_exists(image, image_num_or_name, wimfile);
                if (boot) {
                        imagex_error(T("If you would like to set the boot "
                                       "index to 0, specify image \"0\" with "
@@ -2736,11 +3033,11 @@ imagex_info(int argc, tchar **argv)
 
                if (boot) {
                        if (image == info.boot_index) {
-                               tprintf(T("Image %d is already marked as "
+                               imagex_printf(T("Image %d is already marked as "
                                          "bootable.\n"), image);
                                boot = false;
                        } else {
-                               tprintf(T("Marking image %d as bootable.\n"),
+                               imagex_printf(T("Marking image %d as bootable.\n"),
                                        image);
                                info.boot_index = image;
                                ret = wimlib_set_wim_info(wim, &info,
@@ -2752,11 +3049,11 @@ imagex_info(int argc, tchar **argv)
                if (new_name) {
                        if (!tstrcmp(wimlib_get_image_name(wim, image), new_name))
                        {
-                               tprintf(T("Image %d is already named \"%"TS"\".\n"),
+                               imagex_printf(T("Image %d is already named \"%"TS"\".\n"),
                                        image, new_name);
                                new_name = NULL;
                        } else {
-                               tprintf(T("Changing the name of image %d to "
+                               imagex_printf(T("Changing the name of image %d to "
                                          "\"%"TS"\".\n"), image, new_name);
                                ret = wimlib_set_image_name(wim, image, new_name);
                                if (ret)
@@ -2767,11 +3064,11 @@ imagex_info(int argc, tchar **argv)
                        const tchar *old_desc;
                        old_desc = wimlib_get_image_description(wim, image);
                        if (old_desc && !tstrcmp(old_desc, new_desc)) {
-                               tprintf(T("The description of image %d is already "
+                               imagex_printf(T("The description of image %d is already "
                                          "\"%"TS"\".\n"), image, new_desc);
                                new_desc = NULL;
                        } else {
-                               tprintf(T("Changing the description of image %d "
+                               imagex_printf(T("Changing the description of image %d "
                                          "to \"%"TS"\".\n"), image, new_desc);
                                ret = wimlib_set_image_descripton(wim, image,
                                                                  new_desc);
@@ -2781,19 +3078,23 @@ imagex_info(int argc, tchar **argv)
                }
 
                /* Only call wimlib_overwrite() if something actually needs to
-                * be changed. */
+                * be changed.  */
                if (boot || new_name || new_desc ||
-                   (check && !info.has_integrity_table))
+                   (check && !info.has_integrity_table) ||
+                   (nocheck && info.has_integrity_table))
                {
                        int write_flags = 0;
 
                        if (check)
                                write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
+                       if (nocheck)
+                               write_flags |= WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY;
                        ret = wimlib_overwrite(wim, write_flags, 1,
                                               imagex_progress_func);
                } else {
-                       tprintf(T("The file \"%"TS"\" was not modified because nothing "
-                                 "needed to be done.\n"), wimfile);
+                       imagex_printf(T("The file \"%"TS"\" was not modified "
+                                       "because nothing needed to be done.\n"),
+                                     wimfile);
                        ret = 0;
                }
        }
@@ -2803,17 +3104,18 @@ out:
        return ret;
 
 out_usage:
-       usage(INFO);
+       usage(CMD_INFO, stderr);
+out_err:
        ret = -1;
        goto out;
 }
 
 /* Join split WIMs into one part WIM */
 static int
-imagex_join(int argc, tchar **argv)
+imagex_join(int argc, tchar **argv, int cmd)
 {
        int c;
-       int swm_open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
+       int swm_open_flags = 0;
        int wim_write_flags = 0;
        const tchar *output_path;
        int ret;
@@ -2847,29 +3149,31 @@ out:
        return ret;
 
 out_usage:
-       usage(JOIN);
+       usage(CMD_JOIN, stderr);
        ret = -1;
        goto out;
 }
 
-/* Mounts an image using a FUSE mount. */
+#if WIM_MOUNTING_SUPPORTED
+
+/* Mounts a WIM image.  */
 static int
-imagex_mount_rw_or_ro(int argc, tchar **argv)
+imagex_mount_rw_or_ro(int argc, tchar **argv, int cmd)
 {
        int c;
        int mount_flags = 0;
-       int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
-       const tchar *swm_glob = NULL;
+       int open_flags = 0;
        const tchar *staging_dir = NULL;
        const tchar *wimfile;
        const tchar *dir;
        WIMStruct *wim;
+       struct wimlib_wim_info info;
        int image;
        int ret;
-       WIMStruct **additional_swms;
-       unsigned num_additional_swms;
 
-       if (!tstrcmp(argv[0], T("mountrw"))) {
+       STRING_SET(refglobs);
+
+       if (cmd == CMD_MOUNTRW) {
                mount_flags |= WIMLIB_MOUNT_FLAG_READWRITE;
                open_flags |= WIMLIB_OPEN_FLAG_WRITE_ACCESS;
        }
@@ -2899,7 +3203,9 @@ imagex_mount_rw_or_ro(int argc, tchar **argv)
                        }
                        break;
                case IMAGEX_REF_OPTION:
-                       swm_glob = optarg;
+                       ret = string_set_append(&refglobs, optarg);
+                       if (ret)
+                               goto out_free_refglobs;
                        break;
                case IMAGEX_STAGING_DIR_OPTION:
                        staging_dir = optarg;
@@ -2920,7 +3226,9 @@ imagex_mount_rw_or_ro(int argc, tchar **argv)
 
        ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
        if (ret)
-               goto out;
+               goto out_free_refglobs;
+
+       wimlib_get_wim_info(wim, &info);
 
        if (argc >= 3) {
                /* Image explicitly specified.  */
@@ -2932,9 +3240,7 @@ imagex_mount_rw_or_ro(int argc, tchar **argv)
        } else {
                /* No image specified; default to image 1, but only if the WIM
                 * contains exactly one image.  */
-               struct wimlib_wim_info info;
 
-               wimlib_get_wim_info(wim, &info);
                if (info.image_count != 1) {
                        imagex_error(T("\"%"TS"\" contains %d images; Please "
                                       "select one."), wimfile, info.image_count);
@@ -2945,48 +3251,40 @@ imagex_mount_rw_or_ro(int argc, tchar **argv)
                dir = argv[1];
        }
 
-       if (swm_glob) {
-               ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
-                                         &additional_swms,
-                                         &num_additional_swms);
+       if (refglobs.num_strings) {
+               ret = wim_reference_globs(wim, &refglobs, open_flags);
                if (ret)
                        goto out_free_wim;
-       } else {
-               additional_swms = NULL;
-               num_additional_swms = 0;
        }
 
-       ret = wimlib_mount_image(wim, image, dir, mount_flags, additional_swms,
-                                num_additional_swms, staging_dir);
+       ret = wimlib_mount_image(wim, image, dir, mount_flags, staging_dir);
        if (ret) {
                imagex_error(T("Failed to mount image %d from \"%"TS"\" "
                               "on \"%"TS"\""),
                             image, wimfile, dir);
        }
-       if (swm_glob) {
-               for (unsigned i = 0; i < num_additional_swms; i++)
-                       wimlib_free(additional_swms[i]);
-               free(additional_swms);
-       }
 out_free_wim:
        wimlib_free(wim);
-out:
+out_free_refglobs:
+       string_set_destroy(&refglobs);
        return ret;
 
 out_usage:
-       usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
-                       ? MOUNTRW : MOUNT);
+       usage(cmd, stderr);
        ret = -1;
-       goto out;
+       goto out_free_refglobs;
 }
+#endif /* WIM_MOUNTING_SUPPORTED */
 
 /* Rebuild a WIM file */
 static int
-imagex_optimize(int argc, tchar **argv)
+imagex_optimize(int argc, tchar **argv, int cmd)
 {
        int c;
        int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
        int write_flags = WIMLIB_WRITE_FLAG_REBUILD;
+       int compression_type = WIMLIB_COMPRESSION_TYPE_INVALID;
+       uint32_t chunk_size = UINT32_MAX;
        int ret;
        WIMStruct *wim;
        const tchar *wimfile;
@@ -3000,14 +3298,48 @@ imagex_optimize(int argc, tchar **argv)
                        open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
                        write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
                        break;
+               case IMAGEX_NOCHECK_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY;
+                       break;
+               case IMAGEX_COMPRESS_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
+                       compression_type = get_compression_type(optarg);
+                       if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID)
+                               goto out_err;
+                       break;
                case IMAGEX_RECOMPRESS_OPTION:
                        write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
                        break;
+               case IMAGEX_COMPRESS_SLOW_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
+                       compression_type = WIMLIB_COMPRESSION_TYPE_LZX;
+                       ret = set_compress_slow();
+                       if (ret)
+                               goto out_err;
+                       break;
+               case IMAGEX_CHUNK_SIZE_OPTION:
+                       chunk_size = parse_chunk_size(optarg);
+                       if (chunk_size == UINT32_MAX)
+                               goto out_err;
+                       break;
+               case IMAGEX_PACK_STREAMS_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_PACK_STREAMS;
+                       write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
+                       break;
+               case IMAGEX_NO_PACK_STREAMS_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NO_PACK_STREAMS;
+                       break;
                case IMAGEX_THREADS_OPTION:
                        num_threads = parse_num_threads(optarg);
                        if (num_threads == UINT_MAX)
                                goto out_err;
                        break;
+               case IMAGEX_PIPABLE_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_PIPABLE;
+                       break;
+               case IMAGEX_NOT_PIPABLE_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NOT_PIPABLE;
+                       break;
                default:
                        goto out_usage;
                }
@@ -3024,22 +3356,38 @@ imagex_optimize(int argc, tchar **argv)
        if (ret)
                goto out;
 
-       old_size = file_get_size(argv[0]);
+       if (compression_type != WIMLIB_COMPRESSION_TYPE_INVALID) {
+               /* Change compression type.  */
+               ret = wimlib_set_output_compression_type(wim, compression_type);
+               if (ret)
+                       goto out_wimlib_free;
+       }
+
+       if (chunk_size != UINT32_MAX) {
+               /* Change chunk size.  */
+               ret = wimlib_set_output_chunk_size(wim, chunk_size);
+               if (ret)
+                       goto out_wimlib_free;
+       }
+
+       old_size = file_get_size(wimfile);
        tprintf(T("\"%"TS"\" original size: "), wimfile);
        if (old_size == -1)
-               tfputs(T("Unknown\n"), stdout);
+               tputs(T("Unknown"));
        else
                tprintf(T("%"PRIu64" KiB\n"), old_size >> 10);
 
        ret = wimlib_overwrite(wim, write_flags, num_threads,
                               imagex_progress_func);
-       if (ret)
+       if (ret) {
+               imagex_error(T("Optimization of \"%"TS"\" failed."), wimfile);
                goto out_wimlib_free;
+       }
 
-       new_size = file_get_size(argv[0]);
+       new_size = file_get_size(wimfile);
        tprintf(T("\"%"TS"\" optimized size: "), wimfile);
        if (new_size == -1)
-               tfputs(T("Unknown\n"), stdout);
+               tputs(T("Unknown"));
        else
                tprintf(T("%"PRIu64" KiB\n"), new_size >> 10);
 
@@ -3048,7 +3396,7 @@ imagex_optimize(int argc, tchar **argv)
                tprintf(T("%lld KiB\n"),
                       ((long long)old_size - (long long)new_size) >> 10);
        } else {
-               tfputs(T("Unknown\n"), stdout);
+               tputs(T("Unknown"));
        }
        ret = 0;
 out_wimlib_free:
@@ -3057,7 +3405,7 @@ out:
        return ret;
 
 out_usage:
-       usage(OPTIMIZE);
+       usage(CMD_OPTIMIZE, stderr);
 out_err:
        ret = -1;
        goto out;
@@ -3065,10 +3413,10 @@ out_err:
 
 /* Split a WIM into a spanned set */
 static int
-imagex_split(int argc, tchar **argv)
+imagex_split(int argc, tchar **argv, int cmd)
 {
        int c;
-       int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
+       int open_flags = 0;
        int write_flags = 0;
        unsigned long part_size;
        tchar *tmp;
@@ -3108,15 +3456,16 @@ out:
        return ret;
 
 out_usage:
-       usage(SPLIT);
+       usage(CMD_SPLIT, stderr);
 out_err:
        ret = -1;
        goto out;
 }
 
+#if WIM_MOUNTING_SUPPORTED
 /* Unmounts a mounted WIM image. */
 static int
-imagex_unmount(int argc, tchar **argv)
+imagex_unmount(int argc, tchar **argv, int cmd)
 {
        int c;
        int unmount_flags = 0;
@@ -3153,16 +3502,17 @@ out:
        return ret;
 
 out_usage:
-       usage(UNMOUNT);
+       usage(CMD_UNMOUNT, stderr);
        ret = -1;
        goto out;
 }
+#endif /* WIM_MOUNTING_SUPPORTED */
 
 /*
  * Add, delete, or rename files in a WIM image.
  */
 static int
-imagex_update(int argc, tchar **argv)
+imagex_update(int argc, tchar **argv, int cmd)
 {
        const tchar *wimfile;
        int image;
@@ -3171,7 +3521,7 @@ imagex_update(int argc, tchar **argv)
        int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
        int write_flags = 0;
        int update_flags = WIMLIB_UPDATE_FLAG_SEND_PROGRESS;
-       int default_add_flags = WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE;
+       int default_add_flags = WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE;
        int default_delete_flags = 0;
        unsigned num_threads = 0;
        int c;
@@ -3224,24 +3574,25 @@ imagex_update(int argc, tchar **argv)
 
                /* Global add option */
                case IMAGEX_CONFIG_OPTION:
+                       default_add_flags &= ~WIMLIB_ADD_FLAG_WINCONFIG;
                        config_file = optarg;
                        break;
 
                /* Default add options */
                case IMAGEX_VERBOSE_OPTION:
-                       default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
+                       default_add_flags |= WIMLIB_ADD_FLAG_VERBOSE;
                        break;
                case IMAGEX_DEREFERENCE_OPTION:
-                       default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
+                       default_add_flags |= WIMLIB_ADD_FLAG_DEREFERENCE;
                        break;
                case IMAGEX_UNIX_DATA_OPTION:
-                       default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA;
+                       default_add_flags |= WIMLIB_ADD_FLAG_UNIX_DATA;
                        break;
                case IMAGEX_NO_ACLS_OPTION:
-                       default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_NO_ACLS;
+                       default_add_flags |= WIMLIB_ADD_FLAG_NO_ACLS;
                        break;
                case IMAGEX_STRICT_ACLS_OPTION:
-                       default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_STRICT_ACLS;
+                       default_add_flags |= WIMLIB_ADD_FLAG_STRICT_ACLS;
                        break;
                default:
                        goto out_usage;
@@ -3295,7 +3646,8 @@ imagex_update(int argc, tchar **argv)
                if (ret)
                        goto out_free_config;
        } else {
-               config = &default_capture_config;
+               config = NULL;
+               default_add_flags |= WIMLIB_ADD_FLAG_WINCONFIG;
        }
 
        /* Read update commands from standard input, or the command string if
@@ -3307,7 +3659,7 @@ imagex_update(int argc, tchar **argv)
        } else {
                if (isatty(STDIN_FILENO)) {
                        tputs(T("Reading update commands from standard input..."));
-                       recommend_man_page(T("update"));
+                       recommend_man_page(CMD_UPDATE, stdout);
                }
                cmd_file_contents = stdin_get_text_contents(&cmd_file_nchars);
                if (!cmd_file_contents) {
@@ -3325,46 +3677,35 @@ imagex_update(int argc, tchar **argv)
        }
 
        /* Set default flags and capture config on the update commands */
-       bool have_add_command = false;
        for (size_t i = 0; i < num_cmds; i++) {
                switch (cmds[i].op) {
                case WIMLIB_UPDATE_OP_ADD:
                        cmds[i].add.add_flags |= default_add_flags;
                        cmds[i].add.config = config;
-                       have_add_command = true;
                        break;
                case WIMLIB_UPDATE_OP_DELETE:
-                       cmds[i].delete.delete_flags |= default_delete_flags;
+                       cmds[i].delete_.delete_flags |= default_delete_flags;
                        break;
                default:
                        break;
                }
        }
 
-#ifdef __WIN32__
-       if (have_add_command)
-               win32_acquire_capture_privileges();
-#endif
-
        /* Execute the update commands */
        ret = wimlib_update_image(wim, image, cmds, num_cmds, update_flags,
                                  imagex_progress_func);
        if (ret)
-               goto out_release_privs;
+               goto out_free_cmds;
 
        /* Overwrite the updated WIM */
        ret = wimlib_overwrite(wim, write_flags, num_threads,
                               imagex_progress_func);
-out_release_privs:
-#ifdef __WIN32__
-       if (have_add_command)
-               win32_release_capture_privileges();
-#endif
+out_free_cmds:
        free(cmds);
 out_free_cmd_file_contents:
        free(cmd_file_contents);
 out_free_config:
-       if (config != &default_capture_config) {
+       if (config) {
                free(config->exclusion_pats.pats);
                free(config->exclusion_exception_pats.pats);
                free(config_str);
@@ -3376,40 +3717,166 @@ out_free_command_str:
        return ret;
 
 out_usage:
-       usage(UPDATE);
+       usage(CMD_UPDATE, stderr);
 out_err:
        ret = -1;
        goto out_free_command_str;
 }
 
+
+
 struct imagex_command {
        const tchar *name;
-       int (*func)(int , tchar **);
-       int cmd;
+       int (*func)(int argc, tchar **argv, int cmd);
 };
 
-
-#define for_imagex_command(p) for (p = &imagex_commands[0]; \
-               p != &imagex_commands[ARRAY_LEN(imagex_commands)]; p++)
-
 static const struct imagex_command imagex_commands[] = {
-       {T("append"),  imagex_capture_or_append, APPEND},
-       {T("apply"),   imagex_apply,             APPLY},
-       {T("capture"), imagex_capture_or_append, CAPTURE},
-       {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},
-       {T("mountrw"), imagex_mount_rw_or_ro,    MOUNTRW},
-       {T("optimize"),imagex_optimize,          OPTIMIZE},
-       {T("split"),   imagex_split,             SPLIT},
-       {T("unmount"), imagex_unmount,           UNMOUNT},
-       {T("update"),  imagex_update,            UPDATE},
+       [CMD_APPEND]   = {T("append"),   imagex_capture_or_append},
+       [CMD_APPLY]    = {T("apply"),    imagex_apply},
+       [CMD_CAPTURE]  = {T("capture"),  imagex_capture_or_append},
+       [CMD_DELETE]   = {T("delete"),   imagex_delete},
+       [CMD_DIR ]     = {T("dir"),      imagex_dir},
+       [CMD_EXPORT]   = {T("export"),   imagex_export},
+       [CMD_EXTRACT]  = {T("extract"),  imagex_extract},
+       [CMD_INFO]     = {T("info"),     imagex_info},
+       [CMD_JOIN]     = {T("join"),     imagex_join},
+#if WIM_MOUNTING_SUPPORTED
+       [CMD_MOUNT]    = {T("mount"),    imagex_mount_rw_or_ro},
+       [CMD_MOUNTRW]  = {T("mountrw"),  imagex_mount_rw_or_ro},
+#endif
+       [CMD_OPTIMIZE] = {T("optimize"), imagex_optimize},
+       [CMD_SPLIT]    = {T("split"),    imagex_split},
+#if WIM_MOUNTING_SUPPORTED
+       [CMD_UNMOUNT]  = {T("unmount"),  imagex_unmount},
+#endif
+       [CMD_UPDATE]   = {T("update"),   imagex_update},
+};
+
+static const tchar *usage_strings[] = {
+[CMD_APPEND] =
+T(
+"    %"TS" (DIRECTORY | NTFS_VOLUME) WIMFILE\n"
+"                    [IMAGE_NAME [IMAGE_DESCRIPTION]] [--boot]\n"
+"                    [--check] [--nocheck] [--flags EDITION_ID] [--verbose]\n"
+"                    [--dereference] [--config=FILE] [--threads=NUM_THREADS]\n"
+"                    [--source-list] [--no-acls] [--strict-acls] [--rpfix]\n"
+"                    [--norpfix] [--unix-data] [--pipable]\n"
+"                    [--update-of=[WIMFILE:]IMAGE]\n"
+),
+[CMD_APPLY] =
+T(
+"    %"TS" WIMFILE [(IMAGE_NUM | IMAGE_NAME | all)]\n"
+"                    (DIRECTORY | NTFS_VOLUME) [--check] [--hardlink]\n"
+"                    [--symlink] [--verbose] [--ref=\"GLOB\"] [--unix-data]\n"
+"                    [--no-acls] [--strict-acls] [--rpfix] [--norpfix]\n"
+"                    [--include-invalid-names]\n"
+),
+[CMD_CAPTURE] =
+T(
+"    %"TS" (DIRECTORY | NTFS_VOLUME) WIMFILE\n"
+"                   [IMAGE_NAME [IMAGE_DESCRIPTION]] [--boot]\n"
+"                    [--check] [--nocheck] [--compress=TYPE]\n"
+"                    [--flags EDITION_ID] [--verbose] [--dereference]\n"
+"                    [--config=FILE] [--threads=NUM_THREADS] [--source-list]\n"
+"                    [--no-acls] [--strict-acls] [--rpfix] [--norpfix]\n"
+"                    [--unix-data] [--pipable] [--update-of=[WIMFILE:]IMAGE]\n"
+"                    [--delta-from=WIMFILE]\n"
+),
+[CMD_DELETE] =
+T(
+"    %"TS" WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--check]\n"
+"                    [--soft]\n"
+),
+[CMD_DIR] =
+T(
+"    %"TS" WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--path=PATH]\n"
+),
+[CMD_EXPORT] =
+T(
+"    %"TS" SRC_WIMFILE (SRC_IMAGE_NUM | SRC_IMAGE_NAME | all ) \n"
+"                    DEST_WIMFILE [DEST_IMAGE_NAME [DEST_IMAGE_DESCRIPTION]]\n"
+"                    [--boot] [--check] [--nocheck] [--compress=TYPE]\n"
+"                    [--ref=\"GLOB\"] [--threads=NUM_THREADS] [--rebuild]\n"
+"                    [--pipable] [--not-pipable]\n"
+),
+[CMD_EXTRACT] =
+T(
+"    %"TS" WIMFILE (IMAGE_NUM | IMAGE_NAME) [PATH...]\n"
+"                    [--check] [--ref=\"GLOB\"] [--verbose] [--unix-data]\n"
+"                    [--no-acls] [--strict-acls] [--to-stdout]\n"
+"                    [--dest-dir=CMD_DIR] [--include-invalid-names]\n"
+),
+[CMD_INFO] =
+T(
+"    %"TS" WIMFILE [(IMAGE_NUM | IMAGE_NAME) [NEW_NAME\n"
+"                    [NEW_DESC]]] [--boot] [--check] [--nocheck] [--header]\n"
+"                    [--lookup-table] [--xml] [--extract-xml FILE]\n"
+"                    [--metadata]\n"
+),
+[CMD_JOIN] =
+T(
+"    %"TS" OUT_WIMFILE SPLIT_WIM_PART... [--check]\n"
+),
+#if WIM_MOUNTING_SUPPORTED
+[CMD_MOUNT] =
+T(
+"    %"TS" WIMFILE [(IMAGE_NUM | IMAGE_NAME)] DIRECTORY\n"
+"                    [--check] [--debug] [--streams-interface=INTERFACE]\n"
+"                    [--ref=\"GLOB\"] [--unix-data] [--allow-other]\n"
+),
+[CMD_MOUNTRW] =
+T(
+"    %"TS" WIMFILE [(IMAGE_NUM | IMAGE_NAME)] DIRECTORY\n"
+"                    [--check] [--debug] [--streams-interface=INTERFACE]\n"
+"                    [--staging-dir=CMD_DIR] [--unix-data] [--allow-other]\n"
+),
+#endif
+[CMD_OPTIMIZE] =
+T(
+"    %"TS" WIMFILE [--check] [--nocheck] [--recompress]\n"
+"                    [--recompress-slow] [--compress=TYPE]\n"
+"                    [--threads=NUM_THREADS] [--pipable] [--not-pipable]\n"
+),
+[CMD_SPLIT] =
+T(
+"    %"TS" WIMFILE SPLIT_WIM_PART_1 PART_SIZE_MB [--check]\n"
+),
+#if WIM_MOUNTING_SUPPORTED
+[CMD_UNMOUNT] =
+T(
+"    %"TS" DIRECTORY [--commit] [--check] [--rebuild] [--lazy]\n"
+),
+#endif
+[CMD_UPDATE] =
+T(
+"    %"TS" WIMFILE [IMAGE_NUM | IMAGE_NAME] [--check] [--rebuild]\n"
+"                    [--threads=NUM_THREADS] [DEFAULT_ADD_OPTIONS]\n"
+"                    [DEFAULT_DELETE_OPTIONS] [--command=STRING] [< CMDFILE]\n"
+),
 };
 
+static const tchar *invocation_name;
+static int invocation_cmd = CMD_NONE;
+
+static const tchar *get_cmd_string(int cmd, bool nospace)
+{
+       static tchar buf[50];
+       if (cmd == CMD_NONE) {
+               tsprintf(buf, T("%"TS), T(IMAGEX_PROGNAME));
+       } else if (invocation_cmd != CMD_NONE) {
+               tsprintf(buf, T("wim%"TS), imagex_commands[cmd].name);
+       } else {
+               const tchar *format;
+
+               if (nospace)
+                       format = T("%"TS"-%"TS"");
+               else
+                       format = T("%"TS" %"TS"");
+               tsprintf(buf, format, invocation_name, imagex_commands[cmd].name);
+       }
+       return buf;
+}
+
 static void
 version(void)
 {
@@ -3428,67 +3895,74 @@ IMAGEX_PROGNAME " (" PACKAGE ") " PACKAGE_VERSION "\n"
 
 
 static void
-help_or_version(int argc, tchar **argv)
+help_or_version(int argc, tchar **argv, int cmd)
 {
        int i;
        const tchar *p;
-       const struct imagex_command *cmd;
 
        for (i = 1; i < argc; i++) {
                p = argv[i];
-               if (*p == T('-'))
-                       p++;
-               else
-                       continue;
-               if (*p == T('-'))
-                       p++;
-               if (!tstrcmp(p, T("help"))) {
-                       for_imagex_command(cmd) {
-                               if (!tstrcmp(cmd->name, argv[1])) {
-                                       usage(cmd->cmd);
-                                       exit(0);
-                               }
+               if (p[0] == T('-') && p[1] == T('-')) {
+                       p += 2;
+                       if (!tstrcmp(p, T("help"))) {
+                               if (cmd == CMD_NONE)
+                                       usage_all(stdout);
+                               else
+                                       usage(cmd, stdout);
+                               exit(0);
+                       } else if (!tstrcmp(p, T("version"))) {
+                               version();
+                               exit(0);
                        }
-                       usage_all();
-                       exit(0);
-               }
-               if (!tstrcmp(p, T("version"))) {
-                       version();
-                       exit(0);
                }
        }
 }
 
+static void
+print_usage_string(int cmd, FILE *fp)
+{
+       tfprintf(fp, usage_strings[cmd], get_cmd_string(cmd, false));
+}
 
 static void
-usage(int cmd_type)
+recommend_man_page(int cmd, FILE *fp)
 {
-       const struct imagex_command *cmd;
-       tprintf(T("Usage:\n%"TS), usage_strings[cmd_type]);
-       for_imagex_command(cmd) {
-               if (cmd->cmd == cmd_type) {
-                       tputc(T('\n'), stdout);
-                       recommend_man_page(cmd->name);
-               }
-       }
+       const tchar *format_str;
+#ifdef __WIN32__
+       format_str = T("See %"TS".pdf in the doc directory for more details.\n");
+#else
+       format_str = T("Try `man %"TS"' for more details.\n");
+#endif
+       tfprintf(fp, format_str, get_cmd_string(cmd, true));
+}
+
+static void
+usage(int cmd, FILE *fp)
+{
+       tfprintf(fp, T("Usage:\n"));
+       print_usage_string(cmd, fp);
+       tfprintf(fp, T("\n"));
+       recommend_man_page(cmd, fp);
 }
 
 static void
-usage_all(void)
+usage_all(FILE *fp)
 {
-       tfputs(T("Usage:\n"), stdout);
-       for (int i = 0; i < ARRAY_LEN(usage_strings); i++)
-               tprintf(T("    %"TS), usage_strings[i]);
+       tfprintf(fp, T("Usage:\n"));
+       for (int cmd = 0; cmd < CMD_MAX; cmd++) {
+               print_usage_string(cmd, fp);
+               tfprintf(fp, T("\n"));
+       }
        static const tchar *extra =
        T(
-"    "IMAGEX_PROGNAME" --help\n"
-"    "IMAGEX_PROGNAME" --version\n"
+"    %"TS" --help\n"
+"    %"TS" --version\n"
 "\n"
 "    The compression TYPE may be \"maximum\", \"fast\", or \"none\".\n"
 "\n"
        );
-       tfputs(extra, stdout);
-       recommend_man_page(T(""));
+       tfprintf(fp, extra, invocation_name, invocation_name);
+       recommend_man_page(CMD_NONE, fp);
 }
 
 /* Entry point for wimlib's ImageX implementation.  On UNIX the command
@@ -3502,9 +3976,12 @@ wmain(int argc, wchar_t **argv, wchar_t **envp)
 main(int argc, char **argv)
 #endif
 {
-       const struct imagex_command *cmd;
        int ret;
        int init_flags = 0;
+       int cmd;
+
+       imagex_info_file = stdout;
+       invocation_name = tbasename(argv[0]);
 
 #ifndef __WIN32__
        if (getenv("WIMLIB_IMAGEX_USE_UTF8")) {
@@ -3519,67 +3996,89 @@ main(int argc, char **argv)
                    !strstr(codeset, "utf-8") &&
                    !strstr(codeset, "utf8"))
                {
-                       fputs(
-"WARNING: Running "IMAGEX_PROGNAME" in a UTF-8 locale is recommended!\n"
+                       fprintf(stderr,
+"WARNING: Running %"TS" in a UTF-8 locale is recommended!\n"
 "         Maybe try: `export LANG=en_US.UTF-8'?\n"
 "         Alternatively, set the environmental variable WIMLIB_IMAGEX_USE_UTF8\n"
 "         to any value to force wimlib to use UTF-8.\n",
-                       stderr);
+                       invocation_name);
 
                }
        }
 #endif /* !__WIN32__ */
 
-       if (argc < 2) {
-               imagex_error(T("No command specified"));
-               usage_all();
-               ret = 2;
-               goto out;
+       /* Allow being invoked as wimCOMMAND (e.g. wimapply).  */
+       cmd = CMD_NONE;
+       if (!tstrncmp(invocation_name, T("wim"), 3) &&
+           tstrcmp(invocation_name, T(IMAGEX_PROGNAME))) {
+               for (int i = 0; i < CMD_MAX; i++) {
+                       if (!tstrcmp(invocation_name + 3,
+                                    imagex_commands[i].name))
+                       {
+                               invocation_cmd = i;
+                               cmd = i;
+                               break;
+                       }
+               }
        }
 
-       /* Handle --help and --version for all commands.  Note that this will
-        * not return if either of these arguments are present. */
-       help_or_version(argc, argv);
-       argc--;
-       argv++;
+       /* Unless already known from the invocation name, determine which
+        * command was specified.  */
+       if (cmd == CMD_NONE) {
+               if (argc < 2) {
+                       imagex_error(T("No command specified!\n"));
+                       usage_all(stderr);
+                       exit(2);
+               }
+               for (int i = 0; i < CMD_MAX; i++) {
+                       if (!tstrcmp(argv[1], imagex_commands[i].name)) {
+                               cmd = i;
+                               break;
+                       }
+               }
+               if (cmd != CMD_NONE) {
+                       argc--;
+                       argv++;
+               }
+       }
 
-       /* The user may like to see more informative error messages. */
+       /* Handle --help and --version.  --help can be either for the program as
+        * a whole (cmd == CMD_NONE) or just for a specific command (cmd !=
+        * CMD_NONE).  Note: help_or_version() will not return if a --help or
+        * --version argument was found.  */
+       help_or_version(argc, argv, cmd);
+
+       /* Bail if a valid command was not specified.  */
+       if (cmd == CMD_NONE) {
+               imagex_error(T("Unrecognized command: `%"TS"'\n"), argv[1]);
+               usage_all(stderr);
+               exit(2);
+       }
+
+       /* Enable warning and error messages in wimlib be more user-friendly.
+        * */
        wimlib_set_print_errors(true);
 
-       /* Do any initializations that the library needs */
+       /* Initialize wimlib.  */
        ret = wimlib_global_init(init_flags);
        if (ret)
                goto out_check_status;
 
-       /* Search for the function to handle the ImageX subcommand. */
-       for_imagex_command(cmd) {
-               if (!tstrcmp(cmd->name, *argv)) {
-                       ret = cmd->func(argc, argv);
-                       goto out_check_write_error;
-               }
-       }
-
-       imagex_error(T("Unrecognized command: `%"TS"'"), argv[0]);
-       usage_all();
-       ret = 2;
-       goto out_cleanup;
-out_check_write_error:
-       /* For 'wimlib-imagex info' and 'wimlib-imagex dir', data printed to
-        * standard output is part of the program's actual behavior and not just
-        * for informational purposes, so we should set a failure exit status if
-        * there was a write error. */
-       if (cmd == &imagex_commands[INFO] || cmd == &imagex_commands[DIR]) {
-               if (ferror(stdout) || fclose(stdout)) {
-                       imagex_error_with_errno(T("error writing to standard output"));
-                       if (ret == 0)
-                               ret = -1;
-               }
+       /* Call the command handler function.  */
+       ret = imagex_commands[cmd].func(argc, argv, cmd);
+
+       /* Check for error writing to standard output, especially since for some
+        * commands, writing to standard output is part of the program's actual
+        * behavior and not just for informational purposes.  */
+       if (ferror(stdout) || fclose(stdout)) {
+               imagex_error_with_errno(T("error writing to standard output"));
+               if (ret == 0)
+                       ret = -1;
        }
 out_check_status:
        /* Exit status (ret):  -1 indicates an error found by 'wimlib-imagex'
-        * outside of the wimlib library code.  0 indicates success.  > 0
-        * indicates a wimlib error code from which an error message can be
-        * printed. */
+        * itself (not by wimlib).  0 indicates success.  > 0 indicates a wimlib
+        * error code from which an error message can be printed.  */
        if (ret > 0) {
                imagex_error(T("Exiting with error code %d:\n"
                               "       %"TS"."), ret,
@@ -3587,10 +4086,8 @@ out_check_status:
                if (ret == WIMLIB_ERR_NTFS_3G && errno != 0)
                        imagex_error_with_errno(T("errno"));
        }
-out_cleanup:
-       /* Make the library free any resources it's holding (not strictly
-        * necessary because the process is ending anyway). */
+       /* Make wimlib free any resources it's holding (although this is not
+        * strictly necessary because the process is ending anyway).  */
        wimlib_global_cleanup();
-out:
        return ret;
 }