* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "config.h"
-#include "wimlib_tchar.h"
+#ifdef HAVE_CONFIG_H
+# include "config.h" /* Need for PACKAGE_VERSION, etc. */
+#endif
+
#include "wimlib.h"
+#include "wimlib_tchar.h"
#include <ctype.h>
#include <errno.h>
#include <locale.h>
#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
#endif
#ifdef __WIN32__
DELETE,
DIR,
EXPORT,
+ EXTRACT,
INFO,
JOIN,
MOUNT,
OPTIMIZE,
SPLIT,
UNMOUNT,
+ UPDATE,
};
static void usage(int cmd_type);
-static void usage_all();
+static void usage_all(void);
+
+static bool imagex_be_quiet = false;
static const tchar *usage_strings[] = {
" [DESCRIPTION] [--boot] [--check] [--flags EDITION_ID]\n"
" [--verbose] [--dereference] [--config=FILE]\n"
" [--threads=NUM_THREADS] [--rebuild] [--unix-data]\n"
-" [--source-list] [--noacls]\n"
+" [--source-list] [--no-acls] [--strict-acls]\n"
+" [--rpfix] [--norpfix]\n"
),
[APPLY] =
T(
IMAGEX_PROGNAME" apply WIMFILE [IMAGE_NUM | IMAGE_NAME | all]\n"
" (DIRECTORY | NTFS_VOLUME) [--check] [--hardlink]\n"
" [--symlink] [--verbose] [--ref=\"GLOB\"] [--unix-data]\n"
-" [--noacls]\n"
+" [--no-acls] [--strict-acls] [--rpfix] [--norpfix]\n"
),
[CAPTURE] =
T(
" [DESCRIPTION] [--boot] [--check] [--compress=TYPE]\n"
" [--flags EDITION_ID] [--verbose] [--dereference]\n"
" [--config=FILE] [--threads=NUM_THREADS] [--unix-data]\n"
-" [--source-list] [--noacls]\n"
+" [--source-list] [--no-acls] [--strict-acls]\n"
+" [--rpfix] [--norpfix]\n"
),
[DELETE] =
T(
" [--boot] [--check] [--compress=TYPE] [--ref=\"GLOB\"]\n"
" [--threads=NUM_THREADS] [--rebuild]\n"
),
+[EXTRACT] =
+T(
+IMAGEX_PROGNAME" extract WIMFILE (IMAGE_NUM | IMAGE_NAME) [PATH...]\n"
+" [--check] [--ref=\"GLOB\"] [--verbose] [--unix-data]\n"
+" [--no-acls] [--strict-acls] [--to-stdout] [--dest-dir=DIR]\n"
+),
[INFO] =
T(
IMAGEX_PROGNAME" info WIMFILE [IMAGE_NUM | IMAGE_NAME] [NEW_NAME]\n"
[OPTIMIZE] =
T(
IMAGEX_PROGNAME" optimize WIMFILE [--check] [--recompress]\n"
+" [--threads=NUM_THREADS]\n"
),
[SPLIT] =
T(
),
[UNMOUNT] =
T(
-IMAGEX_PROGNAME" unmount DIRECTORY [--commit] [--check] [--rebuild]\n"
+IMAGEX_PROGNAME" unmount DIRECTORY [--commit] [--check] [--rebuild] [--lazy]\n"
+),
+[UPDATE] =
+T(
+IMAGEX_PROGNAME" update WIMFILE [IMAGE_NUM | IMAGE_NAME] [--check] [--rebuild]\n"
+" [--threads=NUM_THREADS] [DEFAULT_ADD_OPTIONS]\n"
+" [DEFAULT_DELETE_OPTIONS] < CMDFILE\n"
),
};
+
+static void
+recommend_man_page(const tchar *cmd_name)
+{
+ const tchar *format_str;
+#ifdef __WIN32__
+ format_str = T("See "IMAGEX_PROGNAME"%"TS"%"TS".pdf in the "
+ "doc directory for more details.\n");
+#else
+ format_str = T("Try `man "IMAGEX_PROGNAME"%"TS"%"TS"' "
+ "for more details.\n");
+#endif
+ tprintf(format_str, *cmd_name ? T("-") : T(""), cmd_name);
+}
+
+enum {
+ IMAGEX_ALLOW_OTHER_OPTION,
+ IMAGEX_BOOT_OPTION,
+ IMAGEX_CHECK_OPTION,
+ IMAGEX_COMMIT_OPTION,
+ IMAGEX_COMPRESS_OPTION,
+ IMAGEX_CONFIG_OPTION,
+ IMAGEX_DEBUG_OPTION,
+ IMAGEX_DEREFERENCE_OPTION,
+ IMAGEX_DEST_DIR_OPTION,
+ IMAGEX_EXTRACT_XML_OPTION,
+ IMAGEX_FLAGS_OPTION,
+ IMAGEX_FORCE_OPTION,
+ IMAGEX_HARDLINK_OPTION,
+ IMAGEX_HEADER_OPTION,
+ IMAGEX_LAZY_OPTION,
+ IMAGEX_LOOKUP_TABLE_OPTION,
+ IMAGEX_METADATA_OPTION,
+ IMAGEX_NORPFIX_OPTION,
+ IMAGEX_NO_ACLS_OPTION,
+ IMAGEX_REBUILD_OPTION,
+ IMAGEX_RECOMPRESS_OPTION,
+ IMAGEX_RECURSIVE_OPTION,
+ IMAGEX_REF_OPTION,
+ IMAGEX_RPFIX_OPTION,
+ IMAGEX_SOFT_OPTION,
+ IMAGEX_SOURCE_LIST_OPTION,
+ IMAGEX_STAGING_DIR_OPTION,
+ IMAGEX_STREAMS_INTERFACE_OPTION,
+ IMAGEX_STRICT_ACLS_OPTION,
+ IMAGEX_SYMLINK_OPTION,
+ IMAGEX_THREADS_OPTION,
+ IMAGEX_TO_STDOUT_OPTION,
+ IMAGEX_UNIX_DATA_OPTION,
+ IMAGEX_VERBOSE_OPTION,
+ IMAGEX_XML_OPTION,
+};
+
static const struct option apply_options[] = {
- {T("check"), no_argument, NULL, 'c'},
- {T("hardlink"), no_argument, NULL, 'h'},
- {T("symlink"), no_argument, NULL, 's'},
- {T("verbose"), no_argument, NULL, 'v'},
- {T("ref"), required_argument, NULL, 'r'},
- {T("unix-data"), no_argument, NULL, 'U'},
- {T("noacls"), no_argument, NULL, 'N'},
+ {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("rpfix"), no_argument, NULL, IMAGEX_RPFIX_OPTION},
+ {T("norpfix"), no_argument, NULL, IMAGEX_NORPFIX_OPTION},
{NULL, 0, NULL, 0},
};
static const struct option capture_or_append_options[] = {
- {T("boot"), no_argument, NULL, 'b'},
- {T("check"), no_argument, NULL, 'c'},
- {T("compress"), required_argument, NULL, 'x'},
- {T("config"), required_argument, NULL, 'C'},
- {T("dereference"), no_argument, NULL, 'L'},
- {T("flags"), required_argument, NULL, 'f'},
- {T("verbose"), no_argument, NULL, 'v'},
- {T("threads"), required_argument, NULL, 't'},
- {T("rebuild"), no_argument, NULL, 'R'},
- {T("unix-data"), no_argument, NULL, 'U'},
- {T("source-list"), no_argument, NULL, 'S'},
- {T("noacls"), no_argument, NULL, 'N'},
+ {T("boot"), no_argument, NULL, IMAGEX_BOOT_OPTION},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
+ {T("compress"), required_argument, NULL, IMAGEX_COMPRESS_OPTION},
+ {T("config"), required_argument, NULL, IMAGEX_CONFIG_OPTION},
+ {T("dereference"), no_argument, NULL, IMAGEX_DEREFERENCE_OPTION},
+ {T("flags"), required_argument, NULL, IMAGEX_FLAGS_OPTION},
+ {T("verbose"), no_argument, NULL, IMAGEX_VERBOSE_OPTION},
+ {T("threads"), required_argument, NULL, IMAGEX_THREADS_OPTION},
+ {T("rebuild"), no_argument, NULL, IMAGEX_REBUILD_OPTION},
+ {T("unix-data"), no_argument, NULL, IMAGEX_UNIX_DATA_OPTION},
+ {T("source-list"), no_argument, NULL, IMAGEX_SOURCE_LIST_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("rpfix"), no_argument, NULL, IMAGEX_RPFIX_OPTION},
+ {T("norpfix"), no_argument, NULL, IMAGEX_NORPFIX_OPTION},
{NULL, 0, NULL, 0},
};
static const struct option delete_options[] = {
- {T("check"), no_argument, NULL, 'c'},
- {T("soft"), no_argument, NULL, 's'},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
+ {T("soft"), no_argument, NULL, IMAGEX_SOFT_OPTION},
{NULL, 0, NULL, 0},
};
static const struct option export_options[] = {
- {T("boot"), no_argument, NULL, 'b'},
- {T("check"), no_argument, NULL, 'c'},
- {T("compress"), required_argument, NULL, 'x'},
- {T("ref"), required_argument, NULL, 'r'},
- {T("threads"), required_argument, NULL, 't'},
- {T("rebuild"), no_argument, NULL, 'R'},
+ {T("boot"), no_argument, NULL, IMAGEX_BOOT_OPTION},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
+ {T("compress"), required_argument, NULL, IMAGEX_COMPRESS_OPTION},
+ {T("ref"), required_argument, NULL, IMAGEX_REF_OPTION},
+ {T("threads"), required_argument, NULL, IMAGEX_THREADS_OPTION},
+ {T("rebuild"), no_argument, NULL, IMAGEX_REBUILD_OPTION},
+ {NULL, 0, NULL, 0},
+};
+
+static const struct option extract_options[] = {
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
+ {T("verbose"), no_argument, NULL, IMAGEX_VERBOSE_OPTION},
+ {T("ref"), required_argument, NULL, IMAGEX_REF_OPTION},
+ {T("unix-data"), no_argument, NULL, IMAGEX_UNIX_DATA_OPTION},
+ {T("noacls"), no_argument, NULL, IMAGEX_NO_ACLS_OPTION},
+ {T("no-acls"), no_argument, NULL, IMAGEX_NO_ACLS_OPTION},
+ {T("strict-acls"), no_argument, NULL, IMAGEX_STRICT_ACLS_OPTION},
+ {T("dest-dir"), required_argument, NULL, IMAGEX_DEST_DIR_OPTION},
+ {T("to-stdout"), no_argument, NULL, IMAGEX_TO_STDOUT_OPTION},
{NULL, 0, NULL, 0},
};
static const struct option info_options[] = {
- {T("boot"), no_argument, NULL, 'b'},
- {T("check"), no_argument, NULL, 'c'},
- {T("extract-xml"), required_argument, NULL, 'X'},
- {T("header"), no_argument, NULL, 'h'},
- {T("lookup-table"), no_argument, NULL, 'l'},
- {T("metadata"), no_argument, NULL, 'm'},
- {T("xml"), no_argument, NULL, 'x'},
+ {T("boot"), no_argument, NULL, IMAGEX_BOOT_OPTION},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_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("metadata"), no_argument, NULL, IMAGEX_METADATA_OPTION},
+ {T("xml"), no_argument, NULL, IMAGEX_XML_OPTION},
{NULL, 0, NULL, 0},
};
static const struct option join_options[] = {
- {T("check"), no_argument, NULL, 'c'},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
{NULL, 0, NULL, 0},
};
static const struct option mount_options[] = {
- {T("check"), no_argument, NULL, 'c'},
- {T("debug"), no_argument, NULL, 'd'},
- {T("streams-interface"), required_argument, NULL, 's'},
- {T("ref"), required_argument, NULL, 'r'},
- {T("staging-dir"), required_argument, NULL, 'D'},
- {T("unix-data"), no_argument, NULL, 'U'},
- {T("allow-other"), no_argument, NULL, 'A'},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
+ {T("debug"), no_argument, NULL, IMAGEX_DEBUG_OPTION},
+ {T("streams-interface"), required_argument, NULL, IMAGEX_STREAMS_INTERFACE_OPTION},
+ {T("ref"), required_argument, NULL, IMAGEX_REF_OPTION},
+ {T("staging-dir"), required_argument, NULL, IMAGEX_STAGING_DIR_OPTION},
+ {T("unix-data"), no_argument, NULL, IMAGEX_UNIX_DATA_OPTION},
+ {T("allow-other"), no_argument, NULL, IMAGEX_ALLOW_OTHER_OPTION},
{NULL, 0, NULL, 0},
};
static const struct option optimize_options[] = {
- {T("check"), no_argument, NULL, 'c'},
- {T("recompress"), no_argument, NULL, 'r'},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
+ {T("recompress"), no_argument, NULL, IMAGEX_RECOMPRESS_OPTION},
+ {T("threads"), required_argument, NULL, IMAGEX_THREADS_OPTION},
{NULL, 0, NULL, 0},
};
static const struct option split_options[] = {
- {T("check"), no_argument, NULL, 'c'},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
{NULL, 0, NULL, 0},
};
static const struct option unmount_options[] = {
- {T("commit"), no_argument, NULL, 'c'},
- {T("check"), no_argument, NULL, 'C'},
- {T("rebuild"), no_argument, NULL, 'R'},
+ {T("commit"), no_argument, NULL, IMAGEX_COMMIT_OPTION},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
+ {T("rebuild"), no_argument, NULL, IMAGEX_REBUILD_OPTION},
+ {T("lazy"), no_argument, NULL, IMAGEX_LAZY_OPTION},
{NULL, 0, NULL, 0},
};
-
+static const struct option update_options[] = {
+ /* Careful: some of the options here set the defaults for update
+ * commands, but the flags given to an actual update command (and not to
+ * `imagex update' itself are also handled in
+ * update_command_add_option(). */
+ {T("threads"), required_argument, NULL, IMAGEX_THREADS_OPTION},
+ {T("check"), no_argument, NULL, IMAGEX_CHECK_OPTION},
+ {T("rebuild"), no_argument, NULL, IMAGEX_REBUILD_OPTION},
+
+ /* Default delete options */
+ {T("force"), no_argument, NULL, IMAGEX_FORCE_OPTION},
+ {T("recursive"), no_argument, NULL, IMAGEX_RECURSIVE_OPTION},
+
+ /* Global add option */
+ {T("config"), required_argument, NULL, IMAGEX_CONFIG_OPTION},
+
+ /* Default add options */
+ {T("verbose"), no_argument, NULL, IMAGEX_VERBOSE_OPTION},
+ {T("dereference"), no_argument, NULL, IMAGEX_DEREFERENCE_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},
+ {NULL, 0, NULL, 0},
+};
/* Print formatted error message to stderr. */
static void
static int
get_compression_type(const tchar *optarg)
{
- if (tstrcasecmp(optarg, T("maximum")) == 0 || tstrcasecmp(optarg, T("lzx")) == 0)
+ if (!tstrcasecmp(optarg, T("maximum")) || !tstrcasecmp(optarg, T("lzx")))
return WIMLIB_COMPRESSION_TYPE_LZX;
- else if (tstrcasecmp(optarg, T("fast")) == 0 || tstrcasecmp(optarg, T("xpress")) == 0)
+ else if (!tstrcasecmp(optarg, T("fast")) || !tstrcasecmp(optarg, T("xpress")))
return WIMLIB_COMPRESSION_TYPE_XPRESS;
- else if (tstrcasecmp(optarg, T("none")) == 0)
+ else if (!tstrcasecmp(optarg, T("none")))
return WIMLIB_COMPRESSION_TYPE_NONE;
else {
imagex_error(T("Invalid compression type \"%"TS"\"! Must be "
return (off_t)-1;
}
-static const tchar *default_capture_config =
-T(
-"[ExclusionList]\n"
-"\\$ntfs.log\n"
-"\\hiberfil.sys\n"
-"\\pagefile.sys\n"
-"\\System Volume Information\n"
-"\\RECYCLER\n"
-"\\Windows\\CSC\n"
-"\n"
-"[CompressionExclusionList]\n"
-"*.mp3\n"
-"*.zip\n"
-"*.cab\n"
-"\\WINDOWS\\inf\\*.pnf\n"
-);
+tchar pat_ntfs_log[] = T("/$ntfs.log");
+tchar pat_hiberfil_sys[] = T("/hiberfil.sys");
+tchar pat_pagefile_sys[] = T("/pagefile.sys");
+tchar pat_system_volume_information[] = T("/System Volume Information");
+tchar pat_recycler[] = T("/RECYCLER");
+tchar pat_windows_csc[] = T("/Windows/CSC");
+
+tchar *default_pats[] = {
+ pat_ntfs_log,
+ pat_hiberfil_sys,
+ pat_pagefile_sys,
+ pat_system_volume_information,
+ pat_recycler,
+ pat_windows_csc,
+};
+
+static struct wimlib_capture_config default_capture_config = {
+ .exclusion_pats = {
+ .num_pats = sizeof(default_pats) / sizeof(*default_pats),
+ .pats = default_pats,
+ },
+};
enum {
- PARSE_FILENAME_SUCCESS = 0,
- PARSE_FILENAME_FAILURE = 1,
- PARSE_FILENAME_NONE = 2,
+ PARSE_STRING_SUCCESS = 0,
+ PARSE_STRING_FAILURE = 1,
+ PARSE_STRING_NONE = 2,
};
/*
- * Parses a filename in the source list file format. (See the man page for
- * 'wimlib-imagex capture' for details on this format and the meaning.)
- * Accepted formats for filenames are an unquoted string (whitespace-delimited),
- * or a double or single-quoted string.
+ * Parses a string token from an array of characters.
+ *
+ * Tokens are either whitespace-delimited, or double or single-quoted.
*
* @line_p: Pointer to the pointer to the line of data. Will be updated
- * to point past the filename iff the return value is
- * PARSE_FILENAME_SUCCESS. If *len_p > 0, (*line_p)[*len_p - 1] must
+ * to point past the string token iff the return value is
+ * PARSE_STRING_SUCCESS. If *len_p > 0, (*line_p)[*len_p - 1] must
* be '\0'.
*
* @len_p: @len_p initially stores the length of the line of data, which may
* be 0, and it will be updated to the number of bytes remaining in
- * the line iff the return value is PARSE_FILENAME_SUCCESS.
+ * the line iff the return value is PARSE_STRING_SUCCESS.
*
- * @fn_ret: Iff the return value is PARSE_FILENAME_SUCCESS, a pointer to the
- * parsed filename will be returned here.
+ * @fn_ret: Iff the return value is PARSE_STRING_SUCCESS, a pointer to the
+ * parsed string token will be returned here.
*
- * Returns: PARSE_FILENAME_SUCCESS if a filename was successfully parsed; or
- * PARSE_FILENAME_FAILURE if the data was invalid due to a missing
- * closing quote; or PARSE_FILENAME_NONE if the line ended before the
- * beginning of a filename was found.
+ * Returns: PARSE_STRING_SUCCESS if a string token was successfully parsed; or
+ * PARSE_STRING_FAILURE if the data was invalid due to a missing
+ * closing quote; or PARSE_STRING_NONE if the line ended before the
+ * beginning of a string token was found.
*/
static int
-parse_filename(tchar **line_p, size_t *len_p, tchar **fn_ret)
+parse_string(tchar **line_p, size_t *len_p, tchar **fn_ret)
{
size_t len = *len_p;
tchar *line = *line_p;
/* Skip leading whitespace */
for (;;) {
if (len == 0)
- return PARSE_FILENAME_NONE;
+ return PARSE_STRING_NONE;
if (!istspace(*line) && *line != T('\0'))
break;
line++;
}
quote_char = *line;
if (quote_char == T('"') || quote_char == T('\'')) {
- /* Quoted filename */
+ /* Quoted string */
line++;
len--;
fn = line;
line = tmemchr(line, quote_char, len);
if (!line) {
imagex_error(T("Missing closing quote: %"TS), fn - 1);
- return PARSE_FILENAME_FAILURE;
+ return PARSE_STRING_FAILURE;
}
} else {
- /* Unquoted filename. Go until whitespace. Line is terminated
+ /* Unquoted string. Go until whitespace. Line is terminated
* by '\0', so no need to check 'len'. */
fn = line;
do {
*len_p = len;
*line_p = line;
*fn_ret = fn;
- return PARSE_FILENAME_SUCCESS;
+ return PARSE_STRING_SUCCESS;
}
/* Parses a line of data (not an empty line or comment) in the source list file
{
/* SOURCE [DEST] */
int ret;
- ret = parse_filename(&line, &len, &source->fs_source_path);
- if (ret != PARSE_FILENAME_SUCCESS)
+ ret = parse_string(&line, &len, &source->fs_source_path);
+ if (ret != PARSE_STRING_SUCCESS)
return false;
- ret = parse_filename(&line, &len, &source->wim_target_path);
- if (ret == PARSE_FILENAME_NONE)
+ ret = parse_string(&line, &len, &source->wim_target_path);
+ if (ret == PARSE_STRING_NONE)
source->wim_target_path = source->fs_source_path;
- return ret != PARSE_FILENAME_FAILURE;
+ return ret != PARSE_STRING_FAILURE;
}
/* Returns %true if the given line of length @len > 0 is a comment or empty line
}
}
+static ssize_t
+text_file_count_lines(tchar **contents_p, size_t *nchars_p)
+{
+ ssize_t nlines = 0;
+ tchar *contents = *contents_p;
+ size_t nchars = *nchars_p;
+ size_t i;
+
+ for (i = 0; i < nchars; i++)
+ if (contents[i] == T('\n'))
+ nlines++;
+
+ /* Handle last line not terminated by a newline */
+ if (nchars != 0 && contents[nchars - 1] != T('\n')) {
+ contents = realloc(contents, (nchars + 1) * sizeof(tchar));
+ if (!contents) {
+ imagex_error(T("Out of memory!"));
+ return -1;
+ }
+ contents[nchars] = T('\n');
+ *contents_p = contents;
+ nchars++;
+ nlines++;
+ }
+ *nchars_p = nchars;
+ return nlines;
+}
+
/* Parses a file in the source list format. (See the man page for
* 'wimlib-imagex capture' for details on this format and the meaning.)
*
parse_source_list(tchar **source_list_contents_p, size_t source_list_nchars,
size_t *nsources_ret)
{
- size_t nlines;
+ ssize_t nlines;
tchar *p;
struct wimlib_capture_source *sources;
size_t i, j;
- tchar *source_list_contents = *source_list_contents_p;
- nlines = 0;
- for (i = 0; i < source_list_nchars; i++)
- if (source_list_contents[i] == T('\n'))
- nlines++;
+ nlines = text_file_count_lines(source_list_contents_p,
+ &source_list_nchars);
+ if (nlines < 0)
+ return NULL;
- /* Handle last line not terminated by a newline */
- if (source_list_nchars != 0 &&
- source_list_contents[source_list_nchars - 1] != T('\n'))
- {
- source_list_contents = realloc(source_list_contents,
- (source_list_nchars + 1) * sizeof(tchar));
- if (!source_list_contents)
- goto oom;
- source_list_contents[source_list_nchars] = T('\n');
- *source_list_contents_p = source_list_contents;
- source_list_nchars++;
- nlines++;
+ /* Always allocate at least 1 slot, just in case the implementation of
+ * calloc() returns NULL if 0 bytes are requested. */
+ sources = calloc(nlines ?: 1, sizeof(*sources));
+ if (!sources) {
+ imagex_error(T("out of memory"));
+ return NULL;
}
-
- sources = calloc(nlines, sizeof(*sources));
- if (!sources)
- goto oom;
- p = source_list_contents;
+ p = *source_list_contents_p;
j = 0;
for (i = 0; i < nlines; i++) {
/* XXX: Could use rawmemchr() here instead, but it may not be
}
*nsources_ret = j;
return sources;
-oom:
- imagex_error(T("out of memory"));
- return NULL;
+}
+
+
+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 tchar *
-translate_text_to_tstr(char **text_p, size_t num_bytes,
- size_t *num_tchars_ret)
+translate_text_to_tstr(char *text, size_t num_bytes, size_t *num_tchars_ret)
{
#ifndef __WIN32__
/* On non-Windows, assume an ASCII-compatible encoding, such as UTF-8.
* */
*num_tchars_ret = num_bytes;
- return *text_p;
+ return text;
#else /* !__WIN32__ */
/* On Windows, translate the text to UTF-16LE */
- const char *text_bytestr = *text_p;
wchar_t *text_wstr;
size_t num_wchars;
if (num_bytes >= 2 &&
- ((text_bytestr[0] == 0xff && text_bytestr[1] == 0xfe) ||
- (text_bytestr[0] <= 0x7f && text_bytestr[1] == 0x00)))
+ ((text[0] == 0xff && text[1] == 0xfe) ||
+ (text[0] <= 0x7f && text[1] == 0x00)))
{
/* File begins with 0xfeff, the BOM for UTF-16LE, or it begins
* with something that looks like an ASCII character encoded as
* a UTF-16LE code unit. Assume the file is encoded as
* UTF-16LE. This is not a 100% reliable check. */
num_wchars = num_bytes / 2;
- text_wstr = (wchar_t*)text_bytestr;
+ text_wstr = (wchar_t*)text;
} else {
/* File does not look like UTF-16LE. Assume it is encoded in
* the current Windows code page. I think these are always
* ASCII-compatible, so any so-called "plain-text" (ASCII) files
* should work as expected. */
- text_wstr = win32_mbs_to_wcs(text_bytestr,
+ text_wstr = win32_mbs_to_wcs(text,
num_bytes,
&num_wchars);
+ free(text);
}
*num_tchars_ret = num_wchars;
return text_wstr;
contents = file_get_contents(filename, &num_bytes);
if (!contents)
return NULL;
- return translate_text_to_tstr(&contents, num_bytes, num_tchars_ret);
+ return translate_text_to_tstr(contents, num_bytes, num_tchars_ret);
}
static tchar *
contents = stdin_get_contents(&num_bytes);
if (!contents)
return NULL;
- return translate_text_to_tstr(&contents, num_bytes, num_tchars_ret);
+ return translate_text_to_tstr(contents, num_bytes, num_tchars_ret);
}
/* Return 0 if a path names a file to which the current user has write access;
const union wimlib_progress_info *info)
{
unsigned percent_done;
+ if (imagex_be_quiet)
+ return 0;
switch (msg) {
case WIMLIB_PROGRESS_MSG_WRITE_STREAMS:
percent_done = TO_PERCENT(info->write_streams.completed_bytes,
tputchar(T('\n'));
break;
case WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN:
- tprintf(T("Applying image %d (%"TS") from \"%"TS"\" "
+ tprintf(T("Applying image %d (\"%"TS"\") from \"%"TS"\" "
"to %"TS" \"%"TS"\"\n"),
info->extract.image,
info->extract.image_name,
T("NTFS volume") : T("directory")),
info->extract.target);
break;
+ case WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN:
+ tprintf(T("Extracting \"%"TS"\" from image %d (\"%"TS"\") "
+ "in \"%"TS"\" to \"%"TS"\"\n"),
+ info->extract.extract_root_wim_source_path,
+ info->extract.image,
+ info->extract.image_name,
+ info->extract.wimfile_name,
+ info->extract.target);
+ break;
/*case WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_BEGIN:*/
- /*printf("Applying directory structure to %s\n",*/
- /*info->extract.target);*/
+ /*tprintf(T("Applying directory structure to %"TS"\n"),*/
+ /*info->extract.target);*/
/*break;*/
case WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS:
percent_done = TO_PERCENT(info->extract.completed_bytes,
info->extract.total_bytes >> 20,
percent_done);
if (info->extract.completed_bytes >= info->extract.total_bytes)
- putchar('\n');
+ tputchar(T('\n'));
break;
case WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY:
tprintf(T("%"TS"\n"), info->extract.cur_path);
break;
case WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS:
- tprintf(T("Setting timestamps on all extracted files...\n"));
+ if (info->extract.extract_root_wim_source_path[0] == T('\0'))
+ tprintf(T("Setting timestamps on all extracted files...\n"));
break;
case WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END:
if (info->extract.extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
case WIMLIB_PROGRESS_MSG_JOIN_STREAMS:
percent_done = TO_PERCENT(info->join.completed_bytes,
info->join.total_bytes);
- printf("Writing resources from part %u of %u: "
- "%"PRIu64 " MiB of %"PRIu64" MiB (%u%%) written\n",
- (info->join.completed_parts == info->join.total_parts) ?
- info->join.completed_parts : info->join.completed_parts + 1,
- info->join.total_parts,
- info->join.completed_bytes >> 20,
- info->join.total_bytes >> 20,
- percent_done);
+ tprintf(T("Writing resources from part %u of %u: "
+ "%"PRIu64 " MiB of %"PRIu64" MiB (%u%%) written\n"),
+ (info->join.completed_parts == info->join.total_parts) ?
+ info->join.completed_parts : info->join.completed_parts + 1,
+ info->join.total_parts,
+ info->join.completed_bytes >> 20,
+ info->join.total_bytes >> 20,
+ percent_done);
break;
case WIMLIB_PROGRESS_MSG_SPLIT_BEGIN_PART:
percent_done = TO_PERCENT(info->split.completed_bytes,
parse_num_threads(const tchar *optarg)
{
tchar *tmp;
- unsigned nthreads = tstrtoul(optarg, &tmp, 10);
- if (nthreads == UINT_MAX || *tmp || tmp == optarg) {
+ unsigned long ul_nthreads = tstrtoul(optarg, &tmp, 10);
+ if (ul_nthreads >= UINT_MAX || *tmp || tmp == optarg) {
imagex_error(T("Number of threads must be a non-negative integer!"));
return UINT_MAX;
} else {
- return nthreads;
+ return ul_nthreads;
+ }
+}
+
+/*
+ * Parse an option passed to an update command.
+ *
+ * @op: One of WIMLIB_UPDATE_OP_* that indicates the command being
+ * parsed.
+ *
+ * @option: Text string for the option (beginning with --)
+ *
+ * @cmd: `struct wimlib_update_command' that is being constructed for
+ * this command.
+ *
+ * Returns true if the option was recognized; false if not.
+ */
+static bool
+update_command_add_option(int op, const tchar *option,
+ struct wimlib_update_command *cmd)
+{
+ bool recognized = true;
+ switch (op) {
+ case WIMLIB_UPDATE_OP_ADD:
+ if (!tstrcmp(option, T("--verbose")))
+ cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
+ else if (!tstrcmp(option, T("--unix-data")))
+ cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA;
+ else if (!tstrcmp(option, T("--no-acls")) || !tstrcmp(option, T("--noacls")))
+ cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_NO_ACLS;
+ else if (!tstrcmp(option, T("--strict-acls")))
+ cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_STRICT_ACLS;
+ else if (!tstrcmp(option, T("--dereference")))
+ cmd->add.add_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
+ else
+ recognized = false;
+ break;
+ case WIMLIB_UPDATE_OP_DELETE:
+ if (!tstrcmp(option, T("--force")))
+ cmd->delete.delete_flags |= WIMLIB_DELETE_FLAG_FORCE;
+ else if (!tstrcmp(option, T("--recursive")))
+ cmd->delete.delete_flags |= WIMLIB_DELETE_FLAG_RECURSIVE;
+ else
+ recognized = false;
+ break;
+ default:
+ recognized = false;
+ break;
+ }
+ return recognized;
+}
+
+/* How many nonoption arguments each `imagex update' command expects */
+static const unsigned update_command_num_nonoptions[] = {
+ [WIMLIB_UPDATE_OP_ADD] = 2,
+ [WIMLIB_UPDATE_OP_DELETE] = 1,
+ [WIMLIB_UPDATE_OP_RENAME] = 2,
+};
+
+static void
+update_command_add_nonoption(int op, const tchar *nonoption,
+ struct wimlib_update_command *cmd,
+ unsigned num_nonoptions)
+{
+ switch (op) {
+ case WIMLIB_UPDATE_OP_ADD:
+ if (num_nonoptions == 0)
+ cmd->add.fs_source_path = (tchar*)nonoption;
+ else
+ cmd->add.wim_target_path = (tchar*)nonoption;
+ break;
+ case WIMLIB_UPDATE_OP_DELETE:
+ cmd->delete.wim_path = (tchar*)nonoption;
+ break;
+ case WIMLIB_UPDATE_OP_RENAME:
+ if (num_nonoptions == 0)
+ cmd->rename.wim_source_path = (tchar*)nonoption;
+ else
+ cmd->rename.wim_target_path = (tchar*)nonoption;
+ break;
+ }
+}
+
+/*
+ * Parse a command passed on stdin to `imagex update'.
+ *
+ * @line: Text of the command.
+ * @len: Length of the line, including a null terminator
+ * at line[len - 1].
+ *
+ * @command: A `struct wimlib_update_command' to fill in from the parsed
+ * line.
+ *
+ * @line_number: Line number of the command, for diagnostics.
+ *
+ * Returns true on success; returns false on parse error.
+ */
+static bool
+parse_update_command(tchar *line, size_t len,
+ struct wimlib_update_command *command,
+ size_t line_number)
+{
+ int ret;
+ tchar *command_name;
+ int op;
+ size_t num_nonoptions;
+
+ /* Get the command name ("add", "delete", "rename") */
+ ret = parse_string(&line, &len, &command_name);
+ if (ret != PARSE_STRING_SUCCESS)
+ return false;
+
+ if (!tstrcasecmp(command_name, T("add"))) {
+ op = WIMLIB_UPDATE_OP_ADD;
+ } else if (!tstrcasecmp(command_name, T("delete"))) {
+ op = WIMLIB_UPDATE_OP_DELETE;
+ } else if (!tstrcasecmp(command_name, T("rename"))) {
+ op = WIMLIB_UPDATE_OP_RENAME;
+ } else {
+ imagex_error(T("Unknown update command \"%"TS"\" on line %zu"),
+ command_name, line_number);
+ return false;
+ }
+ command->op = op;
+
+ /* Parse additional options and non-options as needed */
+ num_nonoptions = 0;
+ for (;;) {
+ tchar *next_string;
+
+ ret = parse_string(&line, &len, &next_string);
+ if (ret == PARSE_STRING_NONE) /* End of line */
+ break;
+ else if (ret != PARSE_STRING_SUCCESS) /* Parse failure */
+ return false;
+ if (next_string[0] == T('-') && next_string[1] == T('-')) {
+ /* Option */
+ if (!update_command_add_option(op, next_string, command))
+ {
+ imagex_error(T("Unrecognized option \"%"TS"\" to "
+ "update command \"%"TS"\" on line %zu"),
+ next_string, command_name, line_number);
+
+ return false;
+ }
+ } else {
+ /* Nonoption */
+ if (num_nonoptions == update_command_num_nonoptions[op])
+ {
+ imagex_error(T("Unexpected argument \"%"TS"\" in "
+ "update command on line %zu\n"
+ " (The \"%"TS"\" command only "
+ "takes %u nonoption arguments!)\n"),
+ next_string, line_number,
+ command_name, num_nonoptions);
+ return false;
+ }
+ update_command_add_nonoption(op, next_string,
+ command, num_nonoptions);
+ num_nonoptions++;
+ }
+ }
+
+ if (num_nonoptions != update_command_num_nonoptions[op]) {
+ imagex_error(T("Not enough arguments to update command "
+ "\"%"TS"\" on line %zu"), command_name, line_number);
+ return false;
}
+ return true;
}
+static struct wimlib_update_command *
+parse_update_command_file(tchar **cmd_file_contents_p, size_t cmd_file_nchars,
+ size_t *num_cmds_ret)
+{
+ ssize_t nlines;
+ tchar *p;
+ struct wimlib_update_command *cmds;
+ size_t i, j;
+
+ nlines = text_file_count_lines(cmd_file_contents_p,
+ &cmd_file_nchars);
+ if (nlines < 0)
+ return NULL;
+
+ /* Always allocate at least 1 slot, just in case the implementation of
+ * calloc() returns NULL if 0 bytes are requested. */
+ cmds = calloc(nlines ?: 1, sizeof(struct wimlib_update_command));
+ if (!cmds) {
+ imagex_error(T("out of memory"));
+ return NULL;
+ }
+ p = *cmd_file_contents_p;
+ j = 0;
+ for (i = 0; i < nlines; i++) {
+ /* XXX: Could use rawmemchr() here instead, but it may not be
+ * available on all platforms. */
+ tchar *endp = tmemchr(p, T('\n'), cmd_file_nchars);
+ size_t len = endp - p + 1;
+ *endp = T('\0');
+ if (!is_comment_line(p, len)) {
+ if (!parse_update_command(p, len, &cmds[j++], i + 1)) {
+ free(cmds);
+ return NULL;
+ }
+ }
+ p = endp + 1;
+ }
+ *num_cmds_ret = j;
+ 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. */
for_opt(c, apply_options) {
switch (c) {
- case 'c':
+ case IMAGEX_CHECK_OPTION:
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
break;
- case 'h':
+ case IMAGEX_HARDLINK_OPTION:
extract_flags |= WIMLIB_EXTRACT_FLAG_HARDLINK;
break;
- case 's':
+ case IMAGEX_SYMLINK_OPTION:
extract_flags |= WIMLIB_EXTRACT_FLAG_SYMLINK;
break;
- case 'v':
+ case IMAGEX_VERBOSE_OPTION:
extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
break;
- case 'r':
+ case IMAGEX_REF_OPTION:
swm_glob = optarg;
break;
- case 'U':
+ case IMAGEX_UNIX_DATA_OPTION:
extract_flags |= WIMLIB_EXTRACT_FLAG_UNIX_DATA;
break;
- case 'N':
- extract_flags |= WIMLIB_EXTRACT_FLAG_NOACLS;
+ case IMAGEX_NO_ACLS_OPTION:
+ extract_flags |= WIMLIB_EXTRACT_FLAG_NO_ACLS;
+ break;
+ case IMAGEX_STRICT_ACLS_OPTION:
+ extract_flags |= WIMLIB_EXTRACT_FLAG_STRICT_ACLS;
+ break;
+ case IMAGEX_NORPFIX_OPTION:
+ extract_flags |= WIMLIB_EXTRACT_FLAG_NORPFIX;
+ break;
+ case IMAGEX_RPFIX_OPTION:
+ extract_flags |= WIMLIB_EXTRACT_FLAG_RPFIX;
break;
default:
usage(APPLY);
num_images = wimlib_get_num_images(w);
if (argc == 2 && num_images != 1) {
imagex_error(T("\"%"TS"\" contains %d images; Please select one "
- "(or all)"), wimfile, num_images);
+ "(or all)."), wimfile, num_images);
usage(APPLY);
ret = -1;
goto out;
{
int c;
int open_flags = 0;
- int add_image_flags = 0;
+ int add_image_flags = WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE;
int write_flags = 0;
int compression_type = WIMLIB_COMPRESSION_TYPE_XPRESS;
const tchar *wimfile;
const tchar *name;
const tchar *desc;
const tchar *flags_element = NULL;
- WIMStruct *w = NULL;
+ WIMStruct *w;
int ret;
int cur_image;
int cmd = tstrcmp(argv[0], T("append")) ? CAPTURE : APPEND;
tchar *source_copy;
const tchar *config_file = NULL;
- tchar *config_str = NULL;
- size_t config_len;
+ tchar *config_str;
+ struct wimlib_capture_config *config = NULL;
bool source_list = false;
size_t source_list_nchars;
- tchar *source_list_contents = NULL;
- bool capture_sources_malloced = false;
+ tchar *source_list_contents;
+ bool capture_sources_malloced;
struct wimlib_capture_source *capture_sources;
size_t num_sources;
for_opt(c, capture_or_append_options) {
switch (c) {
- case 'b':
+ case IMAGEX_BOOT_OPTION:
add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_BOOT;
break;
- case 'c':
+ case IMAGEX_CHECK_OPTION:
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
- case 'C':
+ case IMAGEX_CONFIG_OPTION:
config_file = optarg;
break;
- case 'x':
+ case IMAGEX_COMPRESS_OPTION:
compression_type = get_compression_type(optarg);
if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID)
return -1;
break;
- case 'f':
+ case IMAGEX_FLAGS_OPTION:
flags_element = optarg;
break;
- case 'L':
+ case IMAGEX_DEREFERENCE_OPTION:
add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
break;
- case 'v':
+ case IMAGEX_VERBOSE_OPTION:
add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
break;
- case 't':
+ case IMAGEX_THREADS_OPTION:
num_threads = parse_num_threads(optarg);
if (num_threads == UINT_MAX)
return -1;
break;
- case 'R':
+ case IMAGEX_REBUILD_OPTION:
write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
break;
- case 'U':
+ case IMAGEX_UNIX_DATA_OPTION:
add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA;
break;
- case 'S':
+ case IMAGEX_SOURCE_LIST_OPTION:
source_list = true;
break;
- case 'N':
+ case IMAGEX_NO_ACLS_OPTION:
add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_NO_ACLS;
break;
+ case IMAGEX_STRICT_ACLS_OPTION:
+ add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_STRICT_ACLS;
+ break;
+ case IMAGEX_RPFIX_OPTION:
+ add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_RPFIX;
+ break;
+ case IMAGEX_NORPFIX_OPTION:
+ add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_NORPFIX;
+ break;
default:
usage(cmd);
return -1;
&num_sources);
if (!capture_sources) {
ret = -1;
- goto out;
+ goto out_free_source_list_contents;
}
capture_sources_malloced = true;
} else {
capture_sources[0].wim_target_path = NULL;
capture_sources[0].reserved = 0;
num_sources = 1;
+ capture_sources_malloced = false;
+ source_list_contents = NULL;
}
if (config_file) {
+ size_t config_len;
+
config_str = file_get_text_contents(config_file, &config_len);
if (!config_str) {
ret = -1;
- goto out;
+ goto out_free_capture_sources;
}
+
+ config = alloca(sizeof(*config));
+ ret = parse_capture_config(&config_str, config_len, config);
+ if (ret)
+ goto out_free_config;
+ } else {
+ config = &default_capture_config;
}
if (cmd == APPEND)
imagex_progress_func);
else
ret = wimlib_create_new_wim(compression_type, &w);
- if (ret != 0)
- goto out;
+ if (ret)
+ goto out_free_config;
if (!source_list) {
struct stat stbuf;
imagex_error_with_errno(T("Failed to stat "
"\"%"TS"\""), source);
ret = -1;
- goto out;
+ goto out_wimlib_free;
}
}
}
win32_acquire_capture_privileges();
#endif
- ret = wimlib_add_image_multisource(w, capture_sources,
- num_sources, name,
- (config_str ? config_str :
- default_capture_config),
- (config_str ? config_len :
- tstrlen(default_capture_config)),
+ ret = wimlib_add_image_multisource(w,
+ capture_sources,
+ num_sources,
+ name,
+ config,
add_image_flags,
imagex_progress_func);
if (ret != 0)
#ifdef __WIN32__
win32_release_capture_privileges();
#endif
-out:
+out_wimlib_free:
wimlib_free(w);
- free(config_str);
- free(source_list_contents);
+out_free_config:
+ if (config != NULL && config != &default_capture_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);
+out_free_source_list_contents:
+ free(source_list_contents);
return ret;
}
for_opt(c, delete_options) {
switch (c) {
- case 'c':
+ case IMAGEX_CHECK_OPTION:
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
- case 's':
+ case IMAGEX_SOFT_OPTION:
write_flags |= WIMLIB_WRITE_FLAG_SOFT_DELETE;
break;
default:
* choose that one; otherwise, print an error. */
num_images = wimlib_get_num_images(w);
if (num_images != 1) {
- imagex_error(T("The file \"%"TS"\" contains %d images; Please "
+ imagex_error(T("\"%"TS"\" contains %d images; Please "
"select one."), wimfile, num_images);
usage(DIR);
ret = -1;
for_opt(c, export_options) {
switch (c) {
- case 'b':
+ case IMAGEX_BOOT_OPTION:
export_flags |= WIMLIB_EXPORT_FLAG_BOOT;
break;
- case 'c':
+ case IMAGEX_CHECK_OPTION:
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
- case 'x':
+ case IMAGEX_COMPRESS_OPTION:
compression_type = get_compression_type(optarg);
if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID)
return -1;
compression_type_specified = true;
break;
- case 'r':
+ case IMAGEX_REF_OPTION:
swm_glob = optarg;
break;
- case 't':
+ case IMAGEX_THREADS_OPTION:
num_threads = parse_num_threads(optarg);
if (num_threads == UINT_MAX)
return -1;
break;
- case 'R':
+ case IMAGEX_REBUILD_OPTION:
write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
break;
default:
return ret;
}
+static bool
+is_root_wim_path(const tchar *path)
+{
+ const tchar *p;
+ for (p = path; *p; p++)
+ if (*p != T('\\') && *p != T('/'))
+ return false;
+ return true;
+}
+
+static void
+free_extract_commands(struct wimlib_extract_command *cmds, size_t num_cmds,
+ 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"/%"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 c;
+ int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
+ int image;
+ WIMStruct *wim;
+ int ret;
+ const tchar *wimfile;
+ const tchar *image_num_or_name;
+ tchar *dest_dir = T(".");
+ int extract_flags = WIMLIB_EXTRACT_FLAG_SEQUENTIAL | WIMLIB_EXTRACT_FLAG_NORPFIX;
+
+ const tchar *swm_glob = NULL;
+ WIMStruct **additional_swms = NULL;
+ unsigned num_additional_swms = 0;
+
+ struct wimlib_extract_command *cmds;
+ size_t num_cmds;
+
+ for_opt(c, extract_options) {
+ switch (c) {
+ case IMAGEX_CHECK_OPTION:
+ open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+ break;
+ case IMAGEX_VERBOSE_OPTION:
+ extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
+ break;
+ case IMAGEX_REF_OPTION:
+ swm_glob = optarg;
+ break;
+ case IMAGEX_UNIX_DATA_OPTION:
+ extract_flags |= WIMLIB_EXTRACT_FLAG_UNIX_DATA;
+ break;
+ case IMAGEX_NO_ACLS_OPTION:
+ extract_flags |= WIMLIB_EXTRACT_FLAG_NO_ACLS;
+ break;
+ case IMAGEX_STRICT_ACLS_OPTION:
+ extract_flags |= WIMLIB_EXTRACT_FLAG_STRICT_ACLS;
+ break;
+ case IMAGEX_DEST_DIR_OPTION:
+ dest_dir = optarg;
+ break;
+ case IMAGEX_TO_STDOUT_OPTION:
+ extract_flags |= WIMLIB_EXTRACT_FLAG_TO_STDOUT;
+ imagex_be_quiet = true;
+ break;
+ default:
+ goto out_usage;
+ }
+ }
+ argc -= optind;
+ argv += optind;
+
+ if (argc < 2)
+ goto out_usage;
+
+ wimfile = argv[0];
+ image_num_or_name = argv[1];
+
+ argc -= 2;
+ argv += 2;
+
+ cmds = prepare_extract_commands(argv, argc, extract_flags, dest_dir,
+ &num_cmds);
+ if (!cmds) {
+ ret = -1;
+ goto out;
+ }
+
+ ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+ if (ret)
+ goto out_free_cmds;
+
+ image = wimlib_resolve_image(wim, image_num_or_name);
+ ret = verify_image_exists_and_is_single(image,
+ image_num_or_name,
+ wimfile);
+ if (ret)
+ goto out_wimlib_free;
+
+ if (swm_glob) {
+ ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
+ &additional_swms,
+ &num_additional_swms);
+ if (ret)
+ goto out_wimlib_free;
+ }
+
+#ifdef __WIN32__
+ win32_acquire_restore_privileges();
+#endif
+
+ ret = wimlib_extract_files(wim, image, cmds, num_cmds, 0,
+ additional_swms, num_additional_swms,
+ imagex_progress_func);
+ if (ret == 0) {
+ if (!imagex_be_quiet)
+ tprintf(T("Done extracting files.\n"));
+ } else if (ret == WIMLIB_ERR_PATH_DOES_NOT_EXIST) {
+ tfprintf(stderr, T("Note: You can use `"IMAGEX_PROGNAME" dir' to see what "
+ "files and directories\n"
+ " are in the WIM image.\n"));
+ }
+#ifdef __WIN32__
+ win32_release_restore_privileges();
+#endif
+ if (additional_swms) {
+ for (unsigned i = 0; i < num_additional_swms; i++)
+ wimlib_free(additional_swms[i]);
+ free(additional_swms);
+ }
+out_wimlib_free:
+ wimlib_free(wim);
+out_free_cmds:
+ free_extract_commands(cmds, num_cmds, dest_dir);
+out:
+ return ret;
+out_usage:
+ usage(EXTRACT);
+ ret = -1;
+ goto out;
+}
+
/* 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
for_opt(c, info_options) {
switch (c) {
- case 'b':
+ case IMAGEX_BOOT_OPTION:
boot = true;
break;
- case 'c':
+ case IMAGEX_CHECK_OPTION:
check = true;
break;
- case 'h':
+ case IMAGEX_HEADER_OPTION:
header = true;
short_header = false;
break;
- case 'l':
+ case IMAGEX_LOOKUP_TABLE_OPTION:
lookup_table = true;
short_header = false;
break;
- case 'x':
+ case IMAGEX_XML_OPTION:
xml = true;
short_header = false;
break;
- case 'X':
+ case IMAGEX_EXTRACT_XML_OPTION:
xml_out_file = optarg;
short_header = false;
break;
- case 'm':
+ case IMAGEX_METADATA_OPTION:
metadata = true;
short_header = false;
break;
ret = file_writable(wimfile);
if (ret != 0)
- return ret;
+ goto out;
if (check)
write_flags = WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
for_opt(c, join_options) {
switch (c) {
- case 'c':
+ case IMAGEX_CHECK_OPTION:
swm_open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
wim_write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
unsigned num_additional_swms = 0;
const tchar *staging_dir = NULL;
- if (tstrcmp(argv[0], T("mountrw")) == 0)
+ if (!tstrcmp(argv[0], T("mountrw")))
mount_flags |= WIMLIB_MOUNT_FLAG_READWRITE;
for_opt(c, mount_options) {
switch (c) {
- case 'A':
+ case IMAGEX_ALLOW_OTHER_OPTION:
mount_flags |= WIMLIB_MOUNT_FLAG_ALLOW_OTHER;
break;
- case 'c':
+ case IMAGEX_CHECK_OPTION:
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
break;
- case 'd':
+ case IMAGEX_DEBUG_OPTION:
mount_flags |= WIMLIB_MOUNT_FLAG_DEBUG;
break;
- case 's':
- if (tstrcasecmp(optarg, T("none")) == 0)
+ case IMAGEX_STREAMS_INTERFACE_OPTION:
+ if (!tstrcasecmp(optarg, T("none")))
mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_NONE;
- else if (tstrcasecmp(optarg, T("xattr")) == 0)
+ else if (!tstrcasecmp(optarg, T("xattr")))
mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR;
- else if (tstrcasecmp(optarg, T("windows")) == 0)
+ else if (!tstrcasecmp(optarg, T("windows")))
mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS;
else {
imagex_error(T("Unknown stream interface \"%"TS"\""),
goto mount_usage;
}
break;
- case 'r':
+ case IMAGEX_REF_OPTION:
swm_glob = optarg;
break;
- case 'D':
+ case IMAGEX_STAGING_DIR_OPTION:
staging_dir = optarg;
break;
- case 'U':
+ case IMAGEX_UNIX_DATA_OPTION:
mount_flags |= WIMLIB_MOUNT_FLAG_UNIX_DATA;
break;
default:
image = 1;
num_images = wimlib_get_num_images(w);
if (num_images != 1) {
- imagex_error(T("The file \"%"TS"\" contains %d images; Please "
+ imagex_error(T("\"%"TS"\" contains %d images; Please "
"select one."), wimfile, num_images);
usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
? MOUNTRW : MOUNT);
const tchar *wimfile;
off_t old_size;
off_t new_size;
+ unsigned num_threads = 0;
for_opt(c, optimize_options) {
switch (c) {
- case 'c':
+ case IMAGEX_CHECK_OPTION:
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
- case 'r':
+ case IMAGEX_RECOMPRESS_OPTION:
write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
break;
+ case IMAGEX_THREADS_OPTION:
+ num_threads = parse_num_threads(optarg);
+ if (num_threads == UINT_MAX)
+ return -1;
+ break;
default:
usage(OPTIMIZE);
return -1;
wimfile = argv[0];
+ ret = file_writable(wimfile);
+ if (ret)
+ return ret;
+
ret = wimlib_open_wim(wimfile, open_flags, &w,
imagex_progress_func);
- if (ret != 0)
+ if (ret)
return ret;
old_size = file_get_size(argv[0]);
else
tprintf(T("%"PRIu64" KiB\n"), old_size >> 10);
- ret = wimlib_overwrite(w, write_flags, 0, imagex_progress_func);
+ ret = wimlib_overwrite(w, write_flags, num_threads,
+ imagex_progress_func);
if (ret == 0) {
new_size = file_get_size(argv[0]);
for_opt(c, split_options) {
switch (c) {
- case 'c':
+ case IMAGEX_CHECK_OPTION:
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
for_opt(c, unmount_options) {
switch (c) {
- case 'c':
+ case IMAGEX_COMMIT_OPTION:
unmount_flags |= WIMLIB_UNMOUNT_FLAG_COMMIT;
break;
- case 'C':
+ case IMAGEX_CHECK_OPTION:
unmount_flags |= WIMLIB_UNMOUNT_FLAG_CHECK_INTEGRITY;
break;
- case 'R':
+ case IMAGEX_REBUILD_OPTION:
unmount_flags |= WIMLIB_UNMOUNT_FLAG_REBUILD;
break;
+ case IMAGEX_LAZY_OPTION:
+ unmount_flags |= WIMLIB_UNMOUNT_FLAG_LAZY;
+ break;
default:
usage(UNMOUNT);
return -1;
return ret;
}
+/*
+ * Add, delete, or rename files in a WIM image.
+ */
+static int
+imagex_update(int argc, tchar **argv)
+{
+ const tchar *wimfile;
+ const tchar *image_num_or_name;
+ int image;
+ WIMStruct *wim;
+ int ret;
+ int open_flags = 0;
+ int write_flags = 0;
+ int update_flags = 0;
+ int default_add_flags = WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE;
+ int default_delete_flags = 0;
+ unsigned num_threads = 0;
+ int c;
+ tchar *cmd_file_contents;
+ size_t cmd_file_nchars;
+ struct wimlib_update_command *cmds;
+ size_t num_cmds;
+ int num_images;
+
+ const tchar *config_file = NULL;
+ tchar *config_str;
+ struct wimlib_capture_config *config = NULL;
+
+ for_opt(c, update_options) {
+ switch (c) {
+ /* Generic or write options */
+ case IMAGEX_THREADS_OPTION:
+ num_threads = parse_num_threads(optarg);
+ if (num_threads == UINT_MAX) {
+ ret = -1;
+ goto out;
+ }
+ break;
+ case IMAGEX_CHECK_OPTION:
+ open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+ write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
+ break;
+ case IMAGEX_REBUILD_OPTION:
+ write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
+ break;
+
+ /* Default delete options */
+ case IMAGEX_FORCE_OPTION:
+ default_delete_flags |= WIMLIB_DELETE_FLAG_FORCE;
+ break;
+ case IMAGEX_RECURSIVE_OPTION:
+ default_delete_flags |= WIMLIB_DELETE_FLAG_RECURSIVE;
+ break;
+
+ /* Global add option */
+ case IMAGEX_CONFIG_OPTION:
+ config_file = optarg;
+ break;
+
+ /* Default add options */
+ case IMAGEX_VERBOSE_OPTION:
+ default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
+ break;
+ case IMAGEX_DEREFERENCE_OPTION:
+ default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
+ break;
+ case IMAGEX_UNIX_DATA_OPTION:
+ default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA;
+ break;
+ case IMAGEX_NO_ACLS_OPTION:
+ default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_NO_ACLS;
+ break;
+ case IMAGEX_STRICT_ACLS_OPTION:
+ default_add_flags |= WIMLIB_ADD_IMAGE_FLAG_STRICT_ACLS;
+ break;
+ default:
+ goto out_usage;
+ }
+ }
+ argv += optind;
+ argc -= optind;
+
+ if (argc < 1 || argc > 2)
+ goto out_usage;
+ wimfile = argv[0];
+
+ ret = file_writable(wimfile);
+ if (ret)
+ goto out;
+
+ ret = wimlib_open_wim(wimfile, open_flags, &wim, imagex_progress_func);
+ if (ret)
+ goto out;
+
+ if (argc == 2)
+ image_num_or_name = argv[1];
+ else
+ image_num_or_name = T("1");
+
+ image = wimlib_resolve_image(wim, image_num_or_name);
+
+ ret = verify_image_exists_and_is_single(image, image_num_or_name,
+ wimfile);
+ if (ret)
+ goto out_wimlib_free;
+
+ num_images = wimlib_get_num_images(wim);
+ if (argc == 1 && num_images != 1) {
+ imagex_error(T("\"%"TS"\" contains %d images; Please select one."),
+ wimfile, num_images);
+ usage(UPDATE);
+ ret = -1;
+ goto out_wimlib_free;
+ }
+
+ /* 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 = &default_capture_config;
+ }
+
+ /* Read update commands from standard input */
+ if (isatty(STDIN_FILENO)) {
+ tputs(T("Reading update commands from standard input..."));
+ recommend_man_page(T("update"));
+ }
+ cmd_file_contents = stdin_get_text_contents(&cmd_file_nchars);
+ if (!cmd_file_contents) {
+ ret = -1;
+ goto out_free_config;
+ }
+
+ /* 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;
+ }
+
+ /* Set default flags and capture config on the update commands */
+ for (size_t i = 0; i < num_cmds; i++) {
+ switch (cmds[i].op) {
+ case WIMLIB_UPDATE_OP_ADD:
+ cmds[i].add.add_flags |= default_add_flags;
+ cmds[i].add.config = config;
+ break;
+ case WIMLIB_UPDATE_OP_DELETE:
+ cmds[i].delete.delete_flags |= default_delete_flags;
+ break;
+ default:
+ break;
+ }
+ }
+
+#ifdef __WIN32__
+ win32_acquire_capture_privileges();
+#endif
+
+ /* Execute the update commands */
+ ret = wimlib_update_image(wim, image, cmds, num_cmds, update_flags,
+ imagex_progress_func);
+ if (ret)
+ goto out_release_privs;
+
+ /* Overwrite the updated WIM */
+ ret = wimlib_overwrite(wim, write_flags, num_threads,
+ imagex_progress_func);
+out_release_privs:
+#ifdef __WIN32__
+ win32_release_capture_privileges();
+#endif
+out_free_cmds:
+ free(cmds);
+out_free_cmd_file_contents:
+ free(cmd_file_contents);
+out_free_config:
+ if (config != NULL && config != &default_capture_config) {
+ free(config->exclusion_pats.pats);
+ free(config->exclusion_exception_pats.pats);
+ free(config_str);
+ }
+out_wimlib_free:
+ wimlib_free(wim);
+out:
+ return ret;
+out_usage:
+ usage(UPDATE);
+ ret = -1;
+ goto out;
+}
+
struct imagex_command {
const tchar *name;
int (*func)(int , tchar **);
{T("delete"), imagex_delete, DELETE},
{T("dir"), imagex_dir, DIR},
{T("export"), imagex_export, EXPORT},
+ {T("extract"), imagex_extract, EXTRACT},
{T("info"), imagex_info, INFO},
{T("join"), imagex_join, JOIN},
{T("mount"), imagex_mount_rw_or_ro, MOUNT},
{T("optimize"),imagex_optimize, OPTIMIZE},
{T("split"), imagex_split, SPLIT},
{T("unmount"), imagex_unmount, UNMOUNT},
+ {T("update"), imagex_update, UPDATE},
};
static void
-version()
+version(void)
{
static const tchar *s =
T(
for (i = 1; i < argc; i++) {
p = argv[i];
- if (*p == '-')
+ if (*p == T('-'))
p++;
else
continue;
- if (*p == '-')
+ if (*p == T('-'))
p++;
if (!tstrcmp(p, T("help"))) {
for_imagex_command(cmd) {
tprintf(T("Usage:\n%"TS), usage_strings[cmd_type]);
for_imagex_command(cmd) {
if (cmd->cmd == cmd_type) {
- tprintf(T("\nTry `man "IMAGEX_PROGNAME"-%"TS"' "
- "for more details.\n"), cmd->name);
+ tputc(T('\n'), stdout);
+ recommend_man_page(cmd->name);
}
}
}
static void
-usage_all()
+usage_all(void)
{
tfputs(T("Usage:\n"), stdout);
for (int i = 0; i < ARRAY_LEN(usage_strings); i++)
"\n"
" The compression TYPE may be \"maximum\", \"fast\", or \"none\".\n"
"\n"
-" Try `man "IMAGEX_PROGNAME"' for more information.\n"
);
tfputs(extra, stdout);
+ recommend_man_page(T(""));
}
/* Entry point for wimlib's ImageX implementation. On UNIX the command
{
const struct imagex_command *cmd;
int ret;
+ int init_flags = 0;
#ifndef __WIN32__
- setlocale(LC_ALL, "");
- {
- char *codeset = nl_langinfo(CODESET);
+ if (getenv("WIMLIB_IMAGEX_USE_UTF8")) {
+ init_flags |= WIMLIB_INIT_FLAG_ASSUME_UTF8;
+ } else {
+ char *codeset;
+
+ setlocale(LC_ALL, "");
+ codeset = nl_langinfo(CODESET);
if (!strstr(codeset, "UTF-8") &&
!strstr(codeset, "UTF8") &&
!strstr(codeset, "utf-8") &&
{
fputs(
"WARNING: Running "IMAGEX_PROGNAME" in a UTF-8 locale is recommended!\n"
-" (Maybe try: `export LANG=en_US.UTF-8'?\n", stderr);
+" Maybe try: `export LANG=en_US.UTF-8'?\n"
+" Alternatively, set the environmental variable WIMLIB_IMAGEX_USE_UTF8\n"
+" to any value to force wimlib to use UTF-8.\n",
+ stderr);
}
}
if (argc < 2) {
imagex_error(T("No command specified"));
usage_all();
- return 1;
+ ret = 2;
+ goto out;
}
/* Handle --help and --version for all commands. Note that this will
wimlib_set_print_errors(true);
/* Do any initializations that the library needs */
- ret = wimlib_global_init();
+ ret = wimlib_global_init(init_flags);
if (ret)
- goto out;
+ goto out_check_status;
/* Search for the function to handle the ImageX subcommand. */
for_imagex_command(cmd) {
imagex_error(T("Unrecognized command: `%"TS"'"), argv[0]);
usage_all();
- return 1;
+ ret = 2;
+ goto out_cleanup;
out_check_write_error:
/* For 'wimlib-imagex info' and 'wimlib-imagex dir', data printed to
* standard output is part of the program's actual behavior and not just
* there was a write error. */
if (cmd == &imagex_commands[INFO] || cmd == &imagex_commands[DIR]) {
if (ferror(stdout) || fclose(stdout)) {
- imagex_error_with_errno(T("output error"));
+ imagex_error_with_errno(T("error writing to standard output"));
if (ret == 0)
ret = -1;
}
}
-out:
+out_check_status:
/* Exit status (ret): -1 indicates an error found by 'wimlib-imagex'
* outside of the wimlib library code. 0 indicates success. > 0
* indicates a wimlib error code from which an error message can be
if (ret == WIMLIB_ERR_NTFS_3G && errno != 0)
imagex_error_with_errno(T("errno"));
}
-
+out_cleanup:
/* Make the library free any resources it's holding (not strictly
* necessary because the process is ending anyway). */
wimlib_global_cleanup();
+out:
return ret;
}
git://wimlib.net / wimlib / blobdiff