translate_text_to_tstr(): Correctly compare byte values
[wimlib] / programs / imagex.c
index 0a1f77b..772b86e 100644 (file)
 #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 <glob.h>
 #  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"
-),
-[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)\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"
-),
-[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] < 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_COMMAND_OPTION,
        IMAGEX_COMMIT_OPTION,
        IMAGEX_COMPRESS_OPTION,
        IMAGEX_CONFIG_OPTION,
        IMAGEX_DEBUG_OPTION,
+       IMAGEX_DELTA_FROM_OPTION,
        IMAGEX_DEREFERENCE_OPTION,
        IMAGEX_DEST_DIR_OPTION,
        IMAGEX_EXTRACT_XML_OPTION,
@@ -208,15 +133,21 @@ enum {
        IMAGEX_FORCE_OPTION,
        IMAGEX_HARDLINK_OPTION,
        IMAGEX_HEADER_OPTION,
+       IMAGEX_INCLUDE_INVALID_NAMES_OPTION,
        IMAGEX_LAZY_OPTION,
        IMAGEX_LOOKUP_TABLE_OPTION,
        IMAGEX_METADATA_OPTION,
        IMAGEX_NORPFIX_OPTION,
+       IMAGEX_NOCHECK_OPTION,
        IMAGEX_NO_ACLS_OPTION,
+       IMAGEX_NOT_PIPABLE_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,
@@ -227,6 +158,7 @@ enum {
        IMAGEX_THREADS_OPTION,
        IMAGEX_TO_STDOUT_OPTION,
        IMAGEX_UNIX_DATA_OPTION,
+       IMAGEX_UPDATE_OF_OPTION,
        IMAGEX_VERBOSE_OPTION,
        IMAGEX_XML_OPTION,
 };
@@ -243,11 +175,18 @@ static const struct option apply_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("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("config"),      required_argument, NULL, IMAGEX_CONFIG_OPTION},
        {T("dereference"), no_argument,       NULL, IMAGEX_DEREFERENCE_OPTION},
@@ -262,21 +201,35 @@ 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},
        {NULL, 0, NULL, 0},
 };
 
+static const struct option dir_options[] = {
+       {T("path"), required_argument, NULL, IMAGEX_PATH_OPTION},
+       {NULL, 0, NULL, 0},
+};
+
 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},
 };
 
@@ -290,12 +243,15 @@ static const struct option extract_options[] = {
        {T("strict-acls"), no_argument,       NULL, IMAGEX_STRICT_ACLS_OPTION},
        {T("dest-dir"),    required_argument, NULL, IMAGEX_DEST_DIR_OPTION},
        {T("to-stdout"),   no_argument,       NULL, IMAGEX_TO_STDOUT_OPTION},
+       {T("include-invalid-names"), no_argument, NULL, IMAGEX_INCLUDE_INVALID_NAMES_OPTION},
        {NULL, 0, NULL, 0},
 };
 
 static const struct option info_options[] = {
        {T("boot"),         no_argument,       NULL, IMAGEX_BOOT_OPTION},
        {T("check"),        no_argument,       NULL, IMAGEX_CHECK_OPTION},
+       {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},
@@ -321,9 +277,13 @@ 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("recompress"),  no_argument,       NULL, IMAGEX_RECOMPRESS_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},
 };
 
@@ -348,6 +308,7 @@ static const struct option update_options[] = {
        {T("threads"),     required_argument, NULL, IMAGEX_THREADS_OPTION},
        {T("check"),       no_argument,       NULL, IMAGEX_CHECK_OPTION},
        {T("rebuild"),     no_argument,       NULL, IMAGEX_REBUILD_OPTION},
+       {T("command"),     required_argument, NULL, IMAGEX_COMMAND_OPTION},
 
        /* Default delete options */
        {T("force"),       no_argument,       NULL, IMAGEX_FORCE_OPTION},
@@ -363,11 +324,19 @@ static const struct option update_options[] = {
        {T("noacls"),      no_argument,       NULL, IMAGEX_NO_ACLS_OPTION},
        {T("no-acls"),     no_argument,       NULL, IMAGEX_NO_ACLS_OPTION},
        {T("strict-acls"), no_argument,       NULL, IMAGEX_STRICT_ACLS_OPTION},
+
        {NULL, 0, NULL, 0},
 };
 
+#if 0
+#      define _format_attribute(type, format_str, args_start) \
+                       __attribute__((format(type, format_str, args_start)))
+#else
+#      define _format_attribute(type, format_str, args_start)
+#endif
+
 /* Print formatted error message to stderr. */
-static void
+static void _format_attribute(printf, 1, 2)
 imagex_error(const tchar *format, ...)
 {
        va_list va;
@@ -379,7 +348,7 @@ imagex_error(const tchar *format, ...)
 }
 
 /* Print formatted error message to stderr. */
-static void
+static void _format_attribute(printf, 1, 2)
 imagex_error_with_errno(const tchar *format, ...)
 {
        int errno_save = errno;
@@ -397,11 +366,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;
 }
@@ -411,7 +382,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;
 }
@@ -444,6 +415,75 @@ get_compression_type(const tchar *optarg)
        }
 }
 
+struct refglob_set {
+       const tchar **globs;
+       unsigned num_globs;
+       unsigned num_alloc_globs;
+};
+
+#define REFGLOB_SET_INITIALIZER \
+       { .globs = NULL, .num_globs = 0, .num_alloc_globs = 0, }
+
+#define REFGLOB_SET(_refglobs) \
+       struct refglob_set _refglobs = REFGLOB_SET_INITIALIZER
+
+static int
+refglob_set_append(struct refglob_set *set, const tchar *glob)
+{
+       unsigned num_alloc_globs = set->num_alloc_globs;
+
+       if (set->num_globs == num_alloc_globs) {
+               const tchar **new_globs;
+
+               num_alloc_globs += 4;
+               new_globs = realloc(set->globs, sizeof(set->globs[0]) * num_alloc_globs);
+               if (!new_globs) {
+                       imagex_error(T("Out of memory!"));
+                       return -1;
+               }
+               set->globs = new_globs;
+               set->num_alloc_globs = num_alloc_globs;
+       }
+       set->globs[set->num_globs++] = glob;
+       return 0;
+}
+
+static int
+wim_reference_globs(WIMStruct *wim, struct refglob_set *set, int open_flags)
+{
+       return wimlib_reference_resource_files(wim, set->globs, set->num_globs,
+                                              WIMLIB_REF_FLAG_GLOB_ENABLE,
+                                              open_flags,
+                                              imagex_progress_func);
+}
+
+static void
+refglob_set_destroy(struct refglob_set *set)
+{
+       free(set->globs);
+}
+
+static void
+do_resource_not_found_warning(const tchar *wimfile,
+                             const struct wimlib_wim_info *info,
+                             const struct refglob_set *refglobs)
+{
+       if (info->total_parts > 1) {
+               if (refglobs->num_globs == 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 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
@@ -456,29 +496,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),
-               .pats = default_pats,
-       },
-};
-
 enum {
        PARSE_STRING_SUCCESS = 0,
        PARSE_STRING_FAILURE = 1,
@@ -843,7 +860,7 @@ file_get_contents(const tchar *filename, size_t *len_ret)
                goto out;
        }
 
-       buf = malloc(len);
+       buf = malloc(len ? len : 1);
        if (!buf) {
                imagex_error(T("Failed to allocate buffer of %zu bytes to hold "
                               "contents of file \"%"TS"\""), len, filename);
@@ -920,8 +937,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
@@ -968,18 +985,6 @@ stdin_get_text_contents(size_t *num_tchars_ret)
        return translate_text_to_tstr(contents, num_bytes, num_tchars_ret);
 }
 
-/* Return 0 if a path names a file to which the current user has write access;
- * -1 otherwise (and print an error message). */
-static int
-file_writable(const tchar *path)
-{
-       int ret;
-       ret = taccess(path, W_OK);
-       if (ret != 0)
-               imagex_error_with_errno(T("Can't modify \"%"TS"\""), path);
-       return ret;
-}
-
 #define TO_PERCENT(numerator, denominator) \
        (((denominator) == 0) ? 0 : ((numerator) * 100 / (denominator)))
 
@@ -999,76 +1004,132 @@ get_data_type(int ctype)
        return NULL;
 }
 
