add System Compression support
[wimlib] / programs / imagex.c
index 9ebe277..556006f 100644 (file)
@@ -6,7 +6,7 @@
  */
 
 /*
- * Copyright (C) 2012, 2013 Eric Biggers
+ * Copyright (C) 2012, 2013, 2014, 2015 Eric Biggers
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
 #  include <alloca.h>
 #endif
 
+#define WIMLIB_COMPRESSION_TYPE_INVALID (-1)
+
 #ifdef __WIN32__
 #  include "imagex-win32.h"
-#  define tbasename    win32_wbasename
-#  define OS_PREFERRED_PATH_SEPARATOR L'\\'
-#  define OS_PREFERRED_PATH_SEPARATOR_STRING L"\\"
+#  define print_security_descriptor     win32_print_security_descriptor
 #else /* __WIN32__ */
-#  include <glob.h>
 #  include <getopt.h>
 #  include <langinfo.h>
-#  define tbasename    basename
-#  define OS_PREFERRED_PATH_SEPARATOR '/'
-#  define OS_PREFERRED_PATH_SEPARATOR_STRING "/"
+#  define print_security_descriptor    default_print_security_descriptor
 static inline void set_fd_to_binary_mode(int fd)
 {
 }
@@ -75,6 +72,34 @@ static inline void set_fd_to_binary_mode(int fd)
 
 #define ARRAY_LEN(array) (sizeof(array) / sizeof(array[0]))
 
+static inline bool
+is_any_path_separator(tchar c)
+{
+       return c == T('/') || c == T('\\');
+}
+
+/* Like basename(), but handles both forward and backwards slashes.  */
+static tchar *
+tbasename(tchar *path)
+{
+       tchar *p = tstrchr(path, T('\0'));
+
+       for (;;) {
+               if (p == path)
+                       return path;
+               if (!is_any_path_separator(*--p))
+                       break;
+               *p = T('\0');
+       }
+
+       for (;;) {
+               if (p == path)
+                       return path;
+               if (is_any_path_separator(*--p))
+                       return ++p;
+       }
+}
+
 #define for_opt(c, opts) while ((c = getopt_long_only(argc, (tchar**)argv, T(""), \
                                opts, NULL)) != -1)
 
@@ -99,6 +124,7 @@ enum {
        CMD_UNMOUNT,
 #endif
        CMD_UPDATE,
+       CMD_VERIFY,
        CMD_MAX,
 };
 
@@ -107,9 +133,6 @@ 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 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;
 