+#define GIBIBYTE_MIN_NBYTES 10000000000ULL
+#define MEBIBYTE_MIN_NBYTES 10000000ULL
+#define KIBIBYTE_MIN_NBYTES 10000ULL
+
+static unsigned
+get_unit(uint64_t total_bytes, const tchar **name_ret)
+{
+       if (total_bytes >= GIBIBYTE_MIN_NBYTES) {
+               *name_ret = T("GiB");
+               return 30;
+       } else if (total_bytes >= MEBIBYTE_MIN_NBYTES) {
+               *name_ret = T("MiB");
+               return 20;
+       } else if (total_bytes >= KIBIBYTE_MIN_NBYTES) {
+               *name_ret = T("KiB");
+               return 10;
+       } else {
+               *name_ret = T("bytes");
+               return 0;
+       }
+}
+
 /* Progress callback function passed to various wimlib functions. */
 static int
 imagex_progress_func(enum wimlib_progress_msg msg,
                     const union wimlib_progress_info *info)
 {
        unsigned percent_done;
+       unsigned unit_shift;
+       const tchar *unit_name;
        if (imagex_be_quiet)
                return 0;
        switch (msg) {
        case WIMLIB_PROGRESS_MSG_WRITE_STREAMS:
+               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"),
+                       imagex_printf(T("Writing %"TS" data using %u thread%"TS"\n"),
                                data_type, info->write_streams.num_threads,
                                (info->write_streams.num_threads == 1) ? T("") : T("s"));
                }
-               tprintf(T("\r%"PRIu64" MiB of %"PRIu64" MiB (uncompressed) "
-                       "written (%u%% done)"),
-                       info->write_streams.completed_bytes >> 20,
-                       info->write_streams.total_bytes >> 20,
-                       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: \"/%"TS"\")...\n"),
+                       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" MiB "
-                       "of %"PRIu64" MiB (%u%%) done"),
+               imagex_printf(T("\rVerifying integrity of \"%"TS"\": %"PRIu64" %"TS" "
+                       "of %"PRIu64" %"TS" (%u%%) done"),
                        info->integrity.filename,
-                       info->integrity.completed_bytes >> 20,
-                       info->integrity.total_bytes >> 20,
+                       info->integrity.completed_bytes >> unit_shift,
+                       unit_name,
+                       info->integrity.total_bytes >> unit_shift,
+                       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" MiB "
-                         "of %"PRIu64" MiB (%u%%) done"),
-                       info->integrity.completed_bytes >> 20,
-                       info->integrity.total_bytes >> 20,
+               imagex_printf(T("\rCalculating integrity table for WIM: %"PRIu64" %"TS" "
+                         "of %"PRIu64" %"TS" (%u%%) done"),
+                       info->integrity.completed_bytes >> unit_shift,
+                       unit_name,
+                       info->integrity.total_bytes >> unit_shift,
+                       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,
@@ -1078,7 +1139,8 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                        info->extract.target);
                break;
        case WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN:
-               tprintf(T("Extracting \"%"TS"\" from image %d (\"%"TS"\") "
+               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,
                        info->extract.image,
@@ -1086,133 +1148,85 @@ 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);
-               tprintf(T("\rExtracting files: "
-                         "%"PRIu64" MiB of %"PRIu64" MiB (%u%%) done"),
-                       info->extract.completed_bytes >> 20,
-                       info->extract.total_bytes >> 20,
+               unit_shift = get_unit(info->extract.total_bytes, &unit_name);
+               imagex_printf(T("\rExtracting files: "
+                         "%"PRIu64" %"TS" of %"PRIu64" %"TS" (%u%%) done"),
+                       info->extract.completed_bytes >> unit_shift,
+                       unit_name,
+                       info->extract.total_bytes >> unit_shift,
+                       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);
-               tprintf(T("Writing resources from part %u of %u: "
-                         "%"PRIu64 " MiB of %"PRIu64" MiB (%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 >> 20,
-                       info->join.total_bytes >> 20,
-                       percent_done);
-               break;
        case WIMLIB_PROGRESS_MSG_SPLIT_BEGIN_PART:
                percent_done = TO_PERCENT(info->split.completed_bytes,
                                          info->split.total_bytes);
-               tprintf(T("Writing \"%"TS"\": %"PRIu64" MiB of "
-                         "%"PRIu64" MiB (%u%%) written\n"),
+               unit_shift = get_unit(info->split.total_bytes, &unit_name);
+               imagex_printf(T("Writing \"%"TS"\" (part %u of %u): %"PRIu64" %"TS" of "
+                         "%"PRIu64" %"TS" (%u%%) written\n"),
                        info->split.part_name,
-                       info->split.completed_bytes >> 20,
-                       info->split.total_bytes >> 20,
+                       info->split.cur_part_number,
+                       info->split.total_parts,
+                       info->split.completed_bytes >> unit_shift,
+                       unit_name,
+                       info->split.total_bytes >> unit_shift,
+                       unit_name,
                        percent_done);
                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:
+                       imagex_printf(T("Deleted WIM path "
+                                 "\""WIMLIB_WIM_PATH_SEPARATOR_STRING "%"TS"\"\n"),
+                               info->update.command->delete_.wim_path);
+                       break;
+               case WIMLIB_UPDATE_OP_RENAME:
+                       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,
+                               info->update.command->rename.wim_target_path);
+                       break;
+               case WIMLIB_UPDATE_OP_ADD:
+               default:
+                       break;
                }
                break;
        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 != 0) {
-               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 != 0)
-                       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)
 {
@@ -1247,23 +1261,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;
@@ -1294,7 +1308,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)
@@ -1374,7 +1388,7 @@ parse_update_command(tchar *line, size_t len,
                                imagex_error(T("Unexpected argument \"%"TS"\" in "
                                               "update command on line %zu\n"
                                               "       (The \"%"TS"\" command only "
-                                              "takes %u nonoption arguments!)\n"),
+                                              "takes %zu nonoption arguments!)\n"),
                                             next_string, line_number,
                                             command_name, num_nonoptions);
                                return false;
@@ -1435,24 +1449,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 num_images;
-       WIMStruct *w;
+       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;
+       const tchar *image_num_or_name = NULL;
        int extract_flags = WIMLIB_EXTRACT_FLAG_SEQUENTIAL;
 
-       const tchar *swm_glob = NULL;
-       WIMStruct **additional_swms = NULL;
-       unsigned num_additional_swms = 0;
+       REFGLOB_SET(refglobs);
 
        for_opt(c, apply_options) {
                switch (c) {
@@ -1469,7 +1481,9 @@ imagex_apply(int argc, tchar **argv)
                        extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
                        break;
                case IMAGEX_REF_OPTION:
-                       swm_glob = optarg;
+                       ret = refglob_set_append(&refglobs, optarg);
+                       if (ret)
+                               goto out_free_refglobs;
                        break;
                case IMAGEX_UNIX_DATA_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_UNIX_DATA;
@@ -1486,87 +1500,129 @@ imagex_apply(int argc, tchar **argv)
                case IMAGEX_RPFIX_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_RPFIX;
                        break;
+               case IMAGEX_INCLUDE_INVALID_NAMES_OPTION:
+                       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:
-                       usage(APPLY);
-                       return -1;
+                       goto out_usage;
                }
        }
        argc -= optind;
        argv += optind;
-       if (argc != 2 && argc != 3) {
-               usage(APPLY);
-               return -1;
-       }
+       if (argc != 2 && argc != 3)
+               goto out_usage;
 
        wimfile = argv[0];
-       if (argc == 2) {
-               image_num_or_name = T("1");
-               target = argv[1];
-       } else {
-               image_num_or_name = argv[1];
-               target = argv[2];
-       }
 
-       ret = wimlib_open_wim(wimfile, open_flags, &w, imagex_progress_func);
-       if (ret != 0)
-               return ret;
+       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 {
+               ret = wimlib_open_wim(wimfile, open_flags, &wim,
+                                     imagex_progress_func);
+               if (ret)
+                       goto out_free_refglobs;
 
-       image = wimlib_resolve_image(w, image_num_or_name);
-       ret = verify_image_exists(image, image_num_or_name, wimfile);
-       if (ret != 0)
-               goto out;
+               wimlib_get_wim_info(wim, &info);
 
-       num_images = wimlib_get_num_images(w);
-       if (argc == 2 && num_images != 1) {
-               imagex_error(T("\"%"TS"\" contains %d images; Please select one "
-                              "(or all)."), wimfile, num_images);
-               usage(APPLY);
-               ret = -1;
-               goto out;
+               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];
+               }
        }
 
-       if (swm_glob) {
-               ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
-                                         &additional_swms,
-                                         &num_additional_swms);
-               if (ret != 0)
-                       goto out;
+       if (refglobs.num_globs) {
+               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;
        }
 
-       struct stat stbuf;
+#ifndef __WIN32__
+       {
+               /* Interpret a regular file or block device target as a NTFS
+                * volume.  */
+               struct stat stbuf;
 
-       ret = tstat(target, &stbuf);
-       if (ret == 0) {
-               if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode))
-                       extract_flags |= WIMLIB_EXTRACT_FLAG_NTFS;
-       } else {
-               if (errno != ENOENT) {
-                       imagex_error_with_errno(T("Failed to stat \"%"TS"\""),
-                                               target);
-                       ret = -1;
-                       goto out;
+               if (tstat(target, &stbuf)) {
+                       if (errno != ENOENT) {
+                               imagex_error_with_errno(T("Failed to stat \"%"TS"\""),
+                                                       target);
+                               ret = -1;
+                               goto out_wimlib_free;
+                       }
+               } else {
+                       if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode))
+                               extract_flags |= WIMLIB_EXTRACT_FLAG_NTFS;
                }
        }
-
-#ifdef __WIN32__
-       win32_acquire_restore_privileges();
 #endif
-       ret = wimlib_extract_image(w, 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:
-       wimlib_free(w);
-       if (additional_swms) {
-               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_free_refglobs:
+       refglob_set_destroy(&refglobs);
        return ret;
+
+out_usage:
+       usage(CMD_APPLY, stderr);
+       ret = -1;
+       goto out_free_refglobs;
 }
 
 /* Create a WIM image from a directory tree, NTFS volume, or multiple files or
@@ -1574,37 +1630,45 @@ out:
  * 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 = 0;
-       int add_image_flags = WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE;
+       int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
+       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_LZX;
        const tchar *wimfile;
+       int wim_fd;
        const tchar *name;
        const tchar *desc;
        const tchar *flags_element = NULL;
-       WIMStruct *w;
+
+       WIMStruct *wim;
+       WIMStruct *base_wim;
+       const tchar *base_wimfile = NULL;
+       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 cur_image;
-       int cmd = tstrcmp(argv[0], T("append")) ? CAPTURE : APPEND;
        unsigned num_threads = 0;
 
        tchar *source;
-       size_t source_name_len;
        tchar *source_copy;
 
        const tchar *config_file = NULL;
        tchar *config_str;
-       struct wimlib_capture_config *config = NULL;
+       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;
        size_t num_sources;
+       bool name_defaulted;
 
        for_opt(c, capture_or_append_options) {
                switch (c) {
@@ -1615,13 +1679,17 @@ 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)
-                               return -1;
+                               goto out_err;
                        break;
                case IMAGEX_FLAGS_OPTION:
                        flags_element = optarg;
@@ -1635,7 +1703,7 @@ imagex_capture_or_append(int argc, tchar **argv)
                case IMAGEX_THREADS_OPTION:
                        num_threads = parse_num_threads(optarg);
                        if (num_threads == UINT_MAX)
-                               return -1;
+                               goto out_err;
                        break;
                case IMAGEX_REBUILD_OPTION:
                        write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
@@ -1658,34 +1726,122 @@ 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;
+                       }
+                       if (base_wimfile) {
+                               imagex_error(T("'--delta-from' can only be "
+                                              "specified one time!"));
+                               goto out_err;
+                       }
+                       base_wimfile = optarg;
+                       write_flags |= WIMLIB_WRITE_FLAG_SKIP_EXTERNAL_WIMS;
+                       break;
                default:
-                       usage(cmd);
-                       return -1;
+                       goto out_usage;
                }
        }
        argc -= optind;
        argv += optind;
 
-       if (argc < 2 || argc > 4) {
-               usage(cmd);
-               return -1;
-       }
+       if (argc < 2 || argc > 4)
+               goto out_usage;
 
        source = argv[0];
        wimfile = argv[1];
 
-       if (argc >= 3) {
-               name = argv[2];
+       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_wimfile) {
+                       /* Capturing delta WIM:  default to base WIM.  */
+                       template_wimfile = base_wimfile;
+               } 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.  */
+                       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;
        } else {
                /* Set default name to SOURCE argument, omitting any directory
                 * prefixes and trailing slashes.  This requires making a copy
-                * of @source. */
+                * of @source.  Leave some free characters at the end in case we
+                * append a number to keep the name unique. */
+               size_t source_name_len;
+
                source_name_len = tstrlen(source);
-               source_copy = alloca((source_name_len + 1) * sizeof(tchar));
+               source_copy = alloca((source_name_len + 1 + 25) * sizeof(tchar));
                name = tbasename(tstrcpy(source_copy, source));
+               name_defaulted = true;
        }
        /* Image description defaults to NULL if not given. */
-       desc = (argc >= 4) ? argv[3] : NULL;
+       if (argc >= 4)
+               desc = argv[3];
+       else
+               desc = NULL;
 
        if (source_list) {
                /* Set up capture sources in source list mode */
@@ -1696,7 +1852,7 @@ imagex_capture_or_append(int argc, tchar **argv)
                                                                      &source_list_nchars);
                }
                if (!source_list_contents)
-                       return -1;
+                       goto out_err;
 
                capture_sources = parse_source_list(&source_list_contents,
                                                    source_list_nchars,
@@ -1707,8 +1863,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;
@@ -1719,6 +1874,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);
@@ -1732,23 +1888,30 @@ 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)
-               ret = wimlib_open_wim(wimfile, open_flags, &w,
+       /* 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
-               ret = wimlib_create_new_wim(compression_type, &w);
+               ret = wimlib_create_new_wim(compression_type, &wim);
        if (ret)
                goto out_free_config;
 
+#ifndef __WIN32__
+       /* Detect if source is regular file or block device and set NTFS volume
+        * capture mode.  */
        if (!source_list) {
                struct stat stbuf;
-               ret = tstat(source, &stbuf);
-               if (ret == 0) {
+
+               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;
                        }
@@ -1757,54 +1920,159 @@ 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;
                        }
                }
        }
-#ifdef __WIN32__
-       win32_acquire_capture_privileges();
 #endif
 