@@ -118,11 +141,13 @@ static FILE *imagex_info_file;
 
 enum {
        IMAGEX_ALLOW_OTHER_OPTION,
+       IMAGEX_BLOBS_OPTION,
        IMAGEX_BOOT_OPTION,
        IMAGEX_CHECK_OPTION,
        IMAGEX_CHUNK_SIZE_OPTION,
        IMAGEX_COMMAND_OPTION,
        IMAGEX_COMMIT_OPTION,
+       IMAGEX_COMPACT_OPTION,
        IMAGEX_COMPRESS_OPTION,
        IMAGEX_COMPRESS_SLOW_OPTION,
        IMAGEX_CONFIG_OPTION,
@@ -130,23 +155,28 @@ enum {
        IMAGEX_DELTA_FROM_OPTION,
        IMAGEX_DEREFERENCE_OPTION,
        IMAGEX_DEST_DIR_OPTION,
+       IMAGEX_DETAILED_OPTION,
        IMAGEX_EXTRACT_XML_OPTION,
        IMAGEX_FLAGS_OPTION,
        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_NEW_IMAGE_OPTION,
        IMAGEX_NOCHECK_OPTION,
-       IMAGEX_NO_ACLS_OPTION,
-       IMAGEX_NO_WILDCARDS_OPTION,
+       IMAGEX_NORPFIX_OPTION,
        IMAGEX_NOT_PIPABLE_OPTION,
-       IMAGEX_PACK_STREAMS_OPTION,
+       IMAGEX_NO_ACLS_OPTION,
+       IMAGEX_NO_ATTRIBUTES_OPTION,
+       IMAGEX_NO_GLOBS_OPTION,
+       IMAGEX_NO_REPLACE_OPTION,
+       IMAGEX_NO_SOLID_SORT_OPTION,
+       IMAGEX_NULLGLOB_OPTION,
+       IMAGEX_ONE_FILE_ONLY_OPTION,
        IMAGEX_PATH_OPTION,
        IMAGEX_PIPABLE_OPTION,
+       IMAGEX_PRESERVE_DIR_STRUCTURE_OPTION,
        IMAGEX_REBUILD_OPTION,
        IMAGEX_RECOMPRESS_OPTION,
        IMAGEX_RECURSIVE_OPTION,
@@ -154,36 +184,40 @@ enum {
        IMAGEX_RESUME_OPTION,
        IMAGEX_RPFIX_OPTION,
        IMAGEX_SOFT_OPTION,
+       IMAGEX_SOLID_CHUNK_SIZE_OPTION,
+       IMAGEX_SOLID_COMPRESS_OPTION,
+       IMAGEX_SOLID_OPTION,
        IMAGEX_SOURCE_LIST_OPTION,
        IMAGEX_STAGING_DIR_OPTION,
        IMAGEX_STREAMS_INTERFACE_OPTION,
        IMAGEX_STRICT_ACLS_OPTION,
-       IMAGEX_STRICT_WILDCARDS_OPTION,
-       IMAGEX_SYMLINK_OPTION,
        IMAGEX_THREADS_OPTION,
        IMAGEX_TO_STDOUT_OPTION,
        IMAGEX_UNIX_DATA_OPTION,
        IMAGEX_UPDATE_OF_OPTION,
        IMAGEX_VERBOSE_OPTION,
+       IMAGEX_WIMBOOT_CONFIG_OPTION,
+       IMAGEX_WIMBOOT_OPTION,
        IMAGEX_XML_OPTION,
 };
 
 static const struct option apply_options[] = {
        {T("check"),       no_argument,       NULL, IMAGEX_CHECK_OPTION},
-       {T("hardlink"),    no_argument,       NULL, IMAGEX_HARDLINK_OPTION},
-       {T("symlink"),     no_argument,       NULL, IMAGEX_SYMLINK_OPTION},
        {T("verbose"),     no_argument,       NULL, IMAGEX_VERBOSE_OPTION},
        {T("ref"),         required_argument, NULL, IMAGEX_REF_OPTION},
        {T("unix-data"),   no_argument,       NULL, IMAGEX_UNIX_DATA_OPTION},
        {T("noacls"),      no_argument,       NULL, IMAGEX_NO_ACLS_OPTION},
        {T("no-acls"),     no_argument,       NULL, IMAGEX_NO_ACLS_OPTION},
        {T("strict-acls"), no_argument,       NULL, IMAGEX_STRICT_ACLS_OPTION},
+       {T("no-attributes"), no_argument,     NULL, IMAGEX_NO_ATTRIBUTES_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},
+       {T("wimboot"),     no_argument,       NULL, IMAGEX_WIMBOOT_OPTION},
+       {T("compact"),     required_argument, NULL, IMAGEX_COMPACT_OPTION},
        {NULL, 0, NULL, 0},
 };
 
@@ -195,8 +229,13 @@ static const struct option capture_or_append_options[] = {
        {T("compress"),    required_argument, NULL, IMAGEX_COMPRESS_OPTION},
        {T("compress-slow"), no_argument,     NULL, IMAGEX_COMPRESS_SLOW_OPTION},
        {T("chunk-size"),  required_argument, NULL, IMAGEX_CHUNK_SIZE_OPTION},
-       {T("pack-streams"), no_argument,      NULL, IMAGEX_PACK_STREAMS_OPTION},
-       {T("solid"),       no_argument,      NULL, IMAGEX_PACK_STREAMS_OPTION},
+       {T("solid"),       no_argument,      NULL, IMAGEX_SOLID_OPTION},
+       {T("pack-streams"), no_argument,      NULL, IMAGEX_SOLID_OPTION},
+       {T("solid-compress"),required_argument, NULL, IMAGEX_SOLID_COMPRESS_OPTION},
+       {T("pack-compress"), required_argument, NULL, IMAGEX_SOLID_COMPRESS_OPTION},
+       {T("solid-chunk-size"),required_argument, NULL, IMAGEX_SOLID_CHUNK_SIZE_OPTION},
+       {T("pack-chunk-size"), required_argument, NULL, IMAGEX_SOLID_CHUNK_SIZE_OPTION},
+       {T("no-solid-sort"), no_argument,     NULL, IMAGEX_NO_SOLID_SORT_OPTION},
        {T("config"),      required_argument, NULL, IMAGEX_CONFIG_OPTION},
        {T("dereference"), no_argument,       NULL, IMAGEX_DEREFERENCE_OPTION},
        {T("flags"),       required_argument, NULL, IMAGEX_FLAGS_OPTION},
@@ -214,6 +253,7 @@ static const struct option capture_or_append_options[] = {
        {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},
+       {T("wimboot"),     no_argument,       NULL, IMAGEX_WIMBOOT_OPTION},
        {NULL, 0, NULL, 0},
 };
 
@@ -224,7 +264,9 @@ static const struct option delete_options[] = {
 };
 
 static const struct option dir_options[] = {
-       {T("path"), required_argument, NULL, IMAGEX_PATH_OPTION},
+       {T("path"),     required_argument, NULL, IMAGEX_PATH_OPTION},
+       {T("detailed"), no_argument,       NULL, IMAGEX_DETAILED_OPTION},
+       {T("one-file-only"), no_argument,  NULL, IMAGEX_ONE_FILE_ONLY_OPTION},
        {NULL, 0, NULL, 0},
 };
 
@@ -234,14 +276,22 @@ static const struct option export_options[] = {
        {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("pack-streams"),no_argument,       NULL, IMAGEX_PACK_STREAMS_OPTION},
-       {T("solid"),       no_argument,       NULL, IMAGEX_PACK_STREAMS_OPTION},
+       {T("recompress"),  no_argument,       NULL, IMAGEX_RECOMPRESS_OPTION},
+       {T("compress-slow"), no_argument,     NULL, IMAGEX_COMPRESS_SLOW_OPTION},
        {T("chunk-size"),  required_argument, NULL, IMAGEX_CHUNK_SIZE_OPTION},
+       {T("solid"),       no_argument,       NULL, IMAGEX_SOLID_OPTION},
+       {T("pack-streams"),no_argument,       NULL, IMAGEX_SOLID_OPTION},
+       {T("solid-compress"),required_argument, NULL, IMAGEX_SOLID_COMPRESS_OPTION},
+       {T("pack-compress"), required_argument, NULL, IMAGEX_SOLID_COMPRESS_OPTION},
+       {T("solid-chunk-size"),required_argument, NULL, IMAGEX_SOLID_CHUNK_SIZE_OPTION},
+       {T("pack-chunk-size"), required_argument, NULL, IMAGEX_SOLID_CHUNK_SIZE_OPTION},
+       {T("no-solid-sort"), no_argument,     NULL, IMAGEX_NO_SOLID_SORT_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},
+       {T("wimboot"),     no_argument,       NULL, IMAGEX_WIMBOOT_OPTION},
        {NULL, 0, NULL, 0},
 };
 
@@ -253,11 +303,16 @@ static const struct option extract_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},
+       {T("no-attributes"), no_argument,     NULL, IMAGEX_NO_ATTRIBUTES_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},
-       {T("strict-wildcards"), no_argument,  NULL, IMAGEX_STRICT_WILDCARDS_OPTION},
-       {T("no-wildcards"), no_argument,      NULL, IMAGEX_NO_WILDCARDS_OPTION},
+       {T("no-wildcards"), no_argument,      NULL, IMAGEX_NO_GLOBS_OPTION},
+       {T("no-globs"),     no_argument,      NULL, IMAGEX_NO_GLOBS_OPTION},
+       {T("nullglob"),     no_argument,      NULL, IMAGEX_NULLGLOB_OPTION},
+       {T("preserve-dir-structure"), no_argument, NULL, IMAGEX_PRESERVE_DIR_STRUCTURE_OPTION},
+       {T("wimboot"),     no_argument,       NULL, IMAGEX_WIMBOOT_OPTION},
+       {T("compact"),     required_argument, NULL, IMAGEX_COMPACT_OPTION},
        {NULL, 0, NULL, 0},
 };
 
@@ -268,7 +323,8 @@ static const struct option info_options[] = {
        {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},
+       {T("lookup-table"), no_argument,       NULL, IMAGEX_BLOBS_OPTION},
+       {T("blobs"),        no_argument,       NULL, IMAGEX_BLOBS_OPTION},
        {T("metadata"),     no_argument,       NULL, IMAGEX_METADATA_OPTION},
        {T("xml"),          no_argument,       NULL, IMAGEX_XML_OPTION},
        {NULL, 0, NULL, 0},
@@ -297,10 +353,15 @@ static const struct option optimize_options[] = {
        {T("compress"),    required_argument, NULL, IMAGEX_COMPRESS_OPTION},
        {T("recompress"),  no_argument,       NULL, IMAGEX_RECOMPRESS_OPTION},
        {T("compress-slow"), no_argument,     NULL, IMAGEX_COMPRESS_SLOW_OPTION},
-       {T("recompress-slow"), no_argument,     NULL, IMAGEX_COMPRESS_SLOW_OPTION},
+       {T("recompress-slow"), no_argument,   NULL, IMAGEX_COMPRESS_SLOW_OPTION},
        {T("chunk-size"),  required_argument, NULL, IMAGEX_CHUNK_SIZE_OPTION},
-       {T("pack-streams"),no_argument,       NULL, IMAGEX_PACK_STREAMS_OPTION},
-       {T("solid"),       no_argument,       NULL, IMAGEX_PACK_STREAMS_OPTION},
+       {T("solid"),       no_argument,       NULL, IMAGEX_SOLID_OPTION},
+       {T("pack-streams"),no_argument,       NULL, IMAGEX_SOLID_OPTION},
+       {T("solid-compress"),required_argument, NULL, IMAGEX_SOLID_COMPRESS_OPTION},
+       {T("pack-compress"), required_argument, NULL, IMAGEX_SOLID_COMPRESS_OPTION},
+       {T("solid-chunk-size"),required_argument, NULL, IMAGEX_SOLID_CHUNK_SIZE_OPTION},
+       {T("pack-chunk-size"), required_argument, NULL, IMAGEX_SOLID_CHUNK_SIZE_OPTION},
+       {T("no-solid-sort"), no_argument,     NULL, IMAGEX_NO_SOLID_SORT_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},
@@ -317,6 +378,8 @@ static const struct option unmount_options[] = {
        {T("check"),   no_argument, NULL, IMAGEX_CHECK_OPTION},
        {T("rebuild"), no_argument, NULL, IMAGEX_REBUILD_OPTION},
        {T("lazy"),    no_argument, NULL, IMAGEX_LAZY_OPTION},
+       {T("force"),    no_argument, NULL, IMAGEX_FORCE_OPTION},
+       {T("new-image"), no_argument, NULL, IMAGEX_NEW_IMAGE_OPTION},
        {NULL, 0, NULL, 0},
 };
 
@@ -329,6 +392,7 @@ static const struct option update_options[] = {
        {T("check"),       no_argument,       NULL, IMAGEX_CHECK_OPTION},
        {T("rebuild"),     no_argument,       NULL, IMAGEX_REBUILD_OPTION},
        {T("command"),     required_argument, NULL, IMAGEX_COMMAND_OPTION},
+       {T("wimboot-config"), required_argument, NULL, IMAGEX_WIMBOOT_CONFIG_OPTION},
 
        /* Default delete options */
        {T("force"),       no_argument,       NULL, IMAGEX_FORCE_OPTION},
@@ -344,6 +408,14 @@ 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},
+       {T("no-replace"),  no_argument,       NULL, IMAGEX_NO_REPLACE_OPTION},
+
+       {NULL, 0, NULL, 0},
+};
+
+static const struct option verify_options[] = {
+       {T("ref"), required_argument, NULL, IMAGEX_REF_OPTION},
+       {T("nocheck"), no_argument, NULL, IMAGEX_NOCHECK_OPTION},
 
        {NULL, 0, NULL, 0},
 };
@@ -418,64 +490,105 @@ verify_image_exists_and_is_single(int image, const tchar *image_name,
        return ret;
 }
 
+static void
+print_available_compression_types(FILE *fp)
+{
+       static const tchar *s =
+       T(
+       "Available compression types:\n"
+       "\n"
+       "    none\n"
+       "    xpress (alias: \"fast\")\n"
+       "    lzx    (alias: \"maximum\") (default for capture)\n"
+       "    lzms   (alias: \"recovery\")\n"
+       "\n"
+       );
+       tfputs(s, fp);
+}
+
 /* Parse the argument to --compress */
 static int
-get_compression_type(const tchar *optarg)
+get_compression_type(tchar *optarg)
 {
-       if (!tstrcasecmp(optarg, T("maximum")) || !tstrcasecmp(optarg, T("lzx")))
-               return WIMLIB_COMPRESSION_TYPE_LZX;
+       int ctype;
+       unsigned int compression_level = 0;
+       tchar *plevel;
+
+       plevel = tstrchr(optarg, T(':'));
+       if (plevel) {
+               tchar *ptmp;
+               unsigned long ultmp;
+
+               *plevel++ = T('\0');
+               ultmp = tstrtoul(plevel, &ptmp, 10);
+               if (ultmp >= UINT_MAX || ultmp == 0 || *ptmp || ptmp == plevel) {
+                       imagex_error(T("Compression level must be a positive integer! "
+                                      "e.g. --compress=lzx:80"));
+                       return WIMLIB_COMPRESSION_TYPE_INVALID;
+               }
+               compression_level = ultmp;
+       }
+
+       if (!tstrcasecmp(optarg, T("maximum")) ||
+           !tstrcasecmp(optarg, T("lzx")) ||
+           !tstrcasecmp(optarg, T("max")))
+               ctype = WIMLIB_COMPRESSION_TYPE_LZX;
        else if (!tstrcasecmp(optarg, T("fast")) || !tstrcasecmp(optarg, T("xpress")))
-               return WIMLIB_COMPRESSION_TYPE_XPRESS;
+               ctype = WIMLIB_COMPRESSION_TYPE_XPRESS;
        else if (!tstrcasecmp(optarg, T("recovery")) || !tstrcasecmp(optarg, T("lzms")))
-               return WIMLIB_COMPRESSION_TYPE_LZMS;
+               ctype = WIMLIB_COMPRESSION_TYPE_LZMS;
        else if (!tstrcasecmp(optarg, T("none")))
-               return WIMLIB_COMPRESSION_TYPE_NONE;
+               ctype = WIMLIB_COMPRESSION_TYPE_NONE;
        else {
-               imagex_error(T("Invalid compression type \"%"TS"\"! Must be "
-                            "\"maximum\", \"fast\", or \"none\"."), optarg);
+               imagex_error(T("Invalid compression type \"%"TS"\"!"), optarg);
+               print_available_compression_types(stderr);
                return WIMLIB_COMPRESSION_TYPE_INVALID;
        }
+
+       if (compression_level != 0)
+               wimlib_set_default_compression_level(ctype, compression_level);
+       return ctype;
 }
 
-static void
-set_compress_slow(void)
+/* Parse the argument to --compact */
+static int
+set_compact_mode(const tchar *arg, int *extract_flags)
 {
-       static const struct wimlib_lzx_compressor_params lzx_slow_params = {
-               .hdr = {
-                       .size = sizeof(struct wimlib_lzx_compressor_params),
-               },
-               .algorithm = WIMLIB_LZX_ALGORITHM_SLOW,
-               .alg_params = {
-                       .slow = {
-                               .use_len2_matches = 1,
-                               .nice_match_length = 96,
-                               .num_optim_passes = 4,
-                               .max_search_depth = 100,
-                               .max_matches_per_pos = 10,
-                               .main_nostat_cost = 15,
-                               .len_nostat_cost = 15,
-                               .aligned_nostat_cost = 7,
-                       },
-               },
-       };
+       int flag = 0;
+       if (!tstrcasecmp(arg, T("xpress4k")))
+               flag = WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K;
+       else if (!tstrcasecmp(arg, T("xpress8k")))
+               flag = WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K;
+       else if (!tstrcasecmp(arg, T("xpress16k")))
+               flag = WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K;
+       else if (!tstrcasecmp(arg, T("lzx")))
+               flag = WIMLIB_EXTRACT_FLAG_COMPACT_LZX;
+
+       if (flag) {
+               *extract_flags |= flag;
+               return 0;
+       }
 
-       static const struct wimlib_lzms_compressor_params lzms_slow_params = {
-               .hdr = {
-                       .size = sizeof(struct wimlib_lzms_compressor_params),
-               },
-               .min_match_length = 2,
-               .max_match_length = UINT32_MAX,
-               .nice_match_length = 96,
-               .max_search_depth = 100,
-               .max_matches_per_pos = 10,
-               .optim_array_length = 1024,
-       };
+       imagex_error(T(
+"\"%"TS"\" is not a recognized System Compression format.  The options are:"
+"\n"
+"    --compact=xpress4k\n"
+"    --compact=xpress8k\n"
+"    --compact=xpress16k\n"
+"    --compact=lzx\n"
+       ), arg);
+       return -1;
+}
 
-       wimlib_set_default_compressor_params(WIMLIB_COMPRESSION_TYPE_LZX,
-                                            &lzx_slow_params.hdr);
 
-       wimlib_set_default_compressor_params(WIMLIB_COMPRESSION_TYPE_LZMS,
-                                            &lzms_slow_params.hdr);
+static void
+set_compress_slow(void)
+{
+#if 0
+       fprintf(stderr, "WARNING: the '--compress-slow' option is deprecated.\n"
+                       "         Use the '--compress=TYPE:LEVEL' option instead.\n");
+#endif
+       wimlib_set_default_compression_level(-1, 100);
 }
 
 struct string_set {
@@ -524,8 +637,7 @@ wim_reference_globs(WIMStruct *wim, struct string_set *set, int open_flags)
        return wimlib_reference_resource_files(wim, set->strings,
                                               set->num_strings,
                                               WIMLIB_REF_FLAG_GLOB_ENABLE,
-                                              open_flags,
-                                              imagex_progress_func);
+                                              open_flags);
 }
 
 static void
@@ -668,7 +780,7 @@ static bool
 is_comment_line(const tchar *line, size_t len)
 {
        for (;;) {
-               if (*line == T('#'))
+               if (*line == T('#') || *line == T(';'))
                        return true;
                if (!istspace(*line) && *line != T('\0'))
                        return false;
@@ -766,144 +878,6 @@ parse_source_list(tchar **source_list_contents_p, size_t source_list_nchars,
        return sources;
 }
 
-
-enum capture_config_section {
-       CAPTURE_CONFIG_NO_SECTION,
-       CAPTURE_CONFIG_EXCLUSION_SECTION,
-       CAPTURE_CONFIG_EXCLUSION_EXCEPTION_SECTION,
-       CAPTURE_CONFIG_IGNORE_SECTION,
-};
-
-enum {
-       CAPTURE_CONFIG_INVALID_SECTION,
-       CAPTURE_CONFIG_CHANGED_SECTION,
-       CAPTURE_CONFIG_SAME_SECTION,
-};
-
-static int
-check_config_section(tchar *line, size_t len,
-                    enum capture_config_section *cur_section)
-{
-       while (istspace(*line))
-               line++;
-
-       if (*line != T('['))
-               return CAPTURE_CONFIG_SAME_SECTION;
-
-       line++;
-       tchar *endbrace = tstrrchr(line, T(']'));
-       if (!endbrace)
-               return CAPTURE_CONFIG_SAME_SECTION;
-
-       if (!tmemcmp(line, T("ExclusionList"), endbrace - line)) {
-               *cur_section = CAPTURE_CONFIG_EXCLUSION_SECTION;
-       } else if (!tmemcmp(line, T("ExclusionException"), endbrace - line)) {
-               *cur_section = CAPTURE_CONFIG_EXCLUSION_EXCEPTION_SECTION;
-       } else if (!tmemcmp(line, T("CompressionExclusionList"), endbrace - line)) {
-               *cur_section = CAPTURE_CONFIG_IGNORE_SECTION;
-               tfputs(T("WARNING: Ignoring [CompressionExclusionList] section "
-                        "of capture config file\n"),
-                      stderr);
-       } else if (!tmemcmp(line, T("AlignmentList"), endbrace - line)) {
-               *cur_section = CAPTURE_CONFIG_IGNORE_SECTION;
-               tfputs(T("WARNING: Ignoring [AlignmentList] section "
-                        "of capture config file\n"),
-                      stderr);
-       } else {
-               imagex_error(T("Invalid capture config file section \"%"TS"\""),
-                            line - 1);
-               return CAPTURE_CONFIG_INVALID_SECTION;
-       }
-       return CAPTURE_CONFIG_CHANGED_SECTION;
-}
-
-
-static bool
-pattern_list_add_pattern(struct wimlib_pattern_list *pat_list,
-                        tchar *pat)
-{
-       if (pat_list->num_pats == pat_list->num_allocated_pats) {
-               tchar **pats;
-               size_t num_allocated_pats = pat_list->num_pats + 8;
-
-               pats = realloc(pat_list->pats,
-                              num_allocated_pats * sizeof(pat_list->pats[0]));
-               if (!pats) {
-                       imagex_error(T("Out of memory!"));
-                       return false;
-               }
-               pat_list->pats = pats;
-               pat_list->num_allocated_pats = num_allocated_pats;
-       }
-       pat_list->pats[pat_list->num_pats++] = pat;
-       return true;
-}
-
-static bool
-parse_capture_config_line(tchar *line, size_t len,
-                         enum capture_config_section *cur_section,
-                         struct wimlib_capture_config *config)
-{
-       tchar *filename;
-       int ret;
-
-       ret = check_config_section(line, len, cur_section);
-       if (ret == CAPTURE_CONFIG_INVALID_SECTION)
-               return false;
-       if (ret == CAPTURE_CONFIG_CHANGED_SECTION)
-               return true;
-
-       switch (*cur_section) {
-       case CAPTURE_CONFIG_NO_SECTION:
-               imagex_error(T("Line \"%"TS"\" is not in a section "
-                              "(such as [ExclusionList]"), line);
-               return false;
-       case CAPTURE_CONFIG_EXCLUSION_SECTION:
-               if (parse_string(&line, &len, &filename) != PARSE_STRING_SUCCESS)
-                       return false;
-               return pattern_list_add_pattern(&config->exclusion_pats,
-                                               filename);
-       case CAPTURE_CONFIG_EXCLUSION_EXCEPTION_SECTION:
-               if (parse_string(&line, &len, &filename) != PARSE_STRING_SUCCESS)
-                       return false;
-               return pattern_list_add_pattern(&config->exclusion_exception_pats,
-                                               filename);
-       case CAPTURE_CONFIG_IGNORE_SECTION:
-               return true;
-       }
-       return false;
-}
-
-static int
-parse_capture_config(tchar **contents_p, size_t nchars,
-                    struct wimlib_capture_config *config)
-{
-       ssize_t nlines;
-       tchar *p;
-       size_t i;
-       enum capture_config_section cur_section;
-
-       memset(config, 0, sizeof(*config));
-
-       nlines = text_file_count_lines(contents_p, &nchars);
-       if (nlines < 0)
-               return -1;
-
-       cur_section = CAPTURE_CONFIG_NO_SECTION;
-       p = *contents_p;
-       for (i = 0; i < nlines; i++) {
-               tchar *endp = tmemchr(p, T('\n'), nchars);
-               size_t len = endp - p + 1;
-               *endp = T('\0');
-               if (!is_comment_line(p, len))
-                       if (!parse_capture_config_line(p, len, &cur_section, config))
-                               return -1;
-               p = endp + 1;
-
-       }
-       return 0;
-}
-
 /* Reads the contents of a file into memory. */
 static char *
 file_get_contents(const tchar *filename, size_t *len_ret)
@@ -1102,18 +1076,18 @@ report_scan_progress(const struct wimlib_progress_info_scan *scan, bool done)
                last_scan_progress = *scan;
        }
 }
-
 /* Progress callback function passed to various wimlib functions. */
-static int
+static enum wimlib_progress_status
 imagex_progress_func(enum wimlib_progress_msg msg,
-                    const union wimlib_progress_info *info)
+                    union wimlib_progress_info *info,
+                    void *_ignored_context)
 {
        unsigned percent_done;
        unsigned unit_shift;
        const tchar *unit_name;
 
        if (imagex_be_quiet)
-               return 0;
+               return WIMLIB_PROGRESS_STATUS_CONTINUE;
        switch (msg) {
        case WIMLIB_PROGRESS_MSG_WRITE_STREAMS:
                {
@@ -1132,39 +1106,23 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                percent_done = TO_PERCENT(info->write_streams.completed_bytes,
                                          info->write_streams.total_bytes);
 
-               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);
-               }
+               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);
                if (info->write_streams.completed_bytes >= info->write_streams.total_bytes)
                        imagex_printf(T("\n"));
                break;
        case WIMLIB_PROGRESS_MSG_SCAN_BEGIN:
                imagex_printf(T("Scanning \"%"TS"\""), info->scan.source);
-               if (*info->scan.wim_target_path) {
-                       imagex_printf(T(" (loading as WIM path: "
-                                 "\""WIMLIB_WIM_PATH_SEPARATOR_STRING"%"TS"\")...\n"),
-                              info->scan.wim_target_path);
-               } else {
+               if (WIMLIB_IS_WIM_ROOT_PATH(info->scan.wim_target_path)) {
                        imagex_printf(T("\n"));
+               } else {
+                       imagex_printf(T(" (loading as WIM path: \"%"TS"\")...\n"),
+                                     info->scan.wim_target_path);
                }
                memset(&last_scan_progress, 0, sizeof(last_scan_progress));
                break;
@@ -1180,13 +1138,22 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                        imagex_printf(T("\nWARNING: Excluding unsupported file or directory\n"
                                        "         \"%"TS"\" from capture\n"), info->scan.cur_path);
                        break;
-               case WIMLIB_SCAN_DENTRY_EXCLUDED_SYMLINK:
-                       imagex_printf(T("\nWARNING: Ignoring absolute symbolic link "
-                                       "with out-of-tree target:\n"
-                                       "           \"%"TS"\" => \"%"TS"\"\n"
+               case WIMLIB_SCAN_DENTRY_FIXED_SYMLINK:
+                       /* Symlink fixups are enabled by default.  This is
+                        * mainly intended for Windows, which for some reason
+                        * uses absolute junctions (with drive letters!) in the
+                        * default installation.  On UNIX-like systems, warn the
+                        * user when fixing the target of an absolute symbolic
+                        * link, so they know to disable this if they want.  */
+               #ifndef __WIN32__
+                       imagex_printf(T("\nWARNING: Adjusted target of "
+                                       "absolute symbolic link \"%"TS"\"\n"
                                        "           (Use --norpfix to capture "
                                        "absolute symbolic links as-is)\n"),
-                                       info->scan.cur_path, info->scan.symlink_target);
+                                       info->scan.cur_path);
+               #endif
+                       break;
+               default:
                        break;
                }
                break;
@@ -1233,24 +1200,22 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                         T("NTFS volume") : T("directory")),
                        info->extract.target);
                break;
-       case WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN:
-               if (info->extract.extract_root_wim_source_path[0] != T('\0')) {
-                       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,
-                               info->extract.image_name,
-                               info->extract.wimfile_name,
-                               info->extract.target);
+       case WIMLIB_PROGRESS_MSG_EXTRACT_FILE_STRUCTURE:
+               if (info->extract.end_file_count >= 2000) {
+                       percent_done = TO_PERCENT(info->extract.current_file_count,
+                                                 info->extract.end_file_count);
+                       imagex_printf(T("\rCreating files: %"PRIu64" of %"PRIu64" (%u%%) done"),
+                                     info->extract.current_file_count,
+                                     info->extract.end_file_count, percent_done);
+                       if (info->extract.current_file_count == info->extract.end_file_count)
+                               imagex_printf(T("\n"));
                }
                break;
        case WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS:
                percent_done = TO_PERCENT(info->extract.completed_bytes,
                                          info->extract.total_bytes);
                unit_shift = get_unit(info->extract.total_bytes, &unit_name);
-               imagex_printf(T("\rExtracting files: "
+               imagex_printf(T("\rExtracting file data: "
                          "%"PRIu64" %"TS" of %"PRIu64" %"TS" (%u%%) done"),
                        info->extract.completed_bytes >> unit_shift,
                        unit_name,
@@ -1260,6 +1225,17 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                if (info->extract.completed_bytes >= info->extract.total_bytes)
                        imagex_printf(T("\n"));
                break;
+       case WIMLIB_PROGRESS_MSG_EXTRACT_METADATA:
+               if (info->extract.end_file_count >= 2000) {
+                       percent_done = TO_PERCENT(info->extract.current_file_count,
+                                                 info->extract.end_file_count);
+                       imagex_printf(T("\rApplying metadata to files: %"PRIu64" of %"PRIu64" (%u%%) done"),
+                                     info->extract.current_file_count,
+                                     info->extract.end_file_count, percent_done);
+                       if (info->extract.current_file_count == info->extract.end_file_count)
+                               imagex_printf(T("\n"));
+               }
+               break;
        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"),
@@ -1267,16 +1243,6 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                                      info->extract.total_parts);
                }
                break;
-       case WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS:
-               if (info->extract.extract_root_wim_source_path[0] == T('\0'))
-                       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) {
-                       imagex_printf(T("Unmounting NTFS volume \"%"TS"\"...\n"),
-                               info->extract.target);
-               }
-               break;
        case WIMLIB_PROGRESS_MSG_SPLIT_BEGIN_PART:
                percent_done = TO_PERCENT(info->split.completed_bytes,
                                          info->split.total_bytes);
@@ -1302,14 +1268,11 @@ imagex_progress_func(enum wimlib_progress_msg msg,
        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"),
+                       imagex_printf(T("Deleted WIM path \"%"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"),
+                       imagex_printf(T("Renamed WIM path \"%"TS"\" => \"%"TS"\"\n"),
                                info->update.command->rename.wim_source_path,
                                info->update.command->rename.wim_target_path);
                        break;
@@ -1318,11 +1281,52 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                        break;
                }
                break;
+       case WIMLIB_PROGRESS_MSG_REPLACE_FILE_IN_WIM:
+               imagex_printf(T("Updating \"%"TS"\" in WIM image\n"),
+                             info->replace.path_in_wim);
+               break;
+       case WIMLIB_PROGRESS_MSG_WIMBOOT_EXCLUDE:
+               imagex_printf(T("\nExtracting \"%"TS"\" as normal file (not WIMBoot pointer)\n"),
+                             info->wimboot_exclude.path_in_wim);
+               break;
+       case WIMLIB_PROGRESS_MSG_UNMOUNT_BEGIN:
+               if (info->unmount.mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) {
+                       if (info->unmount.unmount_flags & WIMLIB_UNMOUNT_FLAG_COMMIT) {
+                               imagex_printf(T("Committing changes to %"TS" (image %d)\n"),
+                                             info->unmount.mounted_wim,
+                                             info->unmount.mounted_image);
+                       } else {
+                               imagex_printf(T("Discarding changes to %"TS" (image %d)\n"),
+                                             info->unmount.mounted_wim,
+                                             info->unmount.mounted_image);
+                               imagex_printf(T("\t(Use --commit to keep changes.)\n"));
+                       }
+               }
+               break;
+       case WIMLIB_PROGRESS_MSG_BEGIN_VERIFY_IMAGE:
+               imagex_printf(T("Verifying metadata for image %"PRIu32" of %"PRIu32"\n"),
+                             info->verify_image.current_image,
+                             info->verify_image.total_images);
+               break;
+       case WIMLIB_PROGRESS_MSG_VERIFY_STREAMS:
+               percent_done = TO_PERCENT(info->verify_streams.completed_bytes,
+                                         info->verify_streams.total_bytes);
+               unit_shift = get_unit(info->verify_streams.total_bytes, &unit_name);
+               imagex_printf(T("\rVerifying file data: "
+                         "%"PRIu64" %"TS" of %"PRIu64" %"TS" (%u%%) done"),
+                       info->verify_streams.completed_bytes >> unit_shift,
+                       unit_name,
+                       info->verify_streams.total_bytes >> unit_shift,
+                       unit_name,
+                       percent_done);
+               if (info->verify_streams.completed_bytes == info->verify_streams.total_bytes)
+                       imagex_printf(T("\n"));
+               break;
        default:
                break;
        }
        fflush(imagex_info_file);
-       return 0;
+       return WIMLIB_PROGRESS_STATUS_CONTINUE;
 }
 
 static unsigned
@@ -1338,16 +1342,37 @@ parse_num_threads(const tchar *optarg)
        }
 }
 
-static uint32_t parse_chunk_size(const tchar *optarg)
+static uint32_t
+parse_chunk_size(const tchar *optarg)
 {
-       tchar *tmp;
-       unsigned long chunk_size = tstrtoul(optarg, &tmp, 10);
-       if (chunk_size >= UINT32_MAX || *tmp || tmp == optarg) {
-               imagex_error(T("Chunk size must be a non-negative integer!"));
-               return UINT32_MAX;
-       } else {
-               return chunk_size;
-       }
+       tchar *tmp;
+       uint64_t chunk_size = tstrtoul(optarg, &tmp, 10);
+       if (chunk_size == 0) {
+               imagex_error(T("Invalid chunk size specification; must be a positive integer\n"
+                              "       with optional K, M, or G suffix"));
+               return UINT32_MAX;
+       }
+       if (*tmp) {
+               if (*tmp == T('k') || *tmp == T('K')) {
+                       chunk_size <<= 10;
+                       tmp++;
+               } else if (*tmp == T('m') || *tmp == T('M')) {
+                       chunk_size <<= 20;
+                       tmp++;
+               } else if (*tmp == T('g') || *tmp == T('G')) {
+                       chunk_size <<= 30;
+                       tmp++;
+               }
+               if (*tmp && !(*tmp == T('i') && *(tmp + 1) == T('B'))) {
+                       imagex_error(T("Invalid chunk size specification; suffix must be K, M, or G"));
+                       return UINT32_MAX;
+               }
+       }
+       if (chunk_size >= UINT32_MAX) {
+               imagex_error(T("Invalid chunk size specification; the value is too large!"));
+               return UINT32_MAX;
+       }
+       return chunk_size;
 }
 
 