-       ret = wimlib_add_image_multisource(w,
+       /* 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;
+                    wimlib_image_name_in_use(wim, name);
+                    conflict_idx++)
+               {
+                       tsprintf(name_end, T(" (%lu)"), conflict_idx);
+               }
+       }
+
+       /* If capturing a delta WIM, reference resources from the base WIM
+        * before adding the new image.  */
+       if (base_wimfile) {
+               ret = wimlib_open_wim(base_wimfile, open_flags,
+                                     &base_wim, imagex_progress_func);
+               if (ret)
+                       goto out_free_wim;
+
+               imagex_printf(T("Capturing delta WIM based on \"%"TS"\"\n"),
+                             base_wimfile);
+
+               ret = wimlib_reference_resources(wim, &base_wim, 1, 0);
+               if (ret)
+                       goto out_free_base_wim;
+       } else {
+               base_wim = 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 (template_wimfile == base_wimfile) {
+                       template_wim = base_wim;
+               } 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_wim;
+               }
+
+               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(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,
                                           num_sources,
                                           name,
                                           config,
                                           add_image_flags,
                                           imagex_progress_func);
-       if (ret != 0)
-               goto out_release_privs;
-       cur_image = wimlib_get_num_images(w);
-       if (desc) {
-               ret = wimlib_set_image_descripton(w, cur_image, desc);
-               if (ret != 0)
-                       goto out_release_privs;
-       }
-       if (flags_element) {
-               ret = wimlib_set_image_flags(w, cur_image, flags_element);
-               if (ret != 0)
-                       goto out_release_privs;
-       }
-       if (cmd == APPEND) {
-               ret = wimlib_overwrite(w, write_flags, num_threads,
+       if (ret)
+               goto out_free_template_wim;
+
+       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);
+
+               if (desc) {
+                       ret = wimlib_set_image_descripton(wim,
+                                                         info.image_count,
+                                                         desc);
+                       if (ret)
+                               goto out_free_template_wim;
+               }
+
+               if (flags_element) {
+                       ret = wimlib_set_image_flags(wim, info.image_count,
+                                                    flags_element);
+                       if (ret)
+                               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;
+               }
+       }
+
+       /* 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(w, wimfile, WIMLIB_ALL_IMAGES, write_flags,
-                                  num_threads, imagex_progress_func);
-       }
-       if (ret == WIMLIB_ERR_REOPEN)
-               ret = 0;
-       if (ret != 0)
-               imagex_error(T("Failed to write the WIM file \"%"TS"\""),
-                            wimfile);
-out_release_privs:
-#ifdef __WIN32__
-       win32_release_capture_privileges();
-#endif
-out_wimlib_free:
-       wimlib_free(w);
+               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_wim or wim.  */
+       if (template_wim != base_wim && template_wim != wim)
+               wimlib_free(template_wim);
+out_free_base_wim:
+       wimlib_free(base_wim);
+out_free_wim:
+       wimlib_free(wim);
 out_free_config:
-       if (config != NULL && config != &default_capture_config) {
+       if (config) {
                free(config->exclusion_pats.pats);
                free(config->exclusion_exception_pats.pats);
                free(config_str);
@@ -1814,19 +2082,26 @@ out_free_capture_sources:
                free(capture_sources);
 out_free_source_list_contents:
        free(source_list_contents);
+out:
        return ret;
+
+out_usage:
+       usage(cmd, stderr);
+out_err:
+       ret = -1;
+       goto out;
 }
 
 /* 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 = 0;
+       int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
        int write_flags = 0;
        const tchar *wimfile;
        const tchar *image_num_or_name;
-       WIMStruct *w;
+       WIMStruct *wim;
        int image;
        int ret;
 
@@ -1840,8 +2115,7 @@ imagex_delete(int argc, tchar **argv)
                        write_flags |= WIMLIB_WRITE_FLAG_SOFT_DELETE;
                        break;
                default:
-                       usage(DELETE);
-                       return -1;
+                       goto out_usage;
                }
        }
        argc -= optind;
@@ -1852,122 +2126,150 @@ imagex_delete(int argc, tchar **argv)
                        imagex_error(T("Must specify a WIM file"));
                if (argc < 2)
                        imagex_error(T("Must specify an image"));
-               usage(DELETE);
-               return -1;
+               goto out_usage;
        }
        wimfile = argv[0];
        image_num_or_name = argv[1];
 
-       ret = file_writable(wimfile);
-       if (ret != 0)
-               return ret;
-
-       ret = wimlib_open_wim(wimfile, open_flags, &w,
+       ret = wimlib_open_wim(wimfile, open_flags, &wim,
                              imagex_progress_func);
-       if (ret != 0)
-               return ret;
+       if (ret)
+               goto out;
 
-       image = wimlib_resolve_image(w, image_num_or_name);
+       image = wimlib_resolve_image(wim, image_num_or_name);
 
        ret = verify_image_exists(image, image_num_or_name, wimfile);
-       if (ret != 0)
-               goto out;
+       if (ret)
+               goto out_wimlib_free;
 
-       ret = wimlib_delete_image(w, image);
-       if (ret != 0) {
-               imagex_error(T("Failed to delete image from \"%"TS"\""), wimfile);
-               goto out;
+       ret = wimlib_delete_image(wim, image);
+       if (ret) {
+               imagex_error(T("Failed to delete image from \"%"TS"\""),
+                            wimfile);
+               goto out_wimlib_free;
        }
 
-       ret = wimlib_overwrite(w, write_flags, 0, imagex_progress_func);
-       if (ret == WIMLIB_ERR_REOPEN)
-               ret = 0;
-       if (ret != 0) {
+       ret = wimlib_overwrite(wim, write_flags, 0, imagex_progress_func);
+       if (ret) {
                imagex_error(T("Failed to write the file \"%"TS"\" with image "
                               "deleted"), wimfile);
        }
+out_wimlib_free:
+       wimlib_free(wim);
 out:
-       wimlib_free(w);
        return ret;
+
+out_usage:
+       usage(CMD_DELETE, stderr);
+       ret = -1;
+       goto out;
+}
+
+static int
+print_full_path(const struct wimlib_dir_entry *wdentry, void *_ignore)
+{
+       int ret = tprintf(T("%"TS"\n"), wdentry->full_path);
+       return (ret >= 0) ? 0 : -1;
 }
 
 /* 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 *w;
+       WIMStruct *wim = NULL;
        int image;
        int ret;
-       int num_images;
+       const tchar *path = T("");
+       int c;
 
-       if (argc < 2) {
+       for_opt(c, dir_options) {
+               switch (c) {
+               case IMAGEX_PATH_OPTION:
+                       path = optarg;
+                       break;
+               default:
+                       goto out_usage;
+               }
+       }
+       argc -= optind;
+       argv += optind;
+
+       if (argc < 1) {
                imagex_error(T("Must specify a WIM file"));
-               usage(DIR);
-               return -1;
+               goto out_usage;
        }
-       if (argc > 3) {
+       if (argc > 2) {
                imagex_error(T("Too many arguments"));
-               usage(DIR);
-               return -1;
+               goto out_usage;
        }
 
-       wimfile = argv[1];
-       ret = wimlib_open_wim(wimfile, WIMLIB_OPEN_FLAG_SPLIT_OK, &w,
+       wimfile = argv[0];
+       ret = wimlib_open_wim(wimfile, WIMLIB_OPEN_FLAG_SPLIT_OK, &wim,
                              imagex_progress_func);
-       if (ret != 0)
-               return ret;
-
-       if (argc == 3) {
-               image = wimlib_resolve_image(w, argv[2]);
-               ret = verify_image_exists(image, argv[2], wimfile);
-               if (ret != 0)
-                       goto out;
+       if (ret)
+               goto out;
+
+       if (argc >= 2) {
+               image = wimlib_resolve_image(wim, argv[1]);
+               ret = verify_image_exists(image, argv[1], wimfile);
+               if (ret)
+                       goto out_wimlib_free;
        } else {
-               /* Image was not specified.  If the WIM only contains one image,
-                * choose that one; otherwise, print an error. */
-               num_images = wimlib_get_num_images(w);
-               if (num_images != 1) {
+               /* 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, num_images);
-                       usage(DIR);
-                       ret = -1;
-                       goto out;
+                                      "select one (or all)."),
+                                    wimfile, info.image_count);
+                       wimlib_free(wim);
+                       goto out_usage;
                }
                image = 1;
        }
 
-       ret = wimlib_print_files(w, image);
+       ret = wimlib_iterate_dir_tree(wim, image, path,
+                                     WIMLIB_ITERATE_DIR_TREE_FLAG_RECURSIVE,
+                                     print_full_path, NULL);
+out_wimlib_free:
+       wimlib_free(wim);
 out:
-       wimlib_free(w);
        return ret;
+
+out_usage:
+       usage(CMD_DIR, stderr);
+       ret = -1;
+       goto out;
 }
 
 /* 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;
        int export_flags = 0;
        int write_flags = 0;
-       int compression_type = WIMLIB_COMPRESSION_TYPE_NONE;
-       bool compression_type_specified = false;
+       int compression_type = WIMLIB_COMPRESSION_TYPE_INVALID;
        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_w = NULL;
-       WIMStruct *dest_w = NULL;
+       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 = NULL;
-       unsigned num_additional_swms = 0;
+       REFGLOB_SET(refglobs);
        unsigned num_threads = 0;
 
        for_opt(c, export_options) {
@@ -1979,51 +2281,79 @@ 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)
-                               return -1;
-                       compression_type_specified = true;
+                               goto out_err;
                        break;
                case IMAGEX_REF_OPTION:
-                       swm_glob = optarg;
+                       ret = refglob_set_append(&refglobs, optarg);
+                       if (ret)
+                               goto out_free_refglobs;
                        break;
                case IMAGEX_THREADS_OPTION:
                        num_threads = parse_num_threads(optarg);
                        if (num_threads == UINT_MAX)
-                               return -1;
+                               goto out_err;
                        break;
                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:
-                       usage(EXPORT);
-                       return -1;
+                       goto out_usage;
                }
        }
        argc -= optind;
        argv += optind;
-       if (argc < 3 || argc > 5) {
-               usage(EXPORT);
-               return -1;
-       }
+       if (argc < 3 || argc > 5)
+               goto out_usage;
        src_wimfile           = argv[0];
        src_image_num_or_name = argv[1];
        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_w,
+                             open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK, &src_wim,
                              imagex_progress_func);
-       if (ret != 0)
-               return ret;
-
-       /* 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) {
-               int dest_ctype;
-
+       if (ret)
+               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. */
 
@@ -2031,82 +2361,106 @@ imagex_export(int argc, tchar **argv)
                        imagex_error(T("\"%"TS"\" is not a regular file"),
                                     dest_wimfile);
                        ret = -1;
-                       goto out;
+                       goto out_free_src_wim;
                }
-               ret = wimlib_open_wim(dest_wimfile, open_flags, &dest_w,
-                                     imagex_progress_func);
-               if (ret != 0)
-                       goto out;
-
-               ret = file_writable(dest_wimfile);
-               if (ret != 0)
-                       goto out;
-
-               dest_ctype = wimlib_get_compression_type(dest_w);
-               if (compression_type_specified
-                   && compression_type != dest_ctype)
-               {
-                       imagex_error(T("Cannot specify a compression type that is "
-                                      "not the same as that used in the "
-                                      "destination WIM"));
-                       ret = -1;
-                       goto out;
+               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;
+
+               if (compression_type != WIMLIB_COMPRESSION_TYPE_INVALID) {
+                       /* The user specified a compression type, but we're
+                        * exporting to an existing WIM.  Make sure the
+                        * specified compression type is the same as the
+                        * compression type of the existing destination WIM. */
+                       struct wimlib_wim_info dest_info;
+
+                       wimlib_get_wim_info(dest_wim, &dest_info);
+                       if (compression_type != dest_info.compression_type) {
+                               imagex_error(T("Cannot specify a compression type that is "
+                                              "not the same as that used in the "
+                                              "destination WIM"));
+                               ret = -1;
+                               goto out_free_dest_wim;
+                       }
                }
        } else {
                wim_is_new = true;
-               /* dest_wimfile is not an existing file, so create a new WIM. */
-               if (!compression_type_specified)
-                       compression_type = wimlib_get_compression_type(src_w);
-               if (errno == ENOENT) {
-                       ret = wimlib_create_new_wim(compression_type, &dest_w);
-                       if (ret != 0)
-                               goto out;
-               } else {
+
+               if (errno != ENOENT) {
                        imagex_error_with_errno(T("Cannot stat file \"%"TS"\""),
                                                dest_wimfile);
                        ret = -1;
-                       goto out;
+                       goto out_free_src_wim;
+               }
+
+               /* dest_wimfile is not an existing file, so create a new WIM. */
+
+               if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID) {
+                       /* The user did not specify a compression type; default
+                        * to that of the source WIM.  */
+
+                       compression_type = src_info.compression_type;
                }
+               ret = wimlib_create_new_wim(compression_type, &dest_wim);
+               if (ret)
+                       goto out_free_src_wim;
        }
 
-       image = wimlib_resolve_image(src_w, src_image_num_or_name);
+       image = wimlib_resolve_image(src_wim, src_image_num_or_name);
        ret = verify_image_exists(image, src_image_num_or_name, src_wimfile);
-       if (ret != 0)
-               goto out;
+       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 (ret != 0)
-                       goto out;
+       if (refglobs.num_globs) {
+               ret = wim_reference_globs(src_wim, &refglobs, open_flags);
+               if (ret)
+                       goto out_free_dest_wim;
        }
 
-       ret = wimlib_export_image(src_w, image, dest_w, dest_name, dest_desc,
-                                 export_flags, additional_swms,
-                                 num_additional_swms, imagex_progress_func);
-       if (ret != 0)
-               goto out;
+       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, 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)
-               ret = wimlib_write(dest_w, dest_wimfile, WIMLIB_ALL_IMAGES,
+       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_w, write_flags, num_threads,
-                                      imagex_progress_func);
-out:
-       if (ret == WIMLIB_ERR_REOPEN)
-               ret = 0;
-       wimlib_free(src_w);
-       wimlib_free(dest_w);
-       if (additional_swms) {
-               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_free_refglobs:
+       refglob_set_destroy(&refglobs);
        return ret;
+
+out_usage:
+       usage(CMD_EXPORT, stderr);
+out_err:
+       ret = -1;
+       goto out_free_refglobs;
 }
 
 static bool
@@ -2161,8 +2515,9 @@ prepare_extract_commands(tchar **paths, unsigned num_paths,
                                free_extract_commands(cmds, num_cmds, dest_dir);
                                return NULL;
                        }
-                       tsprintf(cmds[i].fs_dest_path, T("%"TS"/%"TS), dest_dir,
-                                tbasename(paths[i]));
+                       tsprintf(cmds[i].fs_dest_path,
+                                T("%"TS""OS_PREFERRED_PATH_SEPARATOR_STRING"%"TS),
+                                dest_dir, tbasename(paths[i]));
                }
        }
        *num_cmds_ret = num_cmds;