@@ -1381,6 +1406,8 @@ update_command_add_option(int op, const tchar *option,
                        cmd->add.add_flags |= WIMLIB_ADD_FLAG_STRICT_ACLS;
                else if (!tstrcmp(option, T("--dereference")))
                        cmd->add.add_flags |= WIMLIB_ADD_FLAG_DEREFERENCE;
+               else if (!tstrcmp(option, T("--no-replace")))
+                       cmd->add.add_flags |= WIMLIB_ADD_FLAG_NO_REPLACE;
                else
                        recognized = false;
                break;
@@ -1559,8 +1586,8 @@ parse_update_command_file(tchar **cmd_file_contents_p, size_t cmd_file_nchars,
        return cmds;
 }
 
-/* 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.  */
+/* Apply one image, or all images, from a WIM file to a directory, OR apply
+ * one image from a WIM file to an NTFS volume.  */
 static int
 imagex_apply(int argc, tchar **argv, int cmd)
 {
@@ -1582,12 +1609,6 @@ imagex_apply(int argc, tchar **argv, int cmd)
                case IMAGEX_CHECK_OPTION:
                        open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
                        break;
-               case IMAGEX_HARDLINK_OPTION:
-                       extract_flags |= WIMLIB_EXTRACT_FLAG_HARDLINK;
-                       break;
-               case IMAGEX_SYMLINK_OPTION:
-                       extract_flags |= WIMLIB_EXTRACT_FLAG_SYMLINK;
-                       break;
                case IMAGEX_VERBOSE_OPTION:
                        /* No longer does anything.  */
                        break;
@@ -1605,6 +1626,9 @@ imagex_apply(int argc, tchar **argv, int cmd)
                case IMAGEX_STRICT_ACLS_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_STRICT_ACLS;
                        break;
+               case IMAGEX_NO_ATTRIBUTES_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES;
+                       break;
                case IMAGEX_NORPFIX_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_NORPFIX;
                        break;
@@ -1618,6 +1642,14 @@ imagex_apply(int argc, tchar **argv, int cmd)
                case IMAGEX_RESUME_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_RESUME;
                        break;
+               case IMAGEX_WIMBOOT_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_WIMBOOT;
+                       break;
+               case IMAGEX_COMPACT_OPTION:
+                       ret = set_compact_mode(optarg, &extract_flags);
+                       if (ret)
+                               goto out_free_refglobs;
+                       break;
                default:
                        goto out_usage;
                }
@@ -1640,8 +1672,8 @@ imagex_apply(int argc, tchar **argv, int cmd)
                }
                wim = NULL;
        } else {
-               ret = wimlib_open_wim(wimfile, open_flags, &wim,
-                                     imagex_progress_func);
+               ret = wimlib_open_wim_with_progress(wimfile, open_flags, &wim,
+                                                   imagex_progress_func, NULL);
                if (ret)
                        goto out_free_refglobs;
 
@@ -1684,7 +1716,7 @@ imagex_apply(int argc, tchar **argv, int cmd)
 
 #ifndef __WIN32__
        {
-               /* Interpret a regular file or block device target as a NTFS
+               /* Interpret a regular file or block device target as an NTFS
                 * volume.  */
                struct stat stbuf;
 
@@ -1703,14 +1735,16 @@ imagex_apply(int argc, tchar **argv, int cmd)
 #endif
 
        if (wim) {
-               ret = wimlib_extract_image(wim, image, target, extract_flags,
-                                          imagex_progress_func);
+               ret = wimlib_extract_image(wim, image, target, extract_flags);
        } 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);
+               ret = wimlib_extract_image_from_pipe_with_progress(
+                                          STDIN_FILENO,
+                                          image_num_or_name,
+                                          target,
+                                          extract_flags,
+                                          imagex_progress_func,
+                                          NULL);
        }
        if (ret == 0) {
                imagex_printf(T("Done applying WIM image.\n"));
@@ -1744,13 +1778,15 @@ static int
 imagex_capture_or_append(int argc, tchar **argv, int cmd)
 {
        int c;
-       int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
-       int add_image_flags = WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE |
-                             WIMLIB_ADD_IMAGE_FLAG_WINCONFIG |
-                             WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
+       int open_flags = 0;
+       int add_flags = WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE |
+                       WIMLIB_ADD_FLAG_WINCONFIG |
+                       WIMLIB_ADD_FLAG_VERBOSE;
        int write_flags = 0;
        int compression_type = WIMLIB_COMPRESSION_TYPE_INVALID;
        uint32_t chunk_size = UINT32_MAX;
+       uint32_t solid_chunk_size = UINT32_MAX;
+       int solid_ctype = WIMLIB_COMPRESSION_TYPE_INVALID;
        const tchar *wimfile;
        int wim_fd;
        const tchar *name;
@@ -1772,9 +1808,7 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
        tchar *source;
        tchar *source_copy;
 
-       const tchar *config_file = NULL;
-       tchar *config_str;
-       struct wimlib_capture_config *config;
+       tchar *config_file = NULL;
 
        bool source_list = false;
        size_t source_list_nchars = 0;
@@ -1783,12 +1817,11 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
        struct wimlib_capture_source *capture_sources;
        size_t num_sources;
        bool name_defaulted;
-       bool compress_slow = false;
 
        for_opt(c, capture_or_append_options) {
                switch (c) {
                case IMAGEX_BOOT_OPTION:
-                       add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_BOOT;
+                       add_flags |= WIMLIB_ADD_FLAG_BOOT;
                        break;
                case IMAGEX_CHECK_OPTION:
                        open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
@@ -1799,7 +1832,7 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                        break;
                case IMAGEX_CONFIG_OPTION:
                        config_file = optarg;
-                       add_image_flags &= ~WIMLIB_ADD_IMAGE_FLAG_WINCONFIG;
+                       add_flags &= ~WIMLIB_ADD_FLAG_WINCONFIG;
                        break;
                case IMAGEX_COMPRESS_OPTION:
                        compression_type = get_compression_type(optarg);
@@ -1807,21 +1840,34 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                                goto out_err;
                        break;
                case IMAGEX_COMPRESS_SLOW_OPTION:
-                       compress_slow = true;
+                       set_compress_slow();
                        break;
                case IMAGEX_CHUNK_SIZE_OPTION:
                        chunk_size = parse_chunk_size(optarg);
                        if (chunk_size == UINT32_MAX)
                                goto out_err;
                        break;
-               case IMAGEX_PACK_STREAMS_OPTION:
-                       write_flags |= WIMLIB_WRITE_FLAG_PACK_STREAMS;
+               case IMAGEX_SOLID_CHUNK_SIZE_OPTION:
+                       solid_chunk_size = parse_chunk_size(optarg);
+                       if (solid_chunk_size == UINT32_MAX)
+                               goto out_err;
+                       break;
+               case IMAGEX_SOLID_COMPRESS_OPTION:
+                       solid_ctype = get_compression_type(optarg);
+                       if (solid_ctype == WIMLIB_COMPRESSION_TYPE_INVALID)
+                               goto out_err;
+                       break;
+               case IMAGEX_SOLID_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_SOLID;
+                       break;
+               case IMAGEX_NO_SOLID_SORT_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NO_SOLID_SORT;
                        break;
                case IMAGEX_FLAGS_OPTION:
                        flags_element = optarg;
                        break;
                case IMAGEX_DEREFERENCE_OPTION:
-                       add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
+                       add_flags |= WIMLIB_ADD_FLAG_DEREFERENCE;
                        break;
                case IMAGEX_VERBOSE_OPTION:
                        /* No longer does anything.  */
@@ -1835,22 +1881,22 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                        write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
                        break;
                case IMAGEX_UNIX_DATA_OPTION:
-                       add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA;
+                       add_flags |= WIMLIB_ADD_FLAG_UNIX_DATA;
                        break;
                case IMAGEX_SOURCE_LIST_OPTION:
                        source_list = true;
                        break;
                case IMAGEX_NO_ACLS_OPTION:
-                       add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_NO_ACLS;
+                       add_flags |= WIMLIB_ADD_FLAG_NO_ACLS;
                        break;
                case IMAGEX_STRICT_ACLS_OPTION:
-                       add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_STRICT_ACLS;
+                       add_flags |= WIMLIB_ADD_FLAG_STRICT_ACLS;
                        break;
                case IMAGEX_RPFIX_OPTION:
-                       add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_RPFIX;
+                       add_flags |= WIMLIB_ADD_FLAG_RPFIX;
                        break;
                case IMAGEX_NORPFIX_OPTION:
-                       add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_NORPFIX;
+                       add_flags |= WIMLIB_ADD_FLAG_NORPFIX;
                        break;
                case IMAGEX_PIPABLE_OPTION:
                        write_flags |= WIMLIB_WRITE_FLAG_PIPABLE;
@@ -1888,6 +1934,9 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                                goto out_free_base_wimfiles;
                        write_flags |= WIMLIB_WRITE_FLAG_SKIP_EXTERNAL_WIMS;
                        break;
+               case IMAGEX_WIMBOOT_OPTION:
+                       add_flags |= WIMLIB_ADD_FLAG_WIMBOOT;
+                       break;
                default:
                        goto out_usage;
                }
@@ -1905,22 +1954,21 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
 
 
        if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID) {
-               compression_type = WIMLIB_COMPRESSION_TYPE_LZX;
-
-               if (!compress_slow) {
-                       struct wimlib_lzx_compressor_params params = {
-                               .hdr.size = sizeof(params),
-                               .algorithm = WIMLIB_LZX_ALGORITHM_FAST,
-                               .use_defaults = 1,
-                       };
-                       wimlib_set_default_compressor_params(WIMLIB_COMPRESSION_TYPE_LZX,
-                                                            &params.hdr);
+               /* No compression type specified.  Use the default.  */
+
+               if (add_flags & WIMLIB_ADD_FLAG_WIMBOOT) {
+                       /* With --wimboot, default to XPRESS compression.  */
+                       compression_type = WIMLIB_COMPRESSION_TYPE_XPRESS;
+               } else if (write_flags & WIMLIB_WRITE_FLAG_SOLID) {
+                       /* With --solid, default to LZMS compression.  (However,
+                        * this will not affect solid resources!)  */
+                       compression_type = WIMLIB_COMPRESSION_TYPE_LZMS;
+               } else {
+                       /* Otherwise, default to LZX compression.  */
+                       compression_type = WIMLIB_COMPRESSION_TYPE_LZX;
                }
        }
 
-       if (compress_slow)
-               set_compress_slow();
-
        if (!tstrcmp(wimfile, T("-"))) {
                /* Writing captured WIM to standard output.  */
        #if 0
@@ -2018,48 +2066,49 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                /* 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;
+               capture_sources[0].wim_target_path = WIMLIB_WIM_ROOT_PATH;
                capture_sources[0].reserved = 0;
                num_sources = 1;
                capture_sources_malloced = false;
                source_list_contents = NULL;
        }
 
-       if (config_file) {
-               /* Read and parse capture configuration file.  */
-               size_t config_len;
-
-               config_str = file_get_text_contents(config_file, &config_len);
-               if (!config_str) {
-                       ret = -1;
-                       goto out_free_capture_sources;
-               }
-
-               config = alloca(sizeof(*config));
-               ret = parse_capture_config(&config_str, config_len, config);
+       /* Open the existing WIM, or create a new one.  */
+       if (cmd == CMD_APPEND) {
+               ret = wimlib_open_wim_with_progress(wimfile,
+                                                   open_flags | WIMLIB_OPEN_FLAG_WRITE_ACCESS,
+                                                   &wim,
+                                                   imagex_progress_func,
+                                                   NULL);
                if (ret)
-                       goto out_free_config;
+                       goto out_free_capture_sources;
        } else {
-               /* No capture configuration file specified; use default
-                * configuration for capturing Windows operating systems.  */
-               config = NULL;
-               add_image_flags |= WIMLIB_ADD_FLAG_WINCONFIG;
-       }
-
-       /* 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, &wim);
-       if (ret)
-               goto out_free_config;
+               if (ret)
+                       goto out_free_capture_sources;
+               wimlib_register_progress_function(wim, imagex_progress_func, NULL);
+       }
 
        /* Set chunk size if non-default.  */
        if (chunk_size != UINT32_MAX) {
                ret = wimlib_set_output_chunk_size(wim, chunk_size);
                if (ret)
                        goto out_free_wim;
+       } else if ((add_flags & WIMLIB_ADD_FLAG_WIMBOOT) &&
+                  compression_type == WIMLIB_COMPRESSION_TYPE_XPRESS) {
+               ret = wimlib_set_output_chunk_size(wim, 4096);
+               if (ret)
+                       goto out_free_wim;
+       }
+       if (solid_ctype != WIMLIB_COMPRESSION_TYPE_INVALID) {
+               ret = wimlib_set_output_pack_compression_type(wim, solid_ctype);
+               if (ret)
+                       goto out_free_wim;
+       }
+       if (solid_chunk_size != UINT32_MAX) {
+               ret = wimlib_set_output_pack_chunk_size(wim, solid_chunk_size);
+               if (ret)
+                       goto out_free_wim;
        }
 
 #ifndef __WIN32__
@@ -2072,7 +2121,7 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                        if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode)) {
                                imagex_printf(T("Capturing WIM image from NTFS "
                                          "filesystem on \"%"TS"\"\n"), source);
-                               add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_NTFS;
+                               add_flags |= WIMLIB_ADD_FLAG_NTFS;
                        }
                } else {
                        if (errno != ENOENT) {
@@ -2111,9 +2160,9 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                }
 
                for (size_t i = 0; i < base_wimfiles.num_strings; i++) {
-                       ret = wimlib_open_wim(base_wimfiles.strings[i],
-                                             open_flags, &base_wims[i],
-                                             imagex_progress_func);
+                       ret = wimlib_open_wim_with_progress(
+                                   base_wimfiles.strings[i], open_flags,
+                                   &base_wims[i], imagex_progress_func, NULL);
                        if (ret)
                                goto out_free_base_wims;
 
@@ -2147,8 +2196,11 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                } else if (template_wimfile == wimfile) {
                        template_wim = wim;
                } else {
-                       ret = wimlib_open_wim(template_wimfile, open_flags,
-                                             &template_wim, imagex_progress_func);
+                       ret = wimlib_open_wim_with_progress(template_wimfile,
+                                                           open_flags,
+                                                           &template_wim,
+                                                           imagex_progress_func,
+                                                           NULL);
                        if (ret)
                                goto out_free_base_wims;
                }
@@ -2183,9 +2235,8 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                                           capture_sources,
                                           num_sources,
                                           name,
-                                          config,
-                                          add_image_flags,
-                                          imagex_progress_func);
+                                          config_file,
+                                          add_flags);
        if (ret)
                goto out_free_template_wim;
 
@@ -2222,7 +2273,7 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                                                              info.image_count,
                                                              template_wim,
                                                              template_image,
-                                                             0, NULL);
+                                                             0);
                        if (ret)
                                goto out_free_template_wim;
                }
@@ -2231,16 +2282,13 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
        /* 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);
+               ret = wimlib_overwrite(wim, write_flags, num_threads);
        } else if (wimfile) {
                ret = wimlib_write(wim, wimfile, WIMLIB_ALL_IMAGES,
-                                  write_flags, num_threads,
-                                  imagex_progress_func);
+                                  write_flags, num_threads);
        } else {
                ret = wimlib_write_to_fd(wim, wim_fd, WIMLIB_ALL_IMAGES,
-                                        write_flags, num_threads,
-                                        imagex_progress_func);
+                                        write_flags, num_threads);
        }
 out_free_template_wim:
        /* template_wim may alias base_wims[0] or wim.  */
@@ -2253,12 +2301,6 @@ out_free_base_wims:
        free(base_wims);
 out_free_wim:
        wimlib_free(wim);
-out_free_config:
-       if (config) {
-               free(config->exclusion_pats.pats);
-               free(config->exclusion_exception_pats.pats);
-               free(config_str);
-       }
 out_free_capture_sources:
        if (capture_sources_malloced)
                free(capture_sources);
@@ -2314,8 +2356,8 @@ imagex_delete(int argc, tchar **argv, int cmd)
        wimfile = argv[0];
        image_num_or_name = argv[1];
 
-       ret = wimlib_open_wim(wimfile, open_flags, &wim,
-                             imagex_progress_func);
+       ret = wimlib_open_wim_with_progress(wimfile, open_flags, &wim,
+                                           imagex_progress_func, NULL);
        if (ret)
                goto out;
 
@@ -2332,7 +2374,7 @@ imagex_delete(int argc, tchar **argv, int cmd)
                goto out_wimlib_free;
        }
 
-       ret = wimlib_overwrite(wim, write_flags, 0, imagex_progress_func);
+       ret = wimlib_overwrite(wim, write_flags, 0);
        if (ret) {
                imagex_error(T("Failed to write the file \"%"TS"\" with image "
                               "deleted"), wimfile);
@@ -2348,78 +2390,315 @@ out_usage:
        goto out;
 }
 
-static int
-print_full_path(const struct wimlib_dir_entry *wdentry, void *_ignore)
+struct print_dentry_options {
+       bool detailed;
+};
+
+static void
+print_dentry_full_path(const struct wimlib_dir_entry *dentry)
 {
-       int ret = tprintf(T("%"TS"\n"), wdentry->full_path);
-       return (ret >= 0) ? 0 : -1;
+       tprintf(T("%"TS"\n"), dentry->full_path);
 }
 
-/* Print the files contained in an image(s) in a WIM file. */
-static int
-imagex_dir(int argc, tchar **argv, int cmd)
-{
-       const tchar *wimfile;
-       WIMStruct *wim = NULL;
-       int image;
-       int ret;
-       const tchar *path = T("");
-       int c;
+static const struct {
+       uint32_t flag;
+       const tchar *name;
+} file_attr_flags[] = {
+       {WIMLIB_FILE_ATTRIBUTE_READONLY,            T("READONLY")},
+       {WIMLIB_FILE_ATTRIBUTE_HIDDEN,              T("HIDDEN")},
+       {WIMLIB_FILE_ATTRIBUTE_SYSTEM,              T("SYSTEM")},
+       {WIMLIB_FILE_ATTRIBUTE_DIRECTORY,           T("DIRECTORY")},
+       {WIMLIB_FILE_ATTRIBUTE_ARCHIVE,             T("ARCHIVE")},
+       {WIMLIB_FILE_ATTRIBUTE_DEVICE,              T("DEVICE")},
+       {WIMLIB_FILE_ATTRIBUTE_NORMAL,              T("NORMAL")},
+       {WIMLIB_FILE_ATTRIBUTE_TEMPORARY,           T("TEMPORARY")},
+       {WIMLIB_FILE_ATTRIBUTE_SPARSE_FILE,         T("SPARSE_FILE")},
+       {WIMLIB_FILE_ATTRIBUTE_REPARSE_POINT,       T("REPARSE_POINT")},
+       {WIMLIB_FILE_ATTRIBUTE_COMPRESSED,          T("COMPRESSED")},
+       {WIMLIB_FILE_ATTRIBUTE_OFFLINE,             T("OFFLINE")},
+       {WIMLIB_FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, T("NOT_CONTENT_INDEXED")},
+       {WIMLIB_FILE_ATTRIBUTE_ENCRYPTED,           T("ENCRYPTED")},
+       {WIMLIB_FILE_ATTRIBUTE_VIRTUAL,             T("VIRTUAL")},
+};
 
-       for_opt(c, dir_options) {
-               switch (c) {
-               case IMAGEX_PATH_OPTION:
-                       path = optarg;
-                       break;
-               default:
-                       goto out_usage;
-               }
-       }
-       argc -= optind;
-       argv += optind;
+#define TIMESTR_MAX 100
 
-       if (argc < 1) {
-               imagex_error(T("Must specify a WIM file"));
-               goto out_usage;
-       }
-       if (argc > 2) {
-               imagex_error(T("Too many arguments"));
-               goto out_usage;
-       }
+static void
+timespec_to_string(const struct timespec *spec, tchar *buf)
+{
+       time_t t = spec->tv_sec;
+       struct tm tm;
+       gmtime_r(&t, &tm);
+       tstrftime(buf, TIMESTR_MAX, T("%a %b %d %H:%M:%S %Y UTC"), &tm);
+       buf[TIMESTR_MAX - 1] = '\0';
+}
 
-       wimfile = argv[0];
-       ret = wimlib_open_wim(wimfile, 0, &wim, imagex_progress_func);
-       if (ret)
-               goto out;
+static void
+print_time(const tchar *type, const struct timespec *spec)
+{
+       tchar timestr[TIMESTR_MAX];
 
-       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 {
-               /* No image specified; default to image 1, but only if the WIM
-                * contains exactly one image.  */
+       timespec_to_string(spec, timestr);
 
-               struct wimlib_wim_info info;
+       tprintf(T("%-20"TS"= %"TS"\n"), type, timestr);
+}
 
-               wimlib_get_wim_info(wim, &info);
-               if (info.image_count != 1) {
-                       imagex_error(T("\"%"TS"\" contains %d images; Please "
-                                      "select one (or all)."),
-                                    wimfile, info.image_count);
-                       wimlib_free(wim);
-                       goto out_usage;
-               }
-               image = 1;
-       }
+static void print_byte_field(const uint8_t field[], size_t len)
+{
+       while (len--)
+               tprintf(T("%02hhx"), *field++);
+}
 
-       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:
+static void
+print_wim_information(const tchar *wimfile, const struct wimlib_wim_info *info)
+{
+       tchar attr_string[256];
+       tchar *p;
+
+       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("Version:        %u\n"), info->wim_version);
+       tprintf(T("Image Count:    %d\n"), info->image_count);
+       tprintf(T("Compression:    %"TS"\n"),
+               wimlib_get_compression_type_string(info->compression_type));
+       tprintf(T("Chunk Size:     %"PRIu32" bytes\n"),
+               info->chunk_size);
+       tprintf(T("Part Number:    %d/%d\n"), info->part_number, info->total_parts);
+       tprintf(T("Boot Index:     %d\n"), info->boot_index);
+       tprintf(T("Size:           %"PRIu64" bytes\n"), info->total_bytes);
+
+       attr_string[0] = T('\0');
+
+       if (info->pipable)
+               tstrcat(attr_string, T("Pipable, "));
+
+       if (info->has_integrity_table)
+               tstrcat(attr_string, T("Integrity info, "));
+
+       if (info->has_rpfix)
+               tstrcat(attr_string, T("Relative path junction, "));
+
+       if (info->resource_only)
+               tstrcat(attr_string, T("Resource only, "));
+
+       if (info->metadata_only)
+               tstrcat(attr_string, T("Metadata only, "));
+
+       if (info->is_marked_readonly)
+               tstrcat(attr_string, T("Readonly, "));
+
+       p = tstrchr(attr_string, T('\0'));
+       if (p >= &attr_string[2] && p[-1] == T(' ') && p[-2] == T(','))
+               p[-2] = T('\0');
+
+       tprintf(T("Attributes:     %"TS"\n\n"), attr_string);
+}
+
+static int
+print_resource(const struct wimlib_resource_entry *resource,
+              void *_ignore)
+{
+       tprintf(T("Hash              = 0x"));
+       print_byte_field(resource->sha1_hash, sizeof(resource->sha1_hash));
+       tputchar(T('\n'));
+
+       if (!resource->is_missing) {
+               tprintf(T("Uncompressed size = %"PRIu64" bytes\n"),
+                       resource->uncompressed_size);
+               if (resource->packed) {
+                       tprintf(T("Solid resource    = %"PRIu64" => %"PRIu64" "
+                                 "bytes @ offset %"PRIu64"\n"),
+                               resource->raw_resource_uncompressed_size,
+                               resource->raw_resource_compressed_size,
+                               resource->raw_resource_offset_in_wim);
+
+                       tprintf(T("Solid offset      = %"PRIu64" bytes\n"),
+                               resource->offset);
+               } else {
+                       tprintf(T("Compressed size   = %"PRIu64" bytes\n"),
+                               resource->compressed_size);
+
+                       tprintf(T("Offset in WIM     = %"PRIu64" bytes\n"),
+                               resource->offset);
+               }
+
+               tprintf(T("Part Number       = %u\n"), resource->part_number);
+               tprintf(T("Reference Count   = %u\n"), resource->reference_count);
+
+               tprintf(T("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  "));
+               if (resource->packed)
+                       tprintf(T("WIM_RESHDR_FLAG_SOLID  "));
+               tputchar(T('\n'));
+       }
+       tputchar(T('\n'));
+       return 0;
+}
+
+static void
+print_blobs(WIMStruct *wim)
+{
+       wimlib_iterate_lookup_table(wim, 0, print_resource, NULL);
+}
+
+static void
+default_print_security_descriptor(const uint8_t *sd, size_t size)
+{
+       tprintf(T("Security Descriptor = "));
+       print_byte_field(sd, size);
+       tputchar(T('\n'));
+}
+
+static void
+print_dentry_detailed(const struct wimlib_dir_entry *dentry)
+{
+
+       tprintf(T(
+"----------------------------------------------------------------------------\n"));
+       tprintf(T("Full Path           = \"%"TS"\"\n"), dentry->full_path);
+       if (dentry->dos_name)
+               tprintf(T("Short Name          = \"%"TS"\"\n"), dentry->dos_name);
+       tprintf(T("Attributes          = 0x%08x\n"), dentry->attributes);
+       for (size_t i = 0; i < ARRAY_LEN(file_attr_flags); i++)
+               if (file_attr_flags[i].flag & dentry->attributes)
+                       tprintf(T("    FILE_ATTRIBUTE_%"TS" is set\n"),
+                               file_attr_flags[i].name);
+
+       if (dentry->security_descriptor) {
+               print_security_descriptor(dentry->security_descriptor,
+                                         dentry->security_descriptor_size);
+       }
+
+       print_time(T("Creation Time"), &dentry->creation_time);
+       print_time(T("Last Write Time"), &dentry->last_write_time);
+       print_time(T("Last Access Time"), &dentry->last_access_time);
+
+
+       if (dentry->attributes & WIMLIB_FILE_ATTRIBUTE_REPARSE_POINT)
+               tprintf(T("Reparse Tag         = 0x%"PRIx32"\n"), dentry->reparse_tag);
+
+       tprintf(T("Link Group ID       = 0x%016"PRIx64"\n"), dentry->hard_link_group_id);
+       tprintf(T("Link Count          = %"PRIu32"\n"), dentry->num_links);
+
+       if (dentry->unix_mode != 0) {
+               tprintf(T("UNIX Data           = uid:%"PRIu32" gid:%"PRIu32" "
+                         "mode:0%"PRIo32" rdev:0x%"PRIx32"\n"),
+                       dentry->unix_uid, dentry->unix_gid,
+                       dentry->unix_mode, dentry->unix_rdev);
+       }
+
+       for (uint32_t i = 0; i <= dentry->num_named_streams; i++) {
+               if (dentry->streams[i].stream_name) {
+                       tprintf(T("\tNamed data stream \"%"TS"\":\n"),
+                               dentry->streams[i].stream_name);
+               } else if (dentry->attributes & WIMLIB_FILE_ATTRIBUTE_ENCRYPTED) {
+                       tprintf(T("\tRaw encrypted data stream:\n"));
+               } else if (dentry->attributes & WIMLIB_FILE_ATTRIBUTE_REPARSE_POINT) {
+                       tprintf(T("\tReparse point stream:\n"));
+               } else {
+                       tprintf(T("\tUnnamed data stream:\n"));
+               }
+               print_resource(&dentry->streams[i].resource, NULL);
+       }
+}
+
+static int
+print_dentry(const struct wimlib_dir_entry *dentry, void *_options)
+{
+       const struct print_dentry_options *options = _options;
+       if (!options->detailed)
+               print_dentry_full_path(dentry);
+       else
+               print_dentry_detailed(dentry);
+       return 0;
+}
+
+/* Print the files contained in an image(s) in a WIM file. */
+static int
+imagex_dir(int argc, tchar **argv, int cmd)
+{
+       const tchar *wimfile;
+       WIMStruct *wim = NULL;
+       int image;
+       int ret;
+       const tchar *path = WIMLIB_WIM_ROOT_PATH;
+       int c;
+       struct print_dentry_options options = {
+               .detailed = false,
+       };
+       int iterate_flags = WIMLIB_ITERATE_DIR_TREE_FLAG_RECURSIVE;
+
+       for_opt(c, dir_options) {
+               switch (c) {
+               case IMAGEX_PATH_OPTION:
+                       path = optarg;
+                       break;
+               case IMAGEX_DETAILED_OPTION:
+                       options.detailed = true;
+                       break;
+               case IMAGEX_ONE_FILE_ONLY_OPTION:
+                       iterate_flags &= ~WIMLIB_ITERATE_DIR_TREE_FLAG_RECURSIVE;
+                       break;
+               default:
+                       goto out_usage;
+               }
+       }
+       argc -= optind;
+       argv += optind;
+
+       if (argc < 1) {
+               imagex_error(T("Must specify a WIM file"));
+               goto out_usage;
+       }
+       if (argc > 2) {
+               imagex_error(T("Too many arguments"));
+               goto out_usage;
+       }
+
+       wimfile = argv[0];
+       ret = wimlib_open_wim_with_progress(wimfile, 0, &wim,
+                                           imagex_progress_func, NULL);
+       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 {
+               /* 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 (or all)."),
+                                    wimfile, info.image_count);
+                       wimlib_free(wim);
+                       goto out_usage;
+               }
+               image = 1;
+       }
+
+       ret = wimlib_iterate_dir_tree(wim, image, path, iterate_flags,
+                                     print_dentry, &options);
+out_wimlib_free:
+       wimlib_free(wim);
+out:
        return ret;
 
 out_usage:
@@ -2435,7 +2714,7 @@ imagex_export(int argc, tchar **argv, int cmd)
 {
        int c;
        int open_flags = 0;
-       int export_flags = 0;
+       int export_flags = WIMLIB_EXPORT_FLAG_GIFT;
        int write_flags = 0;
        int compression_type = WIMLIB_COMPRESSION_TYPE_INVALID;
        const tchar *src_wimfile;
@@ -2454,6 +2733,8 @@ imagex_export(int argc, tchar **argv, int cmd)
        STRING_SET(refglobs);
        unsigned num_threads = 0;
        uint32_t chunk_size = UINT32_MAX;
+       uint32_t solid_chunk_size = UINT32_MAX;
+       int solid_ctype = WIMLIB_COMPRESSION_TYPE_INVALID;
 
        for_opt(c, export_options) {
                switch (c) {
@@ -2472,14 +2753,34 @@ imagex_export(int argc, tchar **argv, int cmd)
                        if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID)
                                goto out_err;
                        break;
-               case IMAGEX_PACK_STREAMS_OPTION:
-                       write_flags |= WIMLIB_WRITE_FLAG_PACK_STREAMS;
+               case IMAGEX_COMPRESS_SLOW_OPTION:
+                       set_compress_slow();
+                       write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
+                       break;
+               case IMAGEX_RECOMPRESS_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
+                       break;
+               case IMAGEX_SOLID_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_SOLID;
+                       break;
+               case IMAGEX_NO_SOLID_SORT_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NO_SOLID_SORT;
                        break;
                case IMAGEX_CHUNK_SIZE_OPTION:
                        chunk_size = parse_chunk_size(optarg);
                        if (chunk_size == UINT32_MAX)
                                goto out_err;
                        break;
+               case IMAGEX_SOLID_CHUNK_SIZE_OPTION:
+                       solid_chunk_size = parse_chunk_size(optarg);
+                       if (solid_chunk_size == UINT32_MAX)
+                               goto out_err;
+                       break;
+               case IMAGEX_SOLID_COMPRESS_OPTION:
+                       solid_ctype = get_compression_type(optarg);
+                       if (solid_ctype == WIMLIB_COMPRESSION_TYPE_INVALID)
+                               goto out_err;
+                       break;
                case IMAGEX_REF_OPTION:
                        ret = string_set_append(&refglobs, optarg);
                        if (ret)
@@ -2499,6 +2800,9 @@ imagex_export(int argc, tchar **argv, int cmd)
                case IMAGEX_NOT_PIPABLE_OPTION:
                        write_flags |= WIMLIB_WRITE_FLAG_NOT_PIPABLE;
                        break;
+               case IMAGEX_WIMBOOT_OPTION:
+                       export_flags |= WIMLIB_EXPORT_FLAG_WIMBOOT;
+                       break;
                default:
                        goto out_usage;
                }
@@ -2512,8 +2816,8 @@ imagex_export(int argc, tchar **argv, int cmd)
        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, &src_wim,
-                             imagex_progress_func);
+       ret = wimlib_open_wim_with_progress(src_wimfile, open_flags, &src_wim,
+                                           imagex_progress_func, NULL);
        if (ret)
                goto out_free_refglobs;
 
@@ -2553,9 +2857,12 @@ imagex_export(int argc, tchar **argv, int cmd)
                        ret = -1;
                        goto out_free_src_wim;
                }
-               ret = wimlib_open_wim(dest_wimfile,
-                                     open_flags | WIMLIB_OPEN_FLAG_WRITE_ACCESS,
-                                     &dest_wim, imagex_progress_func);
+               ret = wimlib_open_wim_with_progress(dest_wimfile,
+                                                   open_flags |
+                                                       WIMLIB_OPEN_FLAG_WRITE_ACCESS,
+                                                   &dest_wim,
+                                                   imagex_progress_func,
+                                                   NULL);
                if (ret)
                        goto out_free_src_wim;
 
@@ -2589,18 +2896,34 @@ imagex_export(int argc, tchar **argv, int cmd)
 
                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;
+                        * to that of the source WIM, unless --solid or
+                        * --wimboot was specified.   */
+
+                       if (write_flags & WIMLIB_WRITE_FLAG_SOLID)
+                               compression_type = WIMLIB_COMPRESSION_TYPE_LZMS;
+                       else if (export_flags & WIMLIB_EXPORT_FLAG_WIMBOOT)
+                               compression_type = WIMLIB_COMPRESSION_TYPE_XPRESS;
+                       else
+                               compression_type = src_info.compression_type;
                }
                ret = wimlib_create_new_wim(compression_type, &dest_wim);
                if (ret)
                        goto out_free_src_wim;
 
-               /* Use same chunk size if compression type is the same.  */
-               if (compression_type == src_info.compression_type &&
-                   chunk_size == UINT32_MAX)
+               wimlib_register_progress_function(dest_wim,
+                                                 imagex_progress_func, NULL);
+
+               if ((export_flags & WIMLIB_EXPORT_FLAG_WIMBOOT)
+                   && compression_type == WIMLIB_COMPRESSION_TYPE_XPRESS)
+               {
+                       /* For --wimboot export, use small XPRESS chunks.  */
+                       wimlib_set_output_chunk_size(dest_wim, 4096);
+               } else if (compression_type == src_info.compression_type &&
+                          chunk_size == UINT32_MAX)
+               {
+                       /* Use same chunk size if compression type is the same.  */
                        wimlib_set_output_chunk_size(dest_wim, src_info.chunk_size);
+               }
        }
 
        if (chunk_size != UINT32_MAX) {
@@ -2609,6 +2932,16 @@ imagex_export(int argc, tchar **argv, int cmd)
                if (ret)
                        goto out_free_dest_wim;
        }