@@ -2171,7 +2526,7 @@ 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;
@@ -2183,9 +2538,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 = NULL;
-       unsigned num_additional_swms = 0;
+       REFGLOB_SET(refglobs);
 
        struct wimlib_extract_command *cmds;
        size_t num_cmds;
@@ -2199,7 +2552,9 @@ imagex_extract(int argc, tchar **argv)
                        extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
                        break;
                case IMAGEX_REF_OPTION:
-                       swm_glob = optarg;
+                       ret = refglob_set_append(&refglobs, optarg);
+                       if (ret)
+                               goto out_free_refglobs;
                        break;
                case IMAGEX_UNIX_DATA_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_UNIX_DATA;
@@ -2215,8 +2570,13 @@ 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:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_REPLACE_INVALID_FILENAMES;
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_ALL_CASE_CONFLICTS;
+                       break;
                default:
                        goto out_usage;
                }
@@ -2235,10 +2595,8 @@ imagex_extract(int argc, tchar **argv)
 
        cmds = prepare_extract_commands(argv, argc, extract_flags, dest_dir,
                                        &num_cmds);
-       if (!cmds) {
-               ret = -1;
-               goto out;
-       }
+       if (!cmds)
+               goto out_err;
 
        ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
        if (ret)
@@ -2251,57 +2609,124 @@ 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_globs) {
+               ret = wim_reference_globs(wim, &refglobs, open_flags);
                if (ret)
                        goto out_wimlib_free;
        }
 