+       if (solid_ctype != WIMLIB_COMPRESSION_TYPE_INVALID) {
+               ret = wimlib_set_output_pack_compression_type(dest_wim, solid_ctype);
+               if (ret)
+                       goto out_free_dest_wim;
+       }
+       if (solid_chunk_size != UINT32_MAX) {
+               ret = wimlib_set_output_pack_chunk_size(dest_wim, solid_chunk_size);
+               if (ret)
+                       goto out_free_dest_wim;
+       }
 
        image = wimlib_resolve_image(src_wim, src_image_num_or_name);
        ret = verify_image_exists(image, src_image_num_or_name, src_wimfile);
@@ -2631,7 +2964,7 @@ imagex_export(int argc, tchar **argv, int cmd)
        }
 
        ret = wimlib_export_image(src_wim, image, dest_wim, dest_name,
-                                 dest_desc, export_flags, imagex_progress_func);
+                                 dest_desc, export_flags);
        if (ret) {
                if (ret == WIMLIB_ERR_RESOURCE_NOT_FOUND) {
                        do_resource_not_found_warning(src_wimfile,
@@ -2641,16 +2974,14 @@ imagex_export(int argc, tchar **argv, int cmd)
        }
 
        if (!wim_is_new)
-               ret = wimlib_overwrite(dest_wim, write_flags, num_threads,
-                                      imagex_progress_func);
+               ret = wimlib_overwrite(dest_wim, write_flags, num_threads);
        else if (dest_wimfile)
                ret = wimlib_write(dest_wim, dest_wimfile, WIMLIB_ALL_IMAGES,
-                                  write_flags, num_threads,
-                                  imagex_progress_func);
+                                  write_flags, num_threads);
        else
                ret = wimlib_write_to_fd(dest_wim, dest_wim_fd,
                                         WIMLIB_ALL_IMAGES, write_flags,
-                                        num_threads, imagex_progress_func);
+                                        num_threads);
 out_free_dest_wim:
        wimlib_free(dest_wim);
 out_free_src_wim:
@@ -2666,67 +2997,6 @@ out_err:
        goto out_free_refglobs;
 }
 
-static bool
-is_root_wim_path(const tchar *path)
-{
-       const tchar *p;
-       for (p = path; *p; p++)
-               if (*p != T('\\') && *p != T('/'))
-                       return false;
-       return true;
-}
-
-static void
-free_extract_commands(struct wimlib_extract_command *cmds, size_t num_cmds,
-                     const tchar *dest_dir)
-{
-       for (size_t i = 0; i < num_cmds; i++)
-               if (cmds[i].fs_dest_path != dest_dir)
-                       free(cmds[i].fs_dest_path);
-       free(cmds);
-}
-
-static struct wimlib_extract_command *
-prepare_extract_commands(tchar **paths, unsigned num_paths,
-                        int extract_flags, tchar *dest_dir,
-                        size_t *num_cmds_ret)
-{
-       struct wimlib_extract_command *cmds;
-       size_t num_cmds;
-       tchar *emptystr = T("");
-
-       if (num_paths == 0) {
-               num_paths = 1;
-               paths = &emptystr;
-       }
-       num_cmds = num_paths;
-       cmds = calloc(num_cmds, sizeof(cmds[0]));
-       if (!cmds) {
-               imagex_error(T("Out of memory!"));
-               return NULL;
-       }
-
-       for (size_t i = 0; i < num_cmds; i++) {
-               cmds[i].extract_flags = extract_flags;
-               cmds[i].wim_source_path = paths[i];
-               if (is_root_wim_path(paths[i])) {
-                       cmds[i].fs_dest_path = dest_dir;
-               } else {
-                       size_t len = tstrlen(dest_dir) + 1 + tstrlen(paths[i]);
-                       cmds[i].fs_dest_path = malloc((len + 1) * sizeof(tchar));
-                       if (!cmds[i].fs_dest_path) {
-                               free_extract_commands(cmds, num_cmds, dest_dir);
-                               return NULL;
-                       }
-                       tsprintf(cmds[i].fs_dest_path,
-                                T("%"TS""OS_PREFERRED_PATH_SEPARATOR_STRING"%"TS),
-                                dest_dir, tbasename(paths[i]));
-               }
-       }
-       *num_cmds_ret = num_cmds;
-       return cmds;
-}
-
 /* Extract files or directories from a WIM image */
 static int
 imagex_extract(int argc, tchar **argv, int cmd)
@@ -2738,15 +3008,15 @@ imagex_extract(int argc, tchar **argv, int cmd)
        int ret;
        const tchar *wimfile;
        const tchar *image_num_or_name;
-       const tchar *pathlist;
        tchar *dest_dir = T(".");
-       int extract_flags = WIMLIB_EXTRACT_FLAG_NORPFIX;
-       int listfile_extract_flags = WIMLIB_EXTRACT_FLAG_GLOB_PATHS;
+       int extract_flags = WIMLIB_EXTRACT_FLAG_NORPFIX |
+                           WIMLIB_EXTRACT_FLAG_GLOB_PATHS |
+                           WIMLIB_EXTRACT_FLAG_STRICT_GLOB;
+       int notlist_extract_flags = WIMLIB_EXTRACT_FLAG_NO_PRESERVE_DIR_STRUCTURE;
 
        STRING_SET(refglobs);
 
-       struct wimlib_extract_command *cmds;
-       size_t num_cmds;
+       tchar *root_path = WIMLIB_WIM_ROOT_PATH;
 
        for_opt(c, extract_options) {
                switch (c) {
@@ -2770,6 +3040,9 @@ imagex_extract(int argc, tchar **argv, int cmd)
                case IMAGEX_STRICT_ACLS_OPTION:
                        extract_flags |= WIMLIB_EXTRACT_FLAG_STRICT_ACLS;
                        break;
+               case IMAGEX_NO_ATTRIBUTES_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES;
+                       break;
                case IMAGEX_DEST_DIR_OPTION:
                        dest_dir = optarg;
                        break;
@@ -2777,16 +3050,28 @@ imagex_extract(int argc, tchar **argv, int cmd)
                        extract_flags |= WIMLIB_EXTRACT_FLAG_TO_STDOUT;
                        imagex_info_file = stderr;
                        imagex_be_quiet = true;
+                       set_fd_to_binary_mode(STDOUT_FILENO);
                        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_NO_WILDCARDS_OPTION:
-                       listfile_extract_flags &= ~WIMLIB_EXTRACT_FLAG_GLOB_PATHS;
+               case IMAGEX_NO_GLOBS_OPTION:
+                       extract_flags &= ~WIMLIB_EXTRACT_FLAG_GLOB_PATHS;
+                       break;
+               case IMAGEX_NULLGLOB_OPTION:
+                       extract_flags &= ~WIMLIB_EXTRACT_FLAG_STRICT_GLOB;
+                       break;
+               case IMAGEX_PRESERVE_DIR_STRUCTURE_OPTION:
+                       notlist_extract_flags &= ~WIMLIB_EXTRACT_FLAG_NO_PRESERVE_DIR_STRUCTURE;
                        break;
-               case IMAGEX_STRICT_WILDCARDS_OPTION:
-                       listfile_extract_flags |= WIMLIB_EXTRACT_FLAG_STRICT_GLOB;
+               case IMAGEX_WIMBOOT_OPTION:
+                       extract_flags |= WIMLIB_EXTRACT_FLAG_WIMBOOT;
+                       break;
+               case IMAGEX_COMPACT_OPTION:
+                       ret = set_compact_mode(optarg, &extract_flags);
+                       if (ret)
+                               goto out_free_refglobs;
                        break;
                default:
                        goto out_usage;
@@ -2798,27 +3083,23 @@ imagex_extract(int argc, tchar **argv, int cmd)
        if (argc < 2)
                goto out_usage;
 
+       if (!(extract_flags & (WIMLIB_EXTRACT_FLAG_GLOB_PATHS |
+                              WIMLIB_EXTRACT_FLAG_STRICT_GLOB)))
+       {
+               imagex_error(T("Can't combine --no-globs and --nullglob!"));
+               goto out_err;
+       }
+
        wimfile = argv[0];
        image_num_or_name = argv[1];
 
        argc -= 2;
        argv += 2;
 
-       if (argc == 1 && argv[0][0] == T('@')) {
-               pathlist = argv[0] + 1;
-               cmds = NULL;
-               num_cmds = 0;
-       } else {
-               cmds = prepare_extract_commands(argv, argc, extract_flags, dest_dir,
-                                               &num_cmds);
-               if (cmds == NULL)
-                       goto out_err;
-               pathlist = NULL;
-       }
-
-       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+       ret = wimlib_open_wim_with_progress(wimfile, open_flags, &wim,
+                                           imagex_progress_func, NULL);
        if (ret)
-               goto out_free_cmds;
+               goto out_free_refglobs;
 
        image = wimlib_resolve_image(wim, image_num_or_name);
        ret = verify_image_exists_and_is_single(image,
@@ -2833,21 +3114,49 @@ imagex_extract(int argc, tchar **argv, int cmd)
                        goto out_wimlib_free;
        }
 
-       ret = 0;
-       if (ret == 0 && cmds != NULL) {
-               ret = wimlib_extract_files(wim, image, cmds, num_cmds, 0,
-                                          imagex_progress_func);
+       if (argc == 0) {
+               argv = &root_path;
+               argc = 1;
+               extract_flags &= ~WIMLIB_EXTRACT_FLAG_GLOB_PATHS;
        }
-       if (ret == 0 && pathlist != NULL) {
-               ret = wimlib_extract_pathlist(wim, image, dest_dir,
-                                             pathlist,
-                                             extract_flags | listfile_extract_flags,
-                                             imagex_progress_func);
+
+       while (argc != 0 && ret == 0) {
+               int num_paths;
+
+               for (num_paths = 0;
+                    num_paths < argc && argv[num_paths][0] != T('@');
+                    num_paths++)
+                       ;
+
+               if (num_paths) {
+                       ret = wimlib_extract_paths(wim, image, dest_dir,
+                                                  (const tchar **)argv,
+                                                  num_paths,
+                                                  extract_flags | notlist_extract_flags);
+                       argc -= num_paths;
+                       argv += num_paths;
+               } else {
+                       ret = wimlib_extract_pathlist(wim, image, dest_dir,
+                                                     argv[0] + 1,
+                                                     extract_flags);
+                       argc--;
+                       argv++;
+               }
        }
+
        if (ret == 0) {
                if (!imagex_be_quiet)
                        imagex_printf(T("Done extracting files.\n"));
        } else if (ret == WIMLIB_ERR_PATH_DOES_NOT_EXIST) {
+               if ((extract_flags & (WIMLIB_EXTRACT_FLAG_STRICT_GLOB |
+                                     WIMLIB_EXTRACT_FLAG_GLOB_PATHS))
+                       == (WIMLIB_EXTRACT_FLAG_STRICT_GLOB |
+                           WIMLIB_EXTRACT_FLAG_GLOB_PATHS))
+               {
+                       tfprintf(stderr,
+                                T("Note: You can use the '--nullglob' "
+                                  "option to ignore missing files.\n"));
+               }
                tfprintf(stderr, T("Note: You can use `%"TS"' to see what "
                                   "files and directories\n"
                                   "      are in the WIM image.\n"),
@@ -2860,8 +3169,6 @@ imagex_extract(int argc, tchar **argv, int cmd)
        }
 out_wimlib_free:
        wimlib_free(wim);
-out_free_cmds:
-       free_extract_commands(cmds, num_cmds, dest_dir);
 out_free_refglobs:
        string_set_destroy(&refglobs);
        return ret;
@@ -2873,91 +3180,6 @@ out_err:
        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("Version:        %u\n"), info->wim_version);
-       tprintf(T("Image Count:    %d\n"), info->image_count);
-       tprintf(T("Compression:    %"TS"\n"),
-               wimlib_get_compression_type_string(info->compression_type));
-       tprintf(T("Chunk Size:     %"PRIu32" bytes\n"),
-               info->chunk_size);
-       tprintf(T("Part Number:    %d/%d\n"), info->part_number, info->total_parts);
-       tprintf(T("Boot Index:     %d\n"), info->boot_index);
-       tprintf(T("Size:           %"PRIu64" bytes\n"), info->total_bytes);
-       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);
-       if (resource->packed) {
-               tprintf(T("Raw compressed size   = %"PRIu64" bytes\n"),
-                       resource->raw_resource_compressed_size);
-
-               tprintf(T("Raw offset in WIM     = %"PRIu64" bytes\n"),
-                       resource->raw_resource_offset_in_wim);
-
-               tprintf(T("Offset in raw         = %"PRIu64" bytes\n"),
-                       resource->offset);
-       } else {
-               tprintf(T("Compressed size       = %"PRIu64" bytes\n"),
-                       resource->compressed_size);
-
-               tprintf(T("Offset in WIM         = %"PRIu64" bytes\n"),
-                       resource->offset);
-       }
-
-       tprintf(T("Part Number           = %u\n"), resource->part_number);
-       tprintf(T("Reference Count       = %u\n"), resource->reference_count);
-
-       tprintf(T("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  "));
-       if (resource->packed)
-               tprintf(T("WIM_RESHDR_FLAG_PACKED_STREAMS  "));
-       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
@@ -2968,9 +3190,8 @@ imagex_info(int argc, tchar **argv, int cmd)
        bool check        = false;
        bool nocheck      = false;
        bool header       = false;
-       bool lookup_table = false;
+       bool blobs        = false;
        bool xml          = false;
-       bool metadata     = false;
        bool short_header = true;
        const tchar *xml_out_file = NULL;
        const tchar *wimfile;
@@ -2998,8 +3219,8 @@ imagex_info(int argc, tchar **argv, int cmd)
                        header = true;
                        short_header = false;
                        break;
-               case IMAGEX_LOOKUP_TABLE_OPTION:
-                       lookup_table = true;
+               case IMAGEX_BLOBS_OPTION:
+                       blobs = true;
                        short_header = false;
                        break;
                case IMAGEX_XML_OPTION:
@@ -3011,9 +3232,9 @@ imagex_info(int argc, tchar **argv, int cmd)
                        short_header = false;
                        break;
                case IMAGEX_METADATA_OPTION:
-                       metadata = true;
-                       short_header = false;
-                       break;
+                       imagex_error(T("The --metadata option has been removed. "
+                                      "Use 'wimdir --detail' instead."));
+                       goto out_err;
                default:
                        goto out_usage;
                }
@@ -3037,7 +3258,8 @@ imagex_info(int argc, tchar **argv, int cmd)
        if (check)
                open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
 
-       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+       ret = wimlib_open_wim_with_progress(wimfile, open_flags, &wim,
+                                           imagex_progress_func, NULL);
        if (ret)
                goto out;
 
@@ -3093,13 +3315,13 @@ imagex_info(int argc, tchar **argv, int cmd)
                if (header)
                        wimlib_print_header(wim);
 
-               if (lookup_table) {
+               if (blobs) {
                        if (info.total_parts != 1) {
-                               tfprintf(stderr, T("Warning: Only showing the lookup table "
+                               tfprintf(stderr, T("Warning: Only showing the blobs "
                                                   "for part %d of a %d-part WIM.\n"),
                                         info.part_number, info.total_parts);
                        }
-                       print_lookup_table(wim);
+                       print_blobs(wim);
                }
 
                if (xml) {
@@ -3134,11 +3356,6 @@ imagex_info(int argc, tchar **argv, int cmd)
                if (short_header)
                        wimlib_print_available_images(wim, image);
 
-               if (metadata) {
-                       ret = wimlib_print_metadata(wim, image);
-                       if (ret)
-                               goto out_wimlib_free;
-               }
                ret = 0;
        } else {
 
@@ -3212,8 +3429,7 @@ imagex_info(int argc, tchar **argv, int cmd)
                                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);
+                       ret = wimlib_overwrite(wim, write_flags, 1);
                } else {
                        imagex_printf(T("The file \"%"TS"\" was not modified "
                                        "because nothing needed to be done.\n"),
@@ -3262,12 +3478,13 @@ imagex_join(int argc, tchar **argv, int cmd)
                goto out_usage;
        }
        output_path = argv[0];
-       ret = wimlib_join((const tchar * const *)++argv,
-                         --argc,
-                         output_path,
-                         swm_open_flags,
-                         wim_write_flags,
-                         imagex_progress_func);
+       ret = wimlib_join_with_progress((const tchar * const *)++argv,
+                                       --argc,
+                                       output_path,
+                                       swm_open_flags,
+                                       wim_write_flags,
+                                       imagex_progress_func,
+                                       NULL);
 out:
        return ret;
 
@@ -3347,7 +3564,8 @@ imagex_mount_rw_or_ro(int argc, tchar **argv, int cmd)
 
        wimfile = argv[0];
 
-       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+       ret = wimlib_open_wim_with_progress(wimfile, open_flags, &wim,
+                                           imagex_progress_func, NULL);
        if (ret)
                goto out_free_refglobs;
 
@@ -3408,6 +3626,8 @@ imagex_optimize(int argc, tchar **argv, int cmd)
        int write_flags = WIMLIB_WRITE_FLAG_REBUILD;
        int compression_type = WIMLIB_COMPRESSION_TYPE_INVALID;
        uint32_t chunk_size = UINT32_MAX;
+       uint32_t solid_chunk_size = UINT32_MAX;
+       int solid_ctype = WIMLIB_COMPRESSION_TYPE_INVALID;
        int ret;
        WIMStruct *wim;
        const tchar *wimfile;
@@ -3430,22 +3650,35 @@ imagex_optimize(int argc, tchar **argv, int cmd)
                        if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID)
                                goto out_err;
                        break;
-               case IMAGEX_RECOMPRESS_OPTION:
+               case IMAGEX_COMPRESS_SLOW_OPTION:
+                       set_compress_slow();
                        write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
                        break;
-               case IMAGEX_COMPRESS_SLOW_OPTION:
+               case IMAGEX_RECOMPRESS_OPTION:
                        write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
-                       set_compress_slow();
                        break;
                case IMAGEX_CHUNK_SIZE_OPTION:
                        chunk_size = parse_chunk_size(optarg);
                        if (chunk_size == UINT32_MAX)
                                goto out_err;
                        break;
-               case IMAGEX_PACK_STREAMS_OPTION:
-                       write_flags |= WIMLIB_WRITE_FLAG_PACK_STREAMS;
+               case IMAGEX_SOLID_CHUNK_SIZE_OPTION:
+                       solid_chunk_size = parse_chunk_size(optarg);
+                       if (solid_chunk_size == UINT32_MAX)
+                               goto out_err;
+                       break;
+               case IMAGEX_SOLID_COMPRESS_OPTION:
+                       solid_ctype = get_compression_type(optarg);
+                       if (solid_ctype == WIMLIB_COMPRESSION_TYPE_INVALID)
+                               goto out_err;
+                       break;
+               case IMAGEX_SOLID_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_SOLID;
                        write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
                        break;
+               case IMAGEX_NO_SOLID_SORT_OPTION:
+                       write_flags |= WIMLIB_WRITE_FLAG_NO_SOLID_SORT;
+                       break;
                case IMAGEX_THREADS_OPTION:
                        num_threads = parse_num_threads(optarg);
                        if (num_threads == UINT_MAX)
@@ -3469,7 +3702,8 @@ imagex_optimize(int argc, tchar **argv, int cmd)
 
        wimfile = argv[0];
 
-       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+       ret = wimlib_open_wim_with_progress(wimfile, open_flags, &wim,
+                                           imagex_progress_func, NULL);
        if (ret)
                goto out;
 
@@ -3486,6 +3720,16 @@ imagex_optimize(int argc, tchar **argv, int cmd)
                if (ret)
                        goto out_wimlib_free;
        }
+       if (solid_ctype != WIMLIB_COMPRESSION_TYPE_INVALID) {
+               ret = wimlib_set_output_pack_compression_type(wim, solid_ctype);
+               if (ret)
+                       goto out_wimlib_free;
+       }
+       if (solid_chunk_size != UINT32_MAX) {
+               ret = wimlib_set_output_pack_chunk_size(wim, solid_chunk_size);
+               if (ret)
+                       goto out_wimlib_free;
+       }
 
        old_size = file_get_size(wimfile);
        tprintf(T("\"%"TS"\" original size: "), wimfile);
@@ -3494,8 +3738,7 @@ imagex_optimize(int argc, tchar **argv, int cmd)
        else
                tprintf(T("%"PRIu64" KiB\n"), old_size >> 10);
 
-       ret = wimlib_overwrite(wim, write_flags, num_threads,
-                              imagex_progress_func);
+       ret = wimlib_overwrite(wim, write_flags, num_threads);
        if (ret) {
                imagex_error(T("Optimization of \"%"TS"\" failed."), wimfile);
                goto out_wimlib_free;
@@ -3563,11 +3806,12 @@ imagex_split(int argc, tchar **argv, int cmd)
                               "floating-point number of megabytes."));
                goto out_err;
        }
-       ret = wimlib_open_wim(argv[0], open_flags, &wim, imagex_progress_func);
+       ret = wimlib_open_wim_with_progress(argv[0], open_flags, &wim,
+                                           imagex_progress_func, NULL);
        if (ret)
                goto out;
 
-       ret = wimlib_split(wim, argv[1], part_size, write_flags, imagex_progress_func);
+       ret = wimlib_split(wim, argv[1], part_size, write_flags);
        wimlib_free(wim);
 out:
        return ret;
@@ -3600,7 +3844,17 @@ imagex_unmount(int argc, tchar **argv, int cmd)
                        unmount_flags |= WIMLIB_UNMOUNT_FLAG_REBUILD;
                        break;
                case IMAGEX_LAZY_OPTION:
-                       unmount_flags |= WIMLIB_UNMOUNT_FLAG_LAZY;
+               case IMAGEX_FORCE_OPTION:
+                       /* Now, unmount is lazy by default.  However, committing
+                        * the image will fail with
+                        * WIMLIB_ERR_MOUNTED_IMAGE_IS_BUSY if there are open
+                        * file descriptors on the WIM image.  The
+                        * WIMLIB_UNMOUNT_FLAG_FORCE option forces these file
+                        * descriptors to be closed.  */
+                       unmount_flags |= WIMLIB_UNMOUNT_FLAG_FORCE;
+                       break;
+               case IMAGEX_NEW_IMAGE_OPTION:
+                       unmount_flags |= WIMLIB_UNMOUNT_FLAG_NEW_IMAGE;
                        break;
                default:
                        goto out_usage;
@@ -3611,15 +3865,31 @@ imagex_unmount(int argc, tchar **argv, int cmd)
        if (argc != 1)
                goto out_usage;
 
-       ret = wimlib_unmount_image(argv[0], unmount_flags,
-                                  imagex_progress_func);
-       if (ret)
+       if (unmount_flags & WIMLIB_UNMOUNT_FLAG_NEW_IMAGE) {
+               if (!(unmount_flags & WIMLIB_UNMOUNT_FLAG_COMMIT)) {
+                       imagex_error(T("--new-image is meaningless "
+                                      "without --commit also specified!"));
+                       goto out_err;
+               }
+       }
+
+       ret = wimlib_unmount_image_with_progress(argv[0], unmount_flags,
+                                                imagex_progress_func, NULL);
+       if (ret) {
                imagex_error(T("Failed to unmount \"%"TS"\""), argv[0]);
+               if (ret == WIMLIB_ERR_MOUNTED_IMAGE_IS_BUSY) {
+                       imagex_printf(T(
+                               "\tNote: Use --commit --force to force changes "
+                                       "to be committed, regardless\n"
+                               "\t      of open files.\n"));
+               }
+       }
 out:
        return ret;
 
 out_usage:
        usage(CMD_UNMOUNT, stderr);
+out_err:
        ret = -1;
        goto out;
 }
@@ -3639,7 +3909,8 @@ imagex_update(int argc, tchar **argv, int cmd)
        int write_flags = 0;
        int update_flags = WIMLIB_UPDATE_FLAG_SEND_PROGRESS;
        int default_add_flags = WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE |
-                               WIMLIB_ADD_FLAG_VERBOSE;
+                               WIMLIB_ADD_FLAG_VERBOSE |
+                               WIMLIB_ADD_FLAG_WINCONFIG;
        int default_delete_flags = 0;
        unsigned num_threads = 0;
        int c;
@@ -3648,10 +3919,8 @@ imagex_update(int argc, tchar **argv, int cmd)
        struct wimlib_update_command *cmds;
        size_t num_cmds;
        tchar *command_str = NULL;
-
-       const tchar *config_file = NULL;
-       tchar *config_str;
-       struct wimlib_capture_config *config;
+       tchar *config_file = NULL;
+       tchar *wimboot_config = NULL;
 
        for_opt(c, update_options) {
                switch (c) {
@@ -3682,6 +3951,9 @@ imagex_update(int argc, tchar **argv, int cmd)
                                goto out_err;
                        }
                        break;
+               case IMAGEX_WIMBOOT_CONFIG_OPTION:
+                       wimboot_config = optarg;
+                       break;
                /* Default delete options */
                case IMAGEX_FORCE_OPTION:
                        default_delete_flags |= WIMLIB_DELETE_FLAG_FORCE;
@@ -3712,6 +3984,9 @@ imagex_update(int argc, tchar **argv, int cmd)
                case IMAGEX_STRICT_ACLS_OPTION:
                        default_add_flags |= WIMLIB_ADD_FLAG_STRICT_ACLS;
                        break;
+               case IMAGEX_NO_REPLACE_OPTION:
+                       default_add_flags |= WIMLIB_ADD_FLAG_NO_REPLACE;
+                       break;
                default:
                        goto out_usage;
                }
@@ -3723,7 +3998,8 @@ imagex_update(int argc, tchar **argv, int cmd)
                goto out_usage;
        wimfile = argv[0];
 
-       ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+       ret = wimlib_open_wim_with_progress(wimfile, open_flags, &wim,
+                                           imagex_progress_func, NULL);
        if (ret)
                goto out_free_command_str;
 
@@ -3749,32 +4025,17 @@ imagex_update(int argc, tchar **argv, int cmd)
                image = 1;
        }
 
-       /* Parse capture configuration file if specified */
-       if (config_file) {
-               size_t config_len;
-
-               config_str = file_get_text_contents(config_file, &config_len);
-               if (!config_str) {
-                       ret = -1;
-                       goto out_wimlib_free;
-               }
-
-               config = alloca(sizeof(*config));
-               ret = parse_capture_config(&config_str, config_len, config);
-               if (ret)
-                       goto out_free_config;
-       } else {
-               config = NULL;
-               default_add_flags |= WIMLIB_ADD_FLAG_WINCONFIG;
-       }
-
        /* 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 (!cmds) {
+                       ret = -1;
+                       goto out_free_cmd_file_contents;
+               }
+       } else if (!wimboot_config) {
                if (isatty(STDIN_FILENO)) {
                        tputs(T("Reading update commands from standard input..."));
                        recommend_man_page(CMD_UPDATE, stdout);
@@ -3782,16 +4043,20 @@ imagex_update(int argc, tchar **argv, int cmd)
                cmd_file_contents = stdin_get_text_contents(&cmd_file_nchars);
                if (!cmd_file_contents) {
                        ret = -1;
-                       goto out_free_config;
+                       goto out_wimlib_free;
                }
 
                /* 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;
+               if (!cmds) {
+                       ret = -1;
+                       goto out_free_cmd_file_contents;
+               }
+       } else {
+               cmd_file_contents = NULL;
+               cmds = NULL;
+               num_cmds = 0;
        }
 
        /* Set default flags and capture config on the update commands */
@@ -3799,7 +4064,7 @@ imagex_update(int argc, tchar **argv, int cmd)
                switch (cmds[i].op) {
                case WIMLIB_UPDATE_OP_ADD:
                        cmds[i].add.add_flags |= default_add_flags;
-                       cmds[i].add.config = config;
+                       cmds[i].add.config_file = config_file;
                        break;
                case WIMLIB_UPDATE_OP_DELETE:
                        cmds[i].delete_.delete_flags |= default_delete_flags;
@@ -3810,24 +4075,33 @@ imagex_update(int argc, tchar **argv, int cmd)
        }
 
        /* Execute the update commands */
-       ret = wimlib_update_image(wim, image, cmds, num_cmds, update_flags,
-                                 imagex_progress_func);
+       ret = wimlib_update_image(wim, image, cmds, num_cmds, update_flags);
        if (ret)
                goto out_free_cmds;
 
+       if (wimboot_config) {
+               /* --wimboot-config=FILE is short for an
+                * "add FILE /Windows/System32/WimBootCompress.ini" command.
+                */
+               struct wimlib_update_command cmd;
+
+               cmd.op = WIMLIB_UPDATE_OP_ADD;
+               cmd.add.fs_source_path = wimboot_config;
+               cmd.add.wim_target_path = T("/Windows/System32/WimBootCompress.ini");
+               cmd.add.config_file = NULL;
+               cmd.add.add_flags = 0;
+
+               ret = wimlib_update_image(wim, image, &cmd, 1, update_flags);
+               if (ret)
+                       goto out_free_cmds;
+       }
+
        /* Overwrite the updated WIM */
-       ret = wimlib_overwrite(wim, write_flags, num_threads,
-                              imagex_progress_func);
+       ret = wimlib_overwrite(wim, write_flags, num_threads);
 out_free_cmds:
        free(cmds);
 out_free_cmd_file_contents:
        free(cmd_file_contents);