-#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 (additional_swms) {
-               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:
+       refglob_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)
+{
+       while (len--)
+               tprintf(T("%02hhx"), *field++);
+}
+
+static void
+print_wim_information(const tchar *wimfile, const struct wimlib_wim_info *info)
+{
+       tputs(T("WIM Information:"));
+       tputs(T("----------------"));
+       tprintf(T("Path:           %"TS"\n"), wimfile);
+       tprintf(T("GUID:           0x"));
+       print_byte_field(info->guid, sizeof(info->guid));
+       tputchar(T('\n'));
+       tprintf(T("Image Count:    %d\n"), info->image_count);
+       tprintf(T("Compression:    %"TS"\n"),
+               wimlib_get_compression_type_string(info->compression_type));
+       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);
+       tprintf(T("Integrity Info: %"TS"\n"),
+               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'));
+}
+
+static int
+print_resource(const struct wimlib_resource_entry *resource,
+              void *_ignore)
+{
+
+       tprintf(T("Uncompressed size   = %"PRIu64" bytes\n"),
+               resource->uncompressed_size);
+
+       tprintf(T("Compressed size     = %"PRIu64" bytes\n"),
+               resource->compressed_size);
+
+       tprintf(T("Offset              = %"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("Hash                = 0x"));
+       print_byte_field(resource->sha1_hash, sizeof(resource->sha1_hash));
+       tputchar(T('\n'));
+
+       tprintf(T("Flags               = "));
+       if (resource->is_compressed)
+               tprintf(T("WIM_RESHDR_FLAG_COMPRESSED  "));
+       if (resource->is_metadata)
+               tprintf(T("WIM_RESHDR_FLAG_METADATA  "));
+       if (resource->is_free)
+               tprintf(T("WIM_RESHDR_FLAG_FREE  "));
+       if (resource->is_spanned)
+               tprintf(T("WIM_RESHDR_FLAG_SPANNED  "));
+       tputchar(T('\n'));
+       tputchar(T('\n'));
+       return 0;
+}
+
+static void
+print_lookup_table(WIMStruct *wim)
+{
+       wimlib_iterate_lookup_table(wim, 0, print_resource, NULL);
 }
 
 /* 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;
@@ -2309,17 +2734,14 @@ imagex_info(int argc, tchar **argv)
        bool short_header = true;
        const tchar *xml_out_file = NULL;
        const tchar *wimfile;
-       const tchar *image_num_or_name = T("all");
-       const tchar *new_name = NULL;
-       const tchar *new_desc = NULL;
-       WIMStruct *w;
-       FILE *fp;
+       const tchar *image_num_or_name;
+       const tchar *new_name;
+       const tchar *new_desc;
+       WIMStruct *wim;
        int image;
        int ret;
        int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
-       int part_number;
-       int total_parts;
-       int num_images;
+       struct wimlib_wim_info info;
 
        for_opt(c, info_options) {
                switch (c) {
@@ -2329,6 +2751,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;
@@ -2350,76 +2775,63 @@ imagex_info(int argc, tchar **argv)
                        short_header = false;
                        break;
                default:
-                       usage(INFO);
-                       return -1;
+                       goto out_usage;
                }
        }
 
        argc -= optind;
        argv += optind;
-       if (argc == 0 || argc > 4) {
-               usage(INFO);
-               return -1;
-       }
-       wimfile = argv[0];
-       if (argc > 1) {
-               image_num_or_name = argv[1];
-               if (argc > 2) {
-                       new_name = argv[2];
-                       if (argc > 3) {
-                               new_desc = argv[3];
-                       }
-               }
+       if (argc < 1 || argc > 4)
+               goto out_usage;
+
+       wimfile           = argv[0];
+       image_num_or_name = (argc >= 2) ? argv[1] : T("all");
+       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;
 
-       ret = wimlib_open_wim(wimfile, open_flags, &w,
-                             imagex_progress_func);
-       if (ret != 0)
-               return ret;
+       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+       if (ret)
+               goto out;
 
-       part_number = wimlib_get_part_number(w, &total_parts);
+       wimlib_get_wim_info(wim, &info);
 
-       image = wimlib_resolve_image(w, image_num_or_name);
+       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"),
-                            image_num_or_name);
+               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 "
                                       "the --boot flag."));
                }
-               ret = WIMLIB_ERR_INVALID_IMAGE;
-               goto out;
+               goto out_wimlib_free;
        }
 
-       num_images = wimlib_get_num_images(w);
-
-       if (num_images == 0) {
-               if (boot) {
-                       imagex_error(T("--boot is meaningless on a WIM with no "
-                                      "images"));
-                       ret = WIMLIB_ERR_INVALID_IMAGE;
-                       goto out;
-               }
+       if (boot && info.image_count == 0) {
+               imagex_error(T("--boot is meaningless on a WIM with no images"));
+               goto out_wimlib_free;
        }
 
-       if (image == WIMLIB_ALL_IMAGES && num_images > 1) {
+       if (image == WIMLIB_ALL_IMAGES && info.image_count > 1) {
                if (boot) {
                        imagex_error(T("Cannot specify the --boot flag "
                                       "without specifying a specific "
                                       "image in a multi-image WIM"));
-                       ret = WIMLIB_ERR_INVALID_IMAGE;
-                       goto out;
+                       goto out_wimlib_free;
                }
                if (new_name) {
                        imagex_error(T("Cannot specify the NEW_NAME "
                                       "without specifying a specific "
                                       "image in a multi-image WIM"));
-                       ret = WIMLIB_ERR_INVALID_IMAGE;
-                       goto out;
+                       goto out_wimlib_free;
                }
        }
 
@@ -2430,71 +2842,68 @@ imagex_info(int argc, tchar **argv)
                /* Read-only operations */
 
                if (image == WIMLIB_NO_IMAGE) {
-                       imagex_error(T("\"%"TS"\" is not a valid image"),
-                                    image_num_or_name);
-                       ret = WIMLIB_ERR_INVALID_IMAGE;
-                       goto out;
+                       imagex_error(T("\"%"TS"\" is not a valid image in \"%"TS"\""),
+                                    image_num_or_name, wimfile);
+                       goto out_wimlib_free;
                }
 
                if (image == WIMLIB_ALL_IMAGES && short_header)
-                       wimlib_print_wim_information(w);
+                       print_wim_information(wimfile, &info);
 
                if (header)
-                       wimlib_print_header(w);
+                       wimlib_print_header(wim);
 
                if (lookup_table) {
-                       if (total_parts != 1) {
-                               tprintf(T("Warning: Only showing the lookup table "
-                                         "for part %d of a %d-part WIM.\n"),
-                                       part_number, total_parts);
+                       if (info.total_parts != 1) {
+                               tfprintf(stderr, T("Warning: Only showing the lookup table "
+                                                  "for part %d of a %d-part WIM.\n"),
+                                        info.part_number, info.total_parts);
                        }
-                       wimlib_print_lookup_table(w);
+                       print_lookup_table(wim);
                }
 
                if (xml) {
-                       ret = wimlib_extract_xml_data(w, stdout);
-                       if (ret != 0)
-                               goto out;
+                       ret = wimlib_extract_xml_data(wim, stdout);
+                       if (ret)
+                               goto out_wimlib_free;
                }
 
                if (xml_out_file) {
+                       FILE *fp;
+
                        fp = tfopen(xml_out_file, T("wb"));
                        if (!fp) {
                                imagex_error_with_errno(T("Failed to open the "
                                                          "file \"%"TS"\" for "
-                                                         "writing "),
+                                                         "writing"),
                                                        xml_out_file);
                                ret = -1;
-                               goto out;
+                               goto out_wimlib_free;
                        }
-                       ret = wimlib_extract_xml_data(w, fp);
-                       if (fclose(fp) != 0) {
+                       ret = wimlib_extract_xml_data(wim, fp);
+                       if (fclose(fp)) {
                                imagex_error(T("Failed to close the file "
                                               "\"%"TS"\""),
                                             xml_out_file);
                                ret = -1;
                        }
-
-                       if (ret != 0)
-                               goto out;
+                       if (ret)
+                               goto out_wimlib_free;
                }
 
                if (short_header)
-                       wimlib_print_available_images(w, image);
+                       wimlib_print_available_images(wim, image);
 
                if (metadata) {
-                       ret = wimlib_print_metadata(w, image);
-                       if (ret != 0)
-                               goto out;
+                       ret = wimlib_print_metadata(wim, image);
+                       if (ret)
+                               goto out_wimlib_free;
                }
+               ret = 0;
        } else {
 
                /* Modification operations */
-               if (total_parts != 1) {
-                       imagex_error(T("Modifying a split WIM is not supported."));
-                       ret = -1;
-                       goto out;
-               }
+
                if (image == WIMLIB_ALL_IMAGES)
                        image = 1;
 
@@ -2502,90 +2911,97 @@ imagex_info(int argc, tchar **argv)
                        imagex_error(T("Cannot specify new_name (\"%"TS"\") "
                                       "when using image 0"), new_name);
                        ret = -1;
-                       goto out;
+                       goto out_wimlib_free;
                }
 
                if (boot) {
-                       if (image == wimlib_get_boot_idx(w)) {
-                               tprintf(T("Image %d is already marked as "
+                       if (image == info.boot_index) {
+                               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);
-                               wimlib_set_boot_idx(w, image);
+                               info.boot_index = image;
+                               ret = wimlib_set_wim_info(wim, &info,
+                                                         WIMLIB_CHANGE_BOOT_INDEX);
+                               if (ret)
+                                       goto out_wimlib_free;
                        }
                }
                if (new_name) {
-                       if (!tstrcmp(wimlib_get_image_name(w, image), 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(w, image, new_name);
-                               if (ret != 0)
-                                       goto out;
+                               ret = wimlib_set_image_name(wim, image, new_name);
+                               if (ret)
+                                       goto out_wimlib_free;
                        }
                }
                if (new_desc) {
                        const tchar *old_desc;
-                       old_desc = wimlib_get_image_description(w, image);
+                       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(w, image,
+                               ret = wimlib_set_image_descripton(wim, image,
                                                                  new_desc);
-                               if (ret != 0)
-                                       goto out;
+                               if (ret)
+                                       goto out_wimlib_free;
                        }
                }
 
                /* Only call wimlib_overwrite() if something actually needs to
-                * be changed. */
+                * be changed.  */
                if (boot || new_name || new_desc ||
-                   (check && !wimlib_has_integrity_table(w)))
+                   (check && !info.has_integrity_table) ||
+                   (nocheck && info.has_integrity_table))
                {
-                       int write_flags;
-
-                       ret = file_writable(wimfile);
-                       if (ret != 0)
-                               goto out;
+                       int write_flags = 0;
 
                        if (check)
-                               write_flags = WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
-                       else
-                               write_flags = 0;
-
-                       ret = wimlib_overwrite(w, write_flags, 1,
+                               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);
-                       if (ret == WIMLIB_ERR_REOPEN)
-                               ret = 0;
                } 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;
                }
        }
+out_wimlib_free:
+       wimlib_free(wim);
 out:
-       wimlib_free(w);
        return ret;
+
+out_usage:
+       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 wim_write_flags = 0;
        const tchar *output_path;
+       int ret;
 
        for_opt(c, join_options) {
                switch (c) {
@@ -2594,7 +3010,7 @@ imagex_join(int argc, tchar **argv)
                        wim_write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
                        break;
                default:
-                       goto err;
+                       goto out_usage;
                }
        }
        argc -= optind;
@@ -2603,40 +3019,47 @@ imagex_join(int argc, tchar **argv)
        if (argc < 2) {
                imagex_error(T("Must specify one or more split WIM (.swm) "
                               "parts to join"));
-               goto err;
+               goto out_usage;
        }
        output_path = argv[0];
-       return wimlib_join((const tchar * const *)++argv,
-                          --argc,
-                          output_path,
-                          swm_open_flags,
-                          wim_write_flags,
-                          imagex_progress_func);
-err:
-       usage(JOIN);
-       return -1;
+       ret = wimlib_join((const tchar * const *)++argv,
+                         --argc,
+                         output_path,
+                         swm_open_flags,
+                         wim_write_flags,
+                         imagex_progress_func);
+out:
+       return ret;
+
+out_usage:
+       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 *staging_dir = NULL;
        const tchar *wimfile;
        const tchar *dir;
-       WIMStruct *w;
+       WIMStruct *wim;
+       struct wimlib_wim_info info;
        int image;
-       int num_images;
        int ret;
-       const tchar *swm_glob = NULL;
-       WIMStruct **additional_swms = NULL;
-       unsigned num_additional_swms = 0;
-       const tchar *staging_dir = NULL;
 
-       if (!tstrcmp(argv[0], T("mountrw")))
+       REFGLOB_SET(refglobs);
+
+       if (cmd == CMD_MOUNTRW) {
                mount_flags |= WIMLIB_MOUNT_FLAG_READWRITE;
+               open_flags |= WIMLIB_OPEN_FLAG_WRITE_ACCESS;
+       }
 
        for_opt(c, mount_options) {
                switch (c) {
@@ -2659,11 +3082,13 @@ imagex_mount_rw_or_ro(int argc, tchar **argv)
                        else {
                                imagex_error(T("Unknown stream interface \"%"TS"\""),
                                             optarg);
-                               goto mount_usage;
+                               goto out_usage;
                        }
                        break;
                case IMAGEX_REF_OPTION:
-                       swm_glob = optarg;
+                       ret = refglob_set_append(&refglobs, optarg);
+                       if (ret)
+                               goto out_free_refglobs;
                        break;
                case IMAGEX_STAGING_DIR_OPTION:
                        staging_dir = optarg;
@@ -2672,86 +3097,77 @@ imagex_mount_rw_or_ro(int argc, tchar **argv)
                        mount_flags |= WIMLIB_MOUNT_FLAG_UNIX_DATA;
                        break;
                default:
-                       goto mount_usage;
+                       goto out_usage;
                }
        }
        argc -= optind;
        argv += optind;
        if (argc != 2 && argc != 3)
-               goto mount_usage;
+               goto out_usage;
 
        wimfile = argv[0];
 
-       ret = wimlib_open_wim(wimfile, open_flags, &w,
-                             imagex_progress_func);
-       if (ret != 0)
-               return ret;
+       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+       if (ret)
+               goto out_free_refglobs;
 
-       if (swm_glob) {
-               ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
-                                         &additional_swms,
-                                         &num_additional_swms);
-               if (ret != 0)
-                       goto out;
-       }
+       wimlib_get_wim_info(wim, &info);
 
-       if (argc == 2) {
-               image = 1;
-               num_images = wimlib_get_num_images(w);
-               if (num_images != 1) {
+       if (argc >= 3) {
+               /* Image explicitly specified.  */
+               image = wimlib_resolve_image(wim, argv[1]);
+               dir = argv[2];
+               ret = verify_image_exists_and_is_single(image, argv[1], wimfile);
+               if (ret)
+                       goto out_free_wim;
+       } 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."), wimfile, num_images);
-                       usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
-                                       ? MOUNTRW : MOUNT);
-                       ret = -1;
-                       goto out;
+                                      "select one."), wimfile, info.image_count);
+                       wimlib_free(wim);
+                       goto out_usage;
                }
+               image = 1;
                dir = argv[1];
-       } else {
-               image = wimlib_resolve_image(w, argv[1]);
-               dir = argv[2];
-               ret = verify_image_exists_and_is_single(image, argv[1], wimfile);
-               if (ret != 0)
-                       goto out;
        }
 
-       if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) {
-               ret = file_writable(wimfile);
-               if (ret != 0)
-                       goto out;
+       if (refglobs.num_globs) {
+               ret = wim_reference_globs(wim, &refglobs, open_flags);
+               if (ret)
+                       goto out_free_wim;
        }
 
-       ret = wimlib_mount_image(w, image, dir, mount_flags, additional_swms,
-                                num_additional_swms, staging_dir);
-       if (ret != 0) {
+       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);
-
-       }
-out:
-       wimlib_free(w);
-       if (additional_swms) {
-               for (unsigned i = 0; i < num_additional_swms; i++)
-                       wimlib_free(additional_swms[i]);
-               free(additional_swms);
        }
+out_free_wim:
+       wimlib_free(wim);
+out_free_refglobs:
+       refglob_set_destroy(&refglobs);
        return ret;
-mount_usage:
-       usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
-                       ? MOUNTRW : MOUNT);
-       return -1;
+
+out_usage:
+       usage(cmd, stderr);
+       ret = -1;
+       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 = 0;
+       int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
        int write_flags = WIMLIB_WRITE_FLAG_REBUILD;
        int ret;
-       WIMStruct *w;
+       WIMStruct *wim;
        const tchar *wimfile;
        off_t old_size;
        off_t new_size;
@@ -2763,80 +3179,91 @@ 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_RECOMPRESS_OPTION:
                        write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
                        break;
                case IMAGEX_THREADS_OPTION:
                        num_threads = parse_num_threads(optarg);
                        if (num_threads == UINT_MAX)
-                               return -1;
+                               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:
-                       usage(OPTIMIZE);
-                       return -1;
+                       goto out_usage;
                }
        }
        argc -= optind;
        argv += optind;
 
-       if (argc != 1) {
-               usage(OPTIMIZE);
-               return -1;
-       }
+       if (argc != 1)
+               goto out_usage;
 
        wimfile = argv[0];
 
-       ret = file_writable(wimfile);
-       if (ret)
-               return ret;
-
-       ret = wimlib_open_wim(wimfile, open_flags, &w,
-                             imagex_progress_func);
+       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
        if (ret)
-               return ret;
+               goto out;
 
-       old_size = file_get_size(argv[0]);
+       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(w, write_flags, num_threads,
+       ret = wimlib_overwrite(wim, write_flags, num_threads,
                               imagex_progress_func);
+       if (ret) {
+               imagex_error(T("Optimization of \"%"TS"\" failed."), wimfile);
+               goto out_wimlib_free;
+       }
 
-       if (ret == 0) {
-               new_size = file_get_size(argv[0]);
-               tprintf(T("\"%"TS"\" optimized size: "), wimfile);
-               if (new_size == -1)
-                       tfputs(T("Unknown\n"), stdout);
-               else
-                       tprintf(T("%"PRIu64" KiB\n"), new_size >> 10);
+       new_size = file_get_size(wimfile);
+       tprintf(T("\"%"TS"\" optimized size: "), wimfile);
+       if (new_size == -1)
+               tputs(T("Unknown"));
+       else
+               tprintf(T("%"PRIu64" KiB\n"), new_size >> 10);
 
-               tfputs(T("Space saved: "), stdout);
-               if (new_size != -1 && old_size != -1) {
-                       tprintf(T("%lld KiB\n"),
-                              ((long long)old_size - (long long)new_size) >> 10);
-               } else {
-                       tfputs(T("Unknown\n"), stdout);
-               }
+       tfputs(T("Space saved: "), stdout);
+       if (new_size != -1 && old_size != -1) {
+               tprintf(T("%lld KiB\n"),
+                      ((long long)old_size - (long long)new_size) >> 10);
+       } else {
+               tputs(T("Unknown"));
        }
-
-       wimlib_free(w);
+       ret = 0;
+out_wimlib_free:
+       wimlib_free(wim);
+out:
        return ret;
+
+out_usage:
+       usage(CMD_OPTIMIZE, stderr);
+out_err:
+       ret = -1;
+       goto out;
 }
 
 /* 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;
        int ret;
-       WIMStruct *w;
+       WIMStruct *wim;
 
        for_opt(c, split_options) {
                switch (c) {
@@ -2845,35 +3272,42 @@ imagex_split(int argc, tchar **argv)
                        write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
                        break;
                default:
-                       usage(SPLIT);
-                       return -1;
+                       goto out_usage;
                }
        }
        argc -= optind;
        argv += optind;
 
-       if (argc != 3) {
-               usage(SPLIT);
-               return -1;
-       }
+       if (argc != 3)
+               goto out_usage;
+
        part_size = tstrtod(argv[2], &tmp) * (1 << 20);
        if (tmp == argv[2] || *tmp) {
                imagex_error(T("Invalid part size \"%"TS"\""), argv[2]);
                imagex_error(T("The part size must be an integer or "
                               "floating-point number of megabytes."));
-               return -1;
+               goto out_err;
        }
-       ret = wimlib_open_wim(argv[0], open_flags, &w, imagex_progress_func);
-       if (ret != 0)
-               return ret;
-       ret = wimlib_split(w, argv[1], part_size, write_flags, imagex_progress_func);
-       wimlib_free(w);
+       ret = wimlib_open_wim(argv[0], open_flags, &wim, imagex_progress_func);
+       if (ret)
+               goto out;
+
+       ret = wimlib_split(wim, argv[1], part_size, write_flags, imagex_progress_func);
+       wimlib_free(wim);
+out:
        return ret;
+
+out_usage:
+       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;
@@ -2894,39 +3328,42 @@ imagex_unmount(int argc, tchar **argv)
                        unmount_flags |= WIMLIB_UNMOUNT_FLAG_LAZY;
                        break;
                default:
-                       usage(UNMOUNT);
-                       return -1;
+                       goto out_usage;
                }
        }
        argc -= optind;
        argv += optind;
-       if (argc != 1) {
-               usage(UNMOUNT);
-               return -1;
-       }
+       if (argc != 1)
+               goto out_usage;
 
        ret = wimlib_unmount_image(argv[0], unmount_flags,
                                   imagex_progress_func);
-       if (ret != 0)
+       if (ret)
                imagex_error(T("Failed to unmount \"%"TS"\""), argv[0]);
+out:
        return ret;
+
+out_usage:
+       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;
-       const tchar *image_num_or_name;
        int image;
        WIMStruct *wim;
        int ret;
-       int open_flags = 0;
+       int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
        int write_flags = 0;
-       int update_flags = 0;
-       int default_add_flags = WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE;
+       int update_flags = WIMLIB_UPDATE_FLAG_SEND_PROGRESS;
+       int default_add_flags = WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE;
        int default_delete_flags = 0;
        unsigned num_threads = 0;
        int c;
@@ -2934,21 +3371,19 @@ imagex_update(int argc, tchar **argv)
        size_t cmd_file_nchars;
        struct wimlib_update_command *cmds;
        size_t num_cmds;
-       int num_images;
+       tchar *command_str = NULL;
 
        const tchar *config_file = NULL;
        tchar *config_str;
-       struct wimlib_capture_config *config = NULL;
+       struct wimlib_capture_config *config;
 
        for_opt(c, update_options) {
                switch (c) {
                /* Generic or write options */
                case IMAGEX_THREADS_OPTION:
                        num_threads = parse_num_threads(optarg);
-                       if (num_threads == UINT_MAX) {
-                               ret = -1;
-                               goto out;
-                       }
+                       if (num_threads == UINT_MAX)
+                               goto out_err;
                        break;
                case IMAGEX_CHECK_OPTION:
                        open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
@@ -2957,7 +3392,20 @@ imagex_update(int argc, tchar **argv)
                case IMAGEX_REBUILD_OPTION:
                        write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
                        break;
-
+               case IMAGEX_COMMAND_OPTION:
+                       if (command_str) {
+                               imagex_error(T("--command may only be specified "
+                                              "one time.  Please provide\n"
+                                              "       the update commands "
+                                              "on standard input instead."));
+                               goto out_err;
+                       }
+                       command_str = tstrdup(optarg);
+                       if (!command_str) {
+                               imagex_error(T("Out of memory!"));
+                               goto out_err;
+                       }
+                       break;
                /* Default delete options */
                case IMAGEX_FORCE_OPTION:
                        default_delete_flags |= WIMLIB_DELETE_FLAG_FORCE;
@@ -2968,24 +3416,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;
@@ -2994,37 +3443,34 @@ imagex_update(int argc, tchar **argv)
        argv += optind;
        argc -= optind;
 
-       if (argc < 1 || argc > 2)
+       if (argc != 1 && argc != 2)
                goto out_usage;
        wimfile = argv[0];
 
-       ret = file_writable(wimfile);
-       if (ret)
-               goto out;
-
        ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
        if (ret)
-               goto out;
+               goto out_free_command_str;
 
-       if (argc == 2)
-               image_num_or_name = argv[1];
-       else
-               image_num_or_name = T("1");
-
-       image = wimlib_resolve_image(wim, image_num_or_name);
-
-       ret = verify_image_exists_and_is_single(image, image_num_or_name,
-                                               wimfile);
-       if (ret)
-               goto out_wimlib_free;
-
-       num_images = wimlib_get_num_images(wim);
-       if (argc == 1 && num_images != 1) {
-               imagex_error(T("\"%"TS"\" contains %d images; Please select one."),
-                            wimfile, num_images);
-               usage(UPDATE);
-               ret = -1;
-               goto out_wimlib_free;
+       if (argc >= 2) {
+               /* Image explicitly specified.  */
+               image = wimlib_resolve_image(wim, argv[1]);
+               ret = verify_image_exists_and_is_single(image, argv[1],
+                                                       wimfile);
+               if (ret)
+                       goto out_wimlib_free;
+       } 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);
+                       wimlib_free(wim);
+                       goto out_usage;
+               }
+               image = 1;
        }
 
        /* Parse capture configuration file if specified */
@@ -3042,23 +3488,31 @@ 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 */
-       if (isatty(STDIN_FILENO)) {
-               tputs(T("Reading update commands from standard input..."));
-               recommend_man_page(T("update"));
-       }
-       cmd_file_contents = stdin_get_text_contents(&cmd_file_nchars);
-       if (!cmd_file_contents) {
-               ret = -1;
-               goto out_free_config;
-       }
+       /* Read update commands from standard input, or the command string if
+        * specified.  */
+       if (command_str) {
+               cmd_file_contents = NULL;
+               cmds = parse_update_command_file(&command_str, tstrlen(command_str),
+                                                &num_cmds);
+       } else {
+               if (isatty(STDIN_FILENO)) {
+                       tputs(T("Reading update commands from standard input..."));
+                       recommend_man_page(CMD_UPDATE, stdout);
+               }
+               cmd_file_contents = stdin_get_text_contents(&cmd_file_nchars);
+               if (!cmd_file_contents) {
+                       ret = -1;
+                       goto out_free_config;
+               }
 
-       /* Parse the update commands */
-       cmds = parse_update_command_file(&cmd_file_contents, cmd_file_nchars,
-                                        &num_cmds);
+               /* Parse the update commands */
+               cmds = parse_update_command_file(&cmd_file_contents, cmd_file_nchars,
+                                                &num_cmds);
+       }
        if (!cmds) {
                ret = -1;
                goto out_free_cmd_file_contents;
@@ -3072,7 +3526,7 @@ imagex_update(int argc, tchar **argv)
                        cmds[i].add.config = config;
                        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;
@@ -3093,49 +3547,176 @@ out_free_cmds:
 out_free_cmd_file_contents:
        free(cmd_file_contents);
 out_free_config:
-       if (config != NULL && config != &default_capture_config) {
+       if (config) {
                free(config->exclusion_pats.pats);
                free(config->exclusion_exception_pats.pats);
                free(config_str);
        }
 out_wimlib_free:
        wimlib_free(wim);
-out:
+out_free_command_str:
+       free(command_str);
        return ret;
+
 out_usage:
-       usage(UPDATE);
+       usage(CMD_UPDATE, stderr);
+out_err:
        ret = -1;
-       goto out;
+       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] [--check]\n"
+"                    [--nocheck] [--flags EDITION_ID] [--verbose]\n"
+"                    [--dereference] [--config=FILE] [--threads=NUM_THREADS]\n"
+"                    [--rebuild] [--unix-data] [--source-list] [--no-acls]\n"
+"                    [--strict-acls] [--rpfix] [--norpfix] [--pipable]\n"
+"                    [--not-pipable] [--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] [--check]\n"
+"                    [--nocheck] [--compress=TYPE] [--flags EDITION_ID]\n"
+"                    [--verbose] [--dereference] [--config=FILE]\n"
+"                    [--threads=NUM_THREADS] [--unix-data] [--source-list]\n"
+"                    [--no-acls] [--strict-acls] [--norpfix] [--pipable]\n"
+"                    [--update-of=[WIMFILE:]IMAGE] [--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"
+"                    [--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)
 {
@@ -3154,67 +3735,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
@@ -3228,9 +3816,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")) {
@@ -3245,67 +3836,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,
@@ -3313,10 +3926,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;
 }