-out_free_config:
-       if (config) {
-               free(config->exclusion_pats.pats);
-               free(config->exclusion_exception_pats.pats);
-               free(config_str);
-       }
 out_wimlib_free:
        wimlib_free(wim);
 out_free_command_str:
@@ -3841,7 +4115,85 @@ out_err:
        goto out_free_command_str;
 }
 
+/* Verify a WIM file.  */
+static int
+imagex_verify(int argc, tchar **argv, int cmd)
+{
+       int ret;
+       const tchar *wimfile;
+       WIMStruct *wim;
+       int open_flags = WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+       int verify_flags = 0;
+       STRING_SET(refglobs);
+       int c;
+
+       for_opt(c, verify_options) {
+               switch (c) {
+               case IMAGEX_REF_OPTION:
+                       ret = string_set_append(&refglobs, optarg);
+                       if (ret)
+                               goto out_free_refglobs;
+                       break;
+               case IMAGEX_NOCHECK_OPTION:
+                       open_flags &= ~WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+                       break;
+               default:
+                       goto out_usage;
+               }
+       }
+
+       argv += optind;
+       argc -= optind;
+
+       if (argc != 1) {
+               if (argc == 0)
+                       imagex_error(T("Must specify a WIM file!"));
+               else
+                       imagex_error(T("At most one WIM file can be specified!"));
+               goto out_usage;
+       }
+
+       wimfile = argv[0];
+
+       ret = wimlib_open_wim_with_progress(wimfile,
+                                           open_flags,
+                                           &wim,
+                                           imagex_progress_func,
+                                           NULL);
+       if (ret)
+               goto out_free_refglobs;
+
+       ret = wim_reference_globs(wim, &refglobs, open_flags);
+       if (ret)
+               goto out_wimlib_free;
 
+       ret = wimlib_verify_wim(wim, verify_flags);
+       if (ret) {
+               tputc(T('\n'), stderr);
+               imagex_error(T("\"%"TS"\" failed verification!"),
+                            wimfile);
+               if (ret == WIMLIB_ERR_RESOURCE_NOT_FOUND &&
+                   refglobs.num_strings == 0)
+               {
+                       imagex_printf(T("Note: if this WIM file is not standalone, "
+                                       "use the --ref option to specify the other parts.\n"));
+               }
+       } else {
+               imagex_printf(T("\n\"%"TS"\" was successfully verified.\n"),
+                             wimfile);
+       }
+
+out_wimlib_free:
+       wimlib_free(wim);
+out_free_refglobs:
+       string_set_destroy(&refglobs);
+       return ret;
+
+out_usage:
+       usage(CMD_VERIFY, stderr);
+       ret = -1;
+       goto out_free_refglobs;
+}
 
 struct imagex_command {
        const tchar *name;
@@ -3868,63 +4220,82 @@ static const struct imagex_command imagex_commands[] = {
        [CMD_UNMOUNT]  = {T("unmount"),  imagex_unmount},
 #endif
        [CMD_UPDATE]   = {T("update"),   imagex_update},
+       [CMD_VERIFY]   = {T("verify"),   imagex_verify},
 };
 
+#ifdef __WIN32__
+
+   /* Can be a directory or source list file.  But source list file is probably
+    * a rare use case, so just say directory.  */
+#  define SOURCE_STR T("DIRECTORY")
+
+   /* Can only be a directory  */
+#  define TARGET_STR T("DIRECTORY")
+
+#else
+   /* Can be a directory, NTFS volume, or source list file. */
+#  define SOURCE_STR T("SOURCE")
+
+   /* Can be a directory or NTFS volume.  */
+#  define TARGET_STR T("TARGET")
+
+#endif
+
 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] [--dereference]\n"
-"                    [--config=FILE] [--threads=NUM_THREADS] [--source-list]\n"
-"                    [--no-acls] [--strict-acls] [--rpfix] [--norpfix]\n"
-"                    [--update-of=[WIMFILE:]IMAGE]\n"
+"    %"TS" " SOURCE_STR " WIMFILE [IMAGE_NAME [IMAGE_DESC]]\n"
+"                    [--boot] [--check] [--nocheck] [--config=FILE]\n"
+"                    [--threads=NUM_THREADS] [--no-acls] [--strict-acls]\n"
+"                    [--rpfix] [--norpfix] [--update-of=[WIMFILE:]IMAGE]\n"
+"                    [--wimboot] [--unix-data] [--dereference]\n"
 ),
 [CMD_APPLY] =
 T(
-"    %"TS" WIMFILE [(IMAGE_NUM | IMAGE_NAME | all)]\n"
-"                    (DIRECTORY | NTFS_VOLUME) [--check] [--ref=\"GLOB\"]\n"
-"                    [--no-acls] [--strict-acls] [--rpfix] [--norpfix]\n"
-"                    [--hardlink] [--symlink] [--include-invalid-names]\n"
+"    %"TS" WIMFILE [IMAGE] " TARGET_STR "\n"
+"                    [--check] [--ref=\"GLOB\"] [--no-acls] [--strict-acls]\n"
+"                    [--no-attributes] [--rpfix] [--norpfix]\n"
+"                    [--include-invalid-names] [--wimboot] [--unix-data]\n"
+"                    [--compact=FORMAT]\n"
 ),
 [CMD_CAPTURE] =
 T(
-"    %"TS" (DIRECTORY | NTFS_VOLUME) WIMFILE\n"
-"                   [IMAGE_NAME [IMAGE_DESCRIPTION]] [--boot] [--check]\n"
-"                    [--nocheck] [--compress=TYPE] [--flags EDITION_ID]\n"
-"                    [--dereference] [--config=FILE] [--threads=NUM_THREADS]\n"
-"                    [--source-list] [--no-acls] [--strict-acls] [--rpfix]\n"
-"                    [--norpfix] [--update-of=[WIMFILE:]IMAGE]\n"
-"                    [--delta-from=WIMFILE]\n"
+"    %"TS" " SOURCE_STR " WIMFILE [IMAGE_NAME [IMAGE_DESC]]\n"
+"                    [--compress=TYPE] [--boot] [--check] [--nocheck]\n"
+"                    [--config=FILE] [--threads=NUM_THREADS]\n"
+"                    [--no-acls] [--strict-acls] [--rpfix] [--norpfix]\n"
+"                    [--update-of=[WIMFILE:]IMAGE] [--delta-from=WIMFILE]\n"
+"                    [--wimboot] [--unix-data] [--dereference] [--solid]\n"
 ),
 [CMD_DELETE] =
 T(
-"    %"TS" WIMFILE (IMAGE_NUM | IMAGE_NAME | all)\n"
-"                    [--check] [--soft]\n"
+"    %"TS" WIMFILE IMAGE [--check] [--soft]\n"
 ),
 [CMD_DIR] =
 T(
-"    %"TS" WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--path=PATH]\n"
+"    %"TS" WIMFILE IMAGE [--path=PATH] [--detailed]\n"
 ),
 [CMD_EXPORT] =
 T(
-"    %"TS" SRC_WIMFILE (SRC_IMAGE_NUM | SRC_IMAGE_NAME | all ) \n"
-"                    DEST_WIMFILE [DEST_IMAGE_NAME [DEST_IMAGE_DESCRIPTION]]\n"
+"    %"TS" SRC_WIMFILE SRC_IMAGE DEST_WIMFILE\n"
+"                        [DEST_IMAGE_NAME [DEST_IMAGE_DESC]]\n"
 "                    [--boot] [--check] [--nocheck] [--compress=TYPE]\n"
 "                    [--ref=\"GLOB\"] [--threads=NUM_THREADS] [--rebuild]\n"
+"                    [--wimboot] [--solid]\n"
 ),
 [CMD_EXTRACT] =
 T(
-"    %"TS" WIMFILE (IMAGE_NUM | IMAGE_NAME) ([PATH...] | @LISTFILE)\n"
-"                    [--check] [--ref=\"GLOB\"] [--no-acls] [--strict-acls]\n"
-"                    [--to-stdout] [--dest-dir=CMD_DIR]\n"
-"                    [--include-invalid-names]\n"
+"    %"TS" WIMFILE IMAGE [(PATH | @LISTFILE)...]\n"
+"                    [--check] [--ref=\"GLOB\"] [--dest-dir=CMD_DIR]\n"
+"                    [--to-stdout] [--no-acls] [--strict-acls]\n"
+"                    [--no-attributes] [--include-invalid-names]\n"
+"                    [--no-globs] [--nullglob] [--preserve-dir-structure]\n"
 ),
 [CMD_INFO] =
 T(
-"    %"TS" WIMFILE [(IMAGE_NUM | IMAGE_NAME) [NEW_NAME\n"
-"                    [NEW_DESC]]] [--boot] [--check] [--nocheck] [--xml]\n"
-"                    [--extract-xml FILE] [--header] [--lookup-table]\n"
+"    %"TS" WIMFILE [IMAGE [NEW_NAME [NEW_DESC]]]\n"
+"                    [--boot] [--check] [--nocheck] [--xml]\n"
+"                    [--extract-xml FILE] [--header] [--blobs]\n"
 ),
 [CMD_JOIN] =
 T(
@@ -3933,22 +4304,23 @@ T(
 #if WIM_MOUNTING_SUPPORTED
 [CMD_MOUNT] =
 T(
-"    %"TS" WIMFILE [(IMAGE_NUM | IMAGE_NAME)] DIRECTORY\n"
+"    %"TS" WIMFILE [IMAGE] DIRECTORY\n"
 "                    [--check] [--streams-interface=INTERFACE]\n"
-"                    [--ref=\"GLOB\"] [--allow-other]\n"
+"                    [--ref=\"GLOB\"] [--allow-other] [--unix-data]\n"
 ),
 [CMD_MOUNTRW] =
 T(
-"    %"TS" WIMFILE [(IMAGE_NUM | IMAGE_NAME)] DIRECTORY\n"
+"    %"TS" WIMFILE [IMAGE] DIRECTORY\n"
 "                    [--check] [--streams-interface=INTERFACE]\n"
-"                    [--staging-dir=CMD_DIR] [--allow-other]\n"
+"                    [--staging-dir=CMD_DIR] [--allow-other] [--unix-data]\n"
 ),
 #endif
 [CMD_OPTIMIZE] =
 T(
-"    %"TS" WIMFILE [--check] [--nocheck] [--recompress]\n"
-"                    [--recompress-slow] [--compress=TYPE]\n"
-"                    [--threads=NUM_THREADS]\n"
+"    %"TS" WIMFILE\n"
+"                    [--recompress] [--compress=TYPE] [--threads=NUM_THREADS]\n"
+"                    [--check] [--nocheck] [--solid]\n"
+"\n"
 ),
 [CMD_SPLIT] =
 T(
@@ -3957,14 +4329,21 @@ T(
 #if WIM_MOUNTING_SUPPORTED
 [CMD_UNMOUNT] =
 T(
-"    %"TS" DIRECTORY [--commit] [--check] [--rebuild] [--lazy]\n"
+"    %"TS" DIRECTORY\n"
+"                    [--commit] [--force] [--new-image] [--check] [--rebuild]\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"
+"    %"TS" WIMFILE [IMAGE]\n"
+"                    [--check] [--rebuild] [--threads=NUM_THREADS]\n"
+"                    [DEFAULT_ADD_OPTIONS] [DEFAULT_DELETE_OPTIONS]\n"
+"                    [--command=STRING] [--wimboot-config=FILE]\n"
+"                    [< CMDFILE]\n"
+),
+[CMD_VERIFY] =
+T(
+"    %"TS" WIMFILE [--ref=\"GLOB\"]\n"
 ),
 };
 
@@ -3975,7 +4354,7 @@ 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));
+               return T("wimlib-imagex");
        } else if (invocation_cmd != CMD_NONE) {
                tsprintf(buf, T("wim%"TS), imagex_commands[cmd].name);
        } else {
@@ -3995,8 +4374,8 @@ version(void)
 {
        static const tchar *s =
        T(
-IMAGEX_PROGNAME " (" PACKAGE ") " PACKAGE_VERSION "\n"
-"Copyright (C) 2012, 2013 Eric Biggers\n"
+"wimlib-imagex (distributed with " PACKAGE " " PACKAGE_VERSION ")\n"
+"Copyright (C) 2012, 2013, 2014, 2015 Eric Biggers\n"
 "License GPLv3+; GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.\n"
 "This is free software: you are free to change and redistribute it.\n"
 "There is NO WARRANTY, to the extent permitted by law.\n"
@@ -4042,10 +4421,10 @@ recommend_man_page(int cmd, FILE *fp)
 {
        const tchar *format_str;
 #ifdef __WIN32__
-       format_str = T("Uncommon options are not listed;\n"
+       format_str = T("Some uncommon options are not listed;\n"
                       "See %"TS".pdf in the doc directory for more details.\n");
 #else
-       format_str = T("Uncommon options are not listed;\n"
+       format_str = T("Some uncommon options are not listed;\n"
                       "Try `man %"TS"' for more details.\n");
 #endif
        tfprintf(fp, format_str, get_cmd_string(cmd, true));
@@ -4073,16 +4452,19 @@ usage_all(FILE *fp)
 "    %"TS" --help\n"
 "    %"TS" --version\n"
 "\n"
-"    The compression TYPE may be \"maximum\", \"fast\", or \"none\".\n"
-"\n"
        );
        tfprintf(fp, extra, invocation_name, invocation_name);
+       tfprintf(fp,
+                T("IMAGE can be the 1-based index or name of an image in the WIM file.\n"
+                  "For some commands IMAGE is optional if the WIM file only contains one image.\n"
+                  "For some commands IMAGE may be \"all\".\n"
+                  "\n"));
        recommend_man_page(CMD_NONE, fp);
 }
 
 /* Entry point for wimlib's ImageX implementation.  On UNIX the command
  * arguments will just be 'char' strings (ideally UTF-8 encoded, but could be
- * something else), while an Windows the command arguments will be UTF-16LE
+ * something else), while on Windows the command arguments will be UTF-16LE
  * encoded 'wchar_t' strings. */
 int
 #ifdef __WIN32__
@@ -4143,7 +4525,7 @@ main(int argc, char **argv)
        /* Allow being invoked as wimCOMMAND (e.g. wimapply).  */
        cmd = CMD_NONE;
        if (!tstrncmp(invocation_name, T("wim"), 3) &&
-           tstrcmp(invocation_name, T(IMAGEX_PROGNAME))) {
+           tstrcmp(invocation_name, T("wimlib-imagex"))) {
                for (int i = 0; i < CMD_MAX; i++) {
                        if (!tstrcmp(invocation_name + 3,
                                     imagex_commands[i].name))
@@ -4188,7 +4570,7 @@ main(int argc, char **argv)
                exit(2);
        }
 
-       /* Enable warning and error messages in wimlib be more user-friendly.
+       /* Enable warning and error messages in wimlib to be more user-friendly.
         * */
        wimlib_set_print_errors(true);