*
* Use wimlib to create, modify, extract, mount, unmount, or display information
* about a WIM file
- *
+ */
+
+/*
* Copyright (C) 2012 Eric Biggers
*
* This program is free software: you can redistribute it and/or modify
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "wimlib.h"
#include "config.h"
+
+#include "wimlib.h"
+
+#include <errno.h>
#include <getopt.h>
-#include <stdlib.h>
+#include <glob.h>
+#include <inttypes.h>
+#include <libgen.h>
+#include <limits.h>
#include <stdarg.h>
+#include <stdlib.h>
#include <string.h>
-#include <errno.h>
#include <sys/stat.h>
+#include <unistd.h>
#define ARRAY_LEN(array) (sizeof(array) / sizeof(array[0]))
-#define swap(a, b) ({ typeof(a) __a = (a); typeof(b) __b = (b); \
- a = __b; b = __a; })
-
#define for_opt(c, opts) while ((c = getopt_long_only(argc, (char**)argv, "", \
opts, NULL)) != -1)
DIR,
EXPORT,
INFO,
+ JOIN,
MOUNT,
MOUNTRW,
+ OPTIMIZE,
+ SPLIT,
UNMOUNT,
};
-static const char *path_basename(const char *path)
-{
- const char *p = path;
- while (*p)
- p++;
- p--;
-
- /* Trailing slashes. */
- while ((p != path - 1) && *p == '/')
- p--;
-
- while ((p != path - 1) && *p != '/')
- p--;
-
- return p + 1;
-}
-
+static void usage(int cmd_type);
+static void usage_all();
static const char *usage_strings[] = {
-[APPEND] =
-" imagex append DIRECTORY WIMFILE [\"IMAGE_NAME\"] [\"DESCRIPTION\"] [--boot]\n"
-" [--check] [--config CONFIG_FILE] [--flags EDITIONID] [--verify]\n",
-[APPLY] =
-" imagex apply WIMFILE [IMAGE_NUM | IMAGE_NAME | all] DIRECTORY [--check]\n"
-" [--verify] [--hardlink] [--symlink] [--verbose]\n",
-[CAPTURE] =
-" imagex capture DIRECTORY WIMFILE [\"IMAGE_NAME\"] [\"DESCRIPTION\"]\n"
-" [--boot] [--check] [--compress[=TYPE]] [--config CONFIG_FILE]\n"
-" [--flags \"EditionID\"] [--norpfix] [--verify] [--verbose]\n",
-[DELETE] =
-" imagex delete WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--check]\n",
-[DIR] =
-" imagex dir WIMFILE (IMAGE_NUM | IMAGE_NAME | \"all\")\n",
-[EXPORT] =
-" imagex export SRC_WIMFILE (SRC_IMAGE_NUM | SRC_IMAGE_NAME | all ) \n"
-" DEST_WIMFILE [\"DEST_IMAGE_NAME\"] [\"DEST_IMAGE_DESCRIPTION\"]\n"
-" [--boot] [--check] [--compress[=TYPE]]\n",
-[INFO] =
-" imagex info WIMFILE [IMAGE_NUM | IMAGE_NAME] [NEW_NAME]\n"
-" [NEW_DESC] [--boot] [--check] [--header] [--lookup-table]\n"
-" [--xml] [--extract-xml FILE] [--metadata]\n",
-[MOUNT] =
-" imagex mount WIMFILE (IMAGE_NUM | IMAGE_NAME) DIRECTORY\n"
-" [--check] [--debug]\n",
-[MOUNTRW] =
-" imagex mountrw WIMFILE [IMAGE_NUM | IMAGE_NAME] DIRECTORY\n"
-" [--check] [--debug]\n",
-[UNMOUNT] =
-" imagex unmount DIRECTORY [--commit] [--check]\n",
+[APPEND] =
+"imagex append (DIRECTORY | NTFS_VOLUME) WIMFILE [IMAGE_NAME]\n"
+" [DESCRIPTION] [--boot] [--check] [--flags EDITION_ID]\n"
+" [--verbose] [--dereference] [--config=FILE]\n"
+" [--threads=NUM_THREADS] [--rebuild] [--unix-data]\n",
+[APPLY] =
+"imagex apply WIMFILE [IMAGE_NUM | IMAGE_NAME | all]\n"
+" (DIRECTORY | NTFS_VOLUME) [--check] [--hardlink]\n"
+" [--symlink] [--verbose] [--ref=\"GLOB\"] [--unix-data]\n",
+[CAPTURE] =
+"imagex capture (DIRECTORY | NTFS_VOLUME) WIMFILE [IMAGE_NAME]\n"
+" [DESCRIPTION] [--boot] [--check] [--compress=TYPE]\n"
+" [--flags EDITION_ID] [--verbose] [--dereference]\n"
+" [--config=FILE] [--threads=NUM_THREADS] [--unix-data]\n",
+[DELETE] =
+"imagex delete WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--check] [--soft]\n",
+[DIR] =
+"imagex dir WIMFILE (IMAGE_NUM | IMAGE_NAME | all)\n",
+[EXPORT] =
+"imagex export SRC_WIMFILE (SRC_IMAGE_NUM | SRC_IMAGE_NAME | all ) \n"
+" DEST_WIMFILE [DEST_IMAGE_NAME] [DEST_IMAGE_DESCRIPTION]\n"
+" [--boot] [--check] [--compress=TYPE] [--ref=\"GLOB\"]\n"
+" [--threads=NUM_THREADS] [--rebuild]\n",
+[INFO] =
+"imagex info WIMFILE [IMAGE_NUM | IMAGE_NAME] [NEW_NAME]\n"
+" [NEW_DESC] [--boot] [--check] [--header] [--lookup-table]\n"
+" [--xml] [--extract-xml FILE] [--metadata]\n",
+[JOIN] =
+"imagex join [--check] WIMFILE SPLIT_WIM...\n",
+[MOUNT] =
+"imagex mount WIMFILE (IMAGE_NUM | IMAGE_NAME) DIRECTORY\n"
+" [--check] [--debug] [--streams-interface=INTERFACE]\n"
+" [--ref=\"GLOB\"] [--unix-data] [--allow-other]\n",
+[MOUNTRW] =
+"imagex mountrw WIMFILE [IMAGE_NUM | IMAGE_NAME] DIRECTORY\n"
+" [--check] [--debug] [--streams-interface=INTERFACE]\n"
+" [--staging-dir=DIR] [--unix-data] [--allow-other]\n",
+[OPTIMIZE] =
+"imagex optimize WIMFILE [--check] [--recompress] [--compress=TYPE]\n",
+[SPLIT] =
+"imagex split WIMFILE SPLIT_WIMFILE PART_SIZE_MB [--check]\n",
+[UNMOUNT] =
+"imagex unmount DIRECTORY [--commit] [--check] [--rebuild]\n",
};
static const struct option common_options[] = {
{NULL, 0, NULL, 0},
};
-static const struct option append_options[] = {
- {"boot", no_argument, NULL, 'b'},
- {"check", no_argument, NULL, 'c'},
- {"config", required_argument, NULL, 'C'},
- {"flags", required_argument, NULL, 'f'},
- {"verify", no_argument, NULL, 'V'},
- {NULL, 0, NULL, 0},
-};
static const struct option apply_options[] = {
- {"check", no_argument, NULL, 'c'},
- {"verify", no_argument, NULL, 'V'},
- {"hardlink", no_argument, NULL, 'h'},
- {"symlink", no_argument, NULL, 's'},
- {"verbose", no_argument, NULL, 'v'},
+ {"check", no_argument, NULL, 'c'},
+ {"hardlink", no_argument, NULL, 'h'},
+ {"symlink", no_argument, NULL, 's'},
+ {"verbose", no_argument, NULL, 'v'},
+ {"ref", required_argument, NULL, 'r'},
+ {"unix-data", no_argument, NULL, 'U'},
{NULL, 0, NULL, 0},
};
-static const struct option capture_options[] = {
- {"boot", no_argument, NULL, 'b'},
- {"check", no_argument, NULL, 'c'},
- {"compress", optional_argument, NULL, 'x'},
- {"config", required_argument, NULL, 'C'},
- {"flags", required_argument, NULL, 'f'},
- {"norpfix", no_argument, NULL, 'n'},
- {"verify", no_argument, NULL, 'V'},
- {"verbose", no_argument, NULL, 'v'},
+static const struct option capture_or_append_options[] = {
+ {"boot", no_argument, NULL, 'b'},
+ {"check", no_argument, NULL, 'c'},
+ {"compress", required_argument, NULL, 'x'},
+ {"config", required_argument, NULL, 'C'},
+ {"dereference", no_argument, NULL, 'L'},
+ {"flags", required_argument, NULL, 'f'},
+ {"verbose", no_argument, NULL, 'v'},
+ {"threads", required_argument, NULL, 't'},
+ {"rebuild", no_argument, NULL, 'R'},
+ {"unix-data", no_argument, NULL, 'U'},
{NULL, 0, NULL, 0},
};
static const struct option delete_options[] = {
{"check", no_argument, NULL, 'c'},
+ {"soft", no_argument, NULL, 's'},
{NULL, 0, NULL, 0},
};
static const struct option export_options[] = {
- {"boot", no_argument, NULL, 'b'},
- {"check", no_argument , NULL, 'c'},
- {"compress", optional_argument, NULL, 'x'},
+ {"boot", no_argument, NULL, 'b'},
+ {"check", no_argument, NULL, 'c'},
+ {"compress", required_argument, NULL, 'x'},
+ {"ref", required_argument, NULL, 'r'},
+ {"threads", required_argument, NULL, 't'},
+ {"rebuild", no_argument, NULL, 'R'},
{NULL, 0, NULL, 0},
};
static const struct option info_options[] = {
{"boot", no_argument, NULL, 'b'},
{"check", no_argument, NULL, 'c'},
+ {"extract-xml", required_argument, NULL, 'X'},
{"header", no_argument, NULL, 'h'},
{"lookup-table", no_argument, NULL, 'l'},
- {"xml", no_argument, NULL, 'x'},
- {"extract-xml", required_argument, NULL, 'X'},
{"metadata", no_argument, NULL, 'm'},
+ {"xml", no_argument, NULL, 'x'},
{NULL, 0, NULL, 0},
};
+
+static const struct option join_options[] = {
+ {"check", no_argument, NULL, 'c'},
+ {NULL, 0, NULL, 0},
+};
+
static const struct option mount_options[] = {
+ {"check", no_argument, NULL, 'c'},
+ {"debug", no_argument, NULL, 'd'},
+ {"streams-interface", required_argument, NULL, 's'},
+ {"ref", required_argument, NULL, 'r'},
+ {"staging-dir", required_argument, NULL, 'D'},
+ {"unix-data", no_argument, NULL, 'U'},
+ {"allow-other", no_argument, NULL, 'A'},
+ {NULL, 0, NULL, 0},
+};
+
+static const struct option optimize_options[] = {
+ {"check", no_argument, NULL, 'c'},
+ {"recompress", no_argument, NULL, 'r'},
+ {NULL, 0, NULL, 0},
+};
+
+static const struct option split_options[] = {
{"check", no_argument, NULL, 'c'},
- {"debug", no_argument, NULL, 'd'},
{NULL, 0, NULL, 0},
};
static const struct option unmount_options[] = {
- {"commit", no_argument, NULL, 'c'},
- {"check", no_argument, NULL, 'C'},
+ {"commit", no_argument, NULL, 'c'},
+ {"check", no_argument, NULL, 'C'},
+ {"rebuild", no_argument, NULL, 'R'},
{NULL, 0, NULL, 0},
};
+
/* Print formatted error message to stderr. */
static void imagex_error(const char *format, ...)
{
va_start(va, format);
fputs("ERROR: ", stderr);
vfprintf(stderr, format, va);
+ putc('\n', stderr);
va_end(va);
}
-
-static inline void version()
-{
- static const char *s =
- "imagex (" PACKAGE ") " PACKAGE_VERSION "\n"
- "Copyright (C) 2012 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"
- "\n"
- "Report bugs to "PACKAGE_BUGREPORT".\n";
- fputs(s, stdout);
-}
-
-static inline void usage(int cmd)
-{
- puts("IMAGEX: Usage:");
- fputs(usage_strings[cmd], stdout);
-}
-
-static void usage_all()
+/* Print formatted error message to stderr. */
+static void imagex_error_with_errno(const char *format, ...)
{
- puts("IMAGEX: Usage:");
- for (int i = 0; i < ARRAY_LEN(usage_strings); i++)
- fputs(usage_strings[i], stdout);
- static const char *extra =
-" imagex --help\n"
-" imagex --version\n"
-"\n"
-" The compression TYPE may be \"maximum\", \"fast\", or \"none\".\n"
- ;
- fputs(extra, stdout);
+ int errno_save = errno;
+ va_list va;
+ va_start(va, format);
+ fputs("ERROR: ", stderr);
+ vfprintf(stderr, format, va);
+ fprintf(stderr, ": %s\n", strerror(errno_save));
+ va_end(va);
}
-static int verify_image_exists(int image)
+static int verify_image_exists(int image, const char *image_name,
+ const char *wim_name)
{
- if (image == WIM_NO_IMAGE) {
- imagex_error("Not a valid image!\n");
- return WIMLIB_ERR_INVALID_IMAGE;
+ if (image == WIMLIB_NO_IMAGE) {
+ imagex_error("\"%s\" is not a valid image in `%s'!\n"
+ " Please specify a 1-based imagex index or "
+ "image name.\n"
+ " You may use `imagex info' to list the images "
+ "contained in a WIM.",
+ image_name, wim_name);
+ return -1;
}
return 0;
}
static int verify_image_is_single(int image)
{
- if (image == WIM_ALL_IMAGES) {
- imagex_error("Cannot specify all images for this action!\n");
- return WIMLIB_ERR_INVALID_IMAGE;
+ if (image == WIMLIB_ALL_IMAGES) {
+ imagex_error("Cannot specify all images for this action!");
+ return -1;
}
return 0;
}
-static int verify_image_exists_and_is_single(int image)
+static int verify_image_exists_and_is_single(int image, const char *image_name,
+ const char *wim_name)
{
int ret;
- ret = verify_image_exists(image);
+ ret = verify_image_exists(image, image_name, wim_name);
if (ret == 0)
ret = verify_image_is_single(image);
return ret;
static int get_compression_type(const char *optarg)
{
- if (!optarg)
- return WIM_COMPRESSION_TYPE_LZX;
if (strcasecmp(optarg, "maximum") == 0 || strcasecmp(optarg, "lzx") == 0)
- return WIM_COMPRESSION_TYPE_LZX;
+ return WIMLIB_COMPRESSION_TYPE_LZX;
else if (strcasecmp(optarg, "fast") == 0 || strcasecmp(optarg, "xpress") == 0)
- return WIM_COMPRESSION_TYPE_XPRESS;
+ return WIMLIB_COMPRESSION_TYPE_XPRESS;
else if (strcasecmp(optarg, "none") == 0)
- return WIM_COMPRESSION_TYPE_NONE;
+ return WIMLIB_COMPRESSION_TYPE_NONE;
else {
imagex_error("Invalid compression type `%s'! Must be "
- "\"maximum\", \"fast\", or \"none\".\n",
- optarg);
- return WIM_COMPRESSION_TYPE_INVALID;
+ "\"maximum\", \"fast\", or \"none\".", optarg);
+ return WIMLIB_COMPRESSION_TYPE_INVALID;
}
}
-static int imagex_append(int argc, const char **argv)
+static off_t file_get_size(const char *filename)
{
- int c;
- const char *flags_element = NULL;
- int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
- int add_image_flags = 0;
- int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
- const char *dir;
- const char *wimfile;
- const char *name;
- const char *desc;
- WIMStruct *w;
- int ret;
+ struct stat st;
+ if (stat(filename, &st) == 0)
+ return st.st_size;
+ else
+ return (off_t)-1;
+}
- for_opt(c, append_options) {
- switch (c) {
- case 'b':
- add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_BOOT;
- break;
- case 'c':
- open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
- write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
- break;
- case 'C':
- /*config = optarg;*/
- break;
- case 'f':
- flags_element = optarg;
- break;
- case 'V':
- /* verify */
- break;
- default:
- usage(APPEND);
- return -1;
- }
+static const char *default_capture_config =
+"[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";
+
+static char *file_get_contents(const char *filename, size_t *len_ret)
+{
+ struct stat stbuf;
+ char *buf;
+ size_t len;
+ FILE *fp;
+
+ if (stat(filename, &stbuf) != 0) {
+ imagex_error_with_errno("Failed to stat the file `%s'", filename);
+ return NULL;
}
- argc -= optind;
- argv += optind;
- if (argc < 2 || argc > 4) {
- usage(APPEND);
- return -1;
+ len = stbuf.st_size;
+
+ fp = fopen(filename, "rb");
+ if (!fp) {
+ imagex_error_with_errno("Failed to open the file `%s'", filename);
+ return NULL;
}
- dir = argv[0];
- wimfile = argv[1];
- name = (argc >= 3) ? argv[2] : path_basename(dir);
- desc = (argc >= 4) ? argv[3] : NULL;
- ret = wimlib_open_wim(wimfile, open_flags, &w);
- if (ret != 0)
- return ret;
+ buf = malloc(len);
+ if (!buf) {
+ imagex_error("Failed to allocate buffer of %zu bytes to hold "
+ "contents of file `%s'", len, filename);
+ goto out_fclose;
+ }
+ if (fread(buf, 1, len, fp) != len) {
+ imagex_error_with_errno("Failed to read %lu bytes from the "
+ "file `%s'", len, filename);
+ goto out_free_buf;
+ }
+ *len_ret = len;
+ return buf;
+out_free_buf:
+ free(buf);
+out_fclose:
+ fclose(fp);
+ return NULL;
+}
- ret = wimlib_add_image(w, dir, name, desc,
- flags_element, add_image_flags);
+static int file_writable(const char *path)
+{
+ int ret;
+ ret = access(path, W_OK);
if (ret != 0)
- goto done;
- ret = wimlib_overwrite(w, write_flags);
-done:
- wimlib_free(w);
+ imagex_error_with_errno("Can't modify `%s'", path);
+ return ret;
+}
+
+#define TO_PERCENT(numerator, denominator) \
+ (((denominator) == 0) ? 0 : ((numerator) * 100 / (denominator)))
+
+static const char *get_data_type(int ctype)
+{
+ switch (ctype) {
+ case WIMLIB_COMPRESSION_TYPE_NONE:
+ return "uncompressed";
+ case WIMLIB_COMPRESSION_TYPE_LZX:
+ return "LZX-compressed";
+ case WIMLIB_COMPRESSION_TYPE_XPRESS:
+ return "XPRESS-compressed";
+ }
+ return NULL;
+}
+
+static int imagex_progress_func(enum wimlib_progress_msg msg,
+ const union wimlib_progress_info *info)
+{
+ unsigned percent_done;
+ switch (msg) {
+ case WIMLIB_PROGRESS_MSG_WRITE_STREAMS:
+ percent_done = TO_PERCENT(info->write_streams.completed_bytes,
+ info->write_streams.total_bytes);
+ if (info->write_streams.completed_streams == 0) {
+ const char *data_type;
+
+ data_type = get_data_type(info->write_streams.compression_type);
+ printf("Writing %s data using %u thread%s\n",
+ data_type, info->write_streams.num_threads,
+ (info->write_streams.num_threads == 1) ? "" : "s");
+ }
+ printf("\r%"PRIu64" MiB of %"PRIu64" MiB (uncompressed) "
+ "written (%u%% done)",
+ info->write_streams.completed_bytes >> 20,
+ info->write_streams.total_bytes >> 20,
+ percent_done);
+ if (info->write_streams.completed_bytes >= info->write_streams.total_bytes)
+ putchar('\n');
+ break;
+ case WIMLIB_PROGRESS_MSG_SCAN_BEGIN:
+ printf("Scanning `%s'...\n", info->scan.source);
+ break;
+ case WIMLIB_PROGRESS_MSG_SCAN_DENTRY:
+ if (info->scan.excluded)
+ printf("Excluding `%s' from capture\n", info->scan.cur_path);
+ else
+ printf("Scanning `%s'\n", info->scan.cur_path);
+ break;
+ /*case WIMLIB_PROGRESS_MSG_SCAN_END:*/
+ /*break;*/
+ case WIMLIB_PROGRESS_MSG_VERIFY_INTEGRITY:
+ percent_done = TO_PERCENT(info->integrity.completed_bytes,
+ info->integrity.total_bytes);
+ printf("\rVerifying integrity of `%s': %"PRIu64" MiB "
+ "of %"PRIu64" MiB (%u%%) done",
+ info->integrity.filename,
+ info->integrity.completed_bytes >> 20,
+ info->integrity.total_bytes >> 20,
+ percent_done);
+ if (info->integrity.completed_bytes == info->integrity.total_bytes)
+ putchar('\n');
+ break;
+ case WIMLIB_PROGRESS_MSG_CALC_INTEGRITY:
+ percent_done = TO_PERCENT(info->integrity.completed_bytes,
+ info->integrity.total_bytes);
+ printf("\rCalculating integrity table for WIM: %"PRIu64" MiB "
+ "of %"PRIu64" MiB (%u%%) done",
+ info->integrity.completed_bytes >> 20,
+ info->integrity.total_bytes >> 20,
+ percent_done);
+ if (info->integrity.completed_bytes == info->integrity.total_bytes)
+ putchar('\n');
+ break;
+ case WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN:
+ printf("Applying image %d (%s) from `%s' to %s `%s'\n",
+ info->extract.image,
+ info->extract.image_name,
+ info->extract.wimfile_name,
+ ((info->extract.extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) ?
+ "NTFS volume" : "directory"),
+ info->extract.target);
+ break;
+ /*case WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_BEGIN:*/
+ /*printf("Applying directory structure to %s\n",*/
+ /*info->extract.target);*/
+ /*break;*/
+ case WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS:
+ percent_done = TO_PERCENT(info->extract.completed_bytes,
+ info->extract.total_bytes);
+ printf("\rExtracting files: "
+ "%"PRIu64" MiB of %"PRIu64" MiB (%u%%) done",
+ info->extract.completed_bytes >> 20,
+ info->extract.total_bytes >> 20,
+ percent_done);
+ if (info->extract.completed_bytes >= info->extract.total_bytes)
+ putchar('\n');
+ break;
+ case WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY:
+ puts(info->extract.cur_path);
+ break;
+ case WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS:
+ printf("Setting timestamps on all extracted files...\n");
+ break;
+ case WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END:
+ if (info->extract.extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
+ printf("Unmounting NTFS volume `%s'...\n",
+ info->extract.target);
+ }
+ break;
+ 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);
+ break;
+ case WIMLIB_PROGRESS_MSG_SPLIT_BEGIN_PART:
+ percent_done = TO_PERCENT(info->split.completed_bytes,
+ info->split.total_bytes);
+ printf("Writing `%s': %"PRIu64" MiB of %"PRIu64" MiB (%u%%) written\n",
+ info->split.part_name,
+ info->split.completed_bytes >> 20,
+ info->split.total_bytes >> 20,
+ percent_done);
+ break;
+ case WIMLIB_PROGRESS_MSG_SPLIT_END_PART:
+ if (info->split.completed_bytes == info->split.total_bytes) {
+ printf("Finished writing %u split WIM parts\n",
+ info->split.cur_part_number);
+ }
+ break;
+ default:
+ break;
+ }
+ fflush(stdout);
+ return 0;
+}
+
+
+static int open_swms_from_glob(const char *swm_glob,
+ const char *first_part,
+ int open_flags,
+ WIMStruct ***additional_swms_ret,
+ unsigned *num_additional_swms_ret)
+{
+ unsigned num_additional_swms = 0;
+ WIMStruct **additional_swms = NULL;
+ glob_t globbuf;
+ int ret;
+
+ ret = glob(swm_glob, GLOB_ERR | GLOB_NOSORT, NULL, &globbuf);
+ if (ret != 0) {
+ if (ret == GLOB_NOMATCH) {
+ imagex_error("Found no files for glob \"%s\"",
+ swm_glob);
+ } else {
+ imagex_error_with_errno("Failed to process glob "
+ "\"%s\"", swm_glob);
+ }
+ ret = -1;
+ goto out;
+ }
+ num_additional_swms = globbuf.gl_pathc;
+ additional_swms = calloc(num_additional_swms, sizeof(additional_swms[0]));
+ if (!additional_swms) {
+ imagex_error("Out of memory");
+ ret = -1;
+ goto out_globfree;
+ }
+ unsigned offset = 0;
+ for (unsigned i = 0; i < num_additional_swms; i++) {
+ if (strcmp(globbuf.gl_pathv[i], first_part) == 0) {
+ offset++;
+ continue;
+ }
+ ret = wimlib_open_wim(globbuf.gl_pathv[i],
+ open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK,
+ &additional_swms[i - offset],
+ imagex_progress_func);
+ if (ret != 0)
+ goto out_close_swms;
+ }
+ *additional_swms_ret = additional_swms;
+ *num_additional_swms_ret = num_additional_swms - offset;
+ ret = 0;
+ goto out_globfree;
+out_close_swms:
+ for (unsigned i = 0; i < num_additional_swms; i++)
+ wimlib_free(additional_swms[i]);
+ free(additional_swms);
+out_globfree:
+ globfree(&globbuf);
+out:
return ret;
}
+
+static unsigned parse_num_threads(const char *optarg)
+{
+ char *tmp;
+ unsigned nthreads = strtoul(optarg, &tmp, 10);
+ if (nthreads == UINT_MAX || *tmp || tmp == optarg) {
+ imagex_error("Number of threads must be a non-negative integer!");
+ return UINT_MAX;
+ } else {
+ return nthreads;
+ }
+}
+
+
/* Extract one image, or all images, from a WIM file into a directory. */
static int imagex_apply(int argc, const char **argv)
{
int c;
- int link_type = WIM_LINK_TYPE_NONE;
- int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
- bool verbose = false;
+ int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
int image;
int num_images;
WIMStruct *w;
int ret;
const char *wimfile;
- const char *dir;
+ const char *target;
const char *image_num_or_name;
+ int extract_flags = WIMLIB_EXTRACT_FLAG_SEQUENTIAL;
+
+ const char *swm_glob = NULL;
+ WIMStruct **additional_swms = NULL;
+ unsigned num_additional_swms = 0;
for_opt(c, apply_options) {
switch (c) {
case 'c':
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
break;
- case 'V':
- /* verify */
- break;
case 'h':
- link_type = WIM_LINK_TYPE_HARD;
+ extract_flags |= WIMLIB_EXTRACT_FLAG_HARDLINK;
break;
case 's':
- link_type = WIM_LINK_TYPE_SYMBOLIC;
+ extract_flags |= WIMLIB_EXTRACT_FLAG_SYMLINK;
break;
case 'v':
- verbose = true;
+ extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
+ break;
+ case 'r':
+ swm_glob = optarg;
+ break;
+ case 'U':
+ extract_flags |= WIMLIB_EXTRACT_FLAG_UNIX_DATA;
break;
default:
usage(APPLY);
wimfile = argv[0];
if (argc == 2) {
- image_num_or_name = "1";
- dir = argv[1];
+ image_num_or_name = "1";
+ target = argv[1];
} else {
image_num_or_name = argv[1];
- dir = argv[2];
+ target = argv[2];
}
- ret = wimlib_open_wim(wimfile, open_flags, &w);
+ ret = wimlib_open_wim(wimfile, open_flags, &w, imagex_progress_func);
if (ret != 0)
return ret;
image = wimlib_resolve_image(w, image_num_or_name);
- ret = verify_image_exists(image);
+ ret = verify_image_exists(image, image_num_or_name, wimfile);
if (ret != 0)
- goto done;
+ goto out;
num_images = wimlib_get_num_images(w);
if (argc == 2 && num_images != 1) {
imagex_error("`%s' contains %d images; Please select one "
- "(or all).\n", wimfile, num_images);
+ "(or all)", wimfile, num_images);
usage(APPLY);
ret = -1;
- goto done;
+ goto out;
}
- ret = wimlib_set_output_dir(w, dir);
- if (ret != 0)
- goto done;
- wimlib_set_verbose(w, verbose);
- wimlib_set_link_type(w, link_type);
- ret = wimlib_extract_image(w, image);
-done:
+
+ if (swm_glob) {
+ ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
+ &additional_swms,
+ &num_additional_swms);
+ if (ret != 0)
+ goto out;
+ }
+
+ struct stat stbuf;
+
+ ret = stat(target, &stbuf);
+ if (ret == 0) {
+ if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode))
+ extract_flags |= WIMLIB_EXTRACT_FLAG_NTFS;
+ } else {
+ if (errno != ENOENT) {
+ imagex_error_with_errno("Failed to stat `%s'", target);
+ ret = -1;
+ goto out;
+ }
+ }
+
+ ret = wimlib_extract_image(w, image, target, extract_flags,
+ additional_swms, num_additional_swms,
+ imagex_progress_func);
+ if (ret == 0)
+ printf("Done applying WIM image.\n");
+out:
wimlib_free(w);
+ if (additional_swms) {
+ for (unsigned i = 0; i < num_additional_swms; i++)
+ wimlib_free(additional_swms[i]);
+ free(additional_swms);
+ }
return ret;
}
-
-/* Create a WIM file from a directory. */
-static int imagex_capture(int argc, const char **argv)
+static int imagex_capture_or_append(int argc, const char **argv)
{
int c;
+ int open_flags = 0;
int add_image_flags = 0;
- int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
- int compression_type = WIM_COMPRESSION_TYPE_NONE;
- const char *flags_element = NULL;
- bool verbose = false;
- const char *dir;
+ int write_flags = 0;
+ int compression_type = WIMLIB_COMPRESSION_TYPE_XPRESS;
+ const char *source;
const char *wimfile;
const char *name;
const char *desc;
- WIMStruct *w;
+ const char *flags_element = NULL;
+ const char *config_file = NULL;
+ char *config_str = NULL;
+ size_t config_len = 0;
+ WIMStruct *w = NULL;
int ret;
+ int cur_image;
+ char *default_name;
+ int cmd = strcmp(argv[0], "append") ? CAPTURE : APPEND;
+ unsigned num_threads = 0;
- for_opt(c, capture_options) {
+ for_opt(c, capture_or_append_options) {
switch (c) {
case 'b':
add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_BOOT;
break;
case 'c':
+ open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
+ case 'C':
+ config_file = optarg;
+ break;
case 'x':
compression_type = get_compression_type(optarg);
- if (compression_type == WIM_COMPRESSION_TYPE_INVALID)
+ if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID)
return -1;
break;
- case 'C':
- /*config = optarg;*/
- break;
case 'f':
flags_element = optarg;
break;
- case 'n':
- /*norpfix = true;*/
+ case 'L':
+ add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
break;
case 'v':
- verbose = true;
+ add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
+ break;
+ case 't':
+ num_threads = parse_num_threads(optarg);
+ if (num_threads == UINT_MAX)
+ return -1;
break;
- case 'V':
- /*verify = true;*/
+ case 'R':
+ write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
+ break;
+ case 'U':
+ add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA;
break;
default:
- usage(CAPTURE);
+ usage(cmd);
return -1;
}
}
-
argc -= optind;
argv += optind;
if (argc < 2 || argc > 4) {
- usage(CAPTURE);
+ usage(cmd);
return -1;
}
- dir = argv[0];
+ source = argv[0];
wimfile = argv[1];
- name = (argc >= 3) ? argv[2] : dir;
- desc = (argc >= 4) ? argv[3] : NULL;
- ret = wimlib_create_new_wim(compression_type, &w);
+ char source_copy[strlen(source) + 1];
+ memcpy(source_copy, source, strlen(source) + 1);
+ default_name = basename(source_copy);
+
+ name = (argc >= 3) ? argv[2] : default_name;
+ desc = (argc >= 4) ? argv[3] : NULL;
+
+ if (config_file) {
+ config_str = file_get_contents(config_file, &config_len);
+ if (!config_str)
+ return -1;
+ }
+
+ if (cmd == APPEND)
+ ret = wimlib_open_wim(wimfile, open_flags, &w,
+ imagex_progress_func);
+ else
+ ret = wimlib_create_new_wim(compression_type, &w);
if (ret != 0)
- return ret;
+ goto out;
- wimlib_set_verbose(w, verbose);
+ struct stat stbuf;
- ret = wimlib_add_image(w, dir, name, desc, flags_element,
- add_image_flags);
- if (ret != 0) {
- imagex_error("Failed to add the image `%s'!\n", dir);
- goto done;
+ ret = stat(source, &stbuf);
+ if (ret == 0) {
+ if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode)) {
+ printf("Capturing WIM image from NTFS filesystem on `%s'\n",
+ source);
+ add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_NTFS;
+ }
+ } else {
+ if (errno != ENOENT) {
+ imagex_error_with_errno("Failed to stat `%s'", source);
+ ret = -1;
+ goto out;
+ }
}
- ret = wimlib_write(w, wimfile, WIM_ALL_IMAGES, write_flags);
+ ret = wimlib_add_image(w, source, name,
+ (config_str ? config_str : default_capture_config),
+ (config_str ? config_len : strlen(default_capture_config)),
+ add_image_flags, imagex_progress_func);
+
if (ret != 0)
- imagex_error("Failed to write the WIM file `%s'!\n", wimfile);
-done:
+ goto out;
+ cur_image = wimlib_get_num_images(w);
+ if (desc) {
+ ret = wimlib_set_image_descripton(w, cur_image, desc);
+ if (ret != 0)
+ goto out;
+ }
+ if (flags_element) {
+ ret = wimlib_set_image_flags(w, cur_image, flags_element);
+ if (ret != 0)
+ goto out;
+ }
+ if (cmd == APPEND) {
+ ret = wimlib_overwrite(w, write_flags, num_threads,
+ imagex_progress_func);
+ } else {
+ ret = wimlib_write(w, wimfile, WIMLIB_ALL_IMAGES, write_flags,
+ num_threads, imagex_progress_func);
+ }
+ if (ret == WIMLIB_ERR_REOPEN)
+ ret = 0;
+ if (ret != 0)
+ imagex_error("Failed to write the WIM file `%s'", wimfile);
+out:
wimlib_free(w);
+ free(config_str);
return ret;
}
static int imagex_delete(int argc, const char **argv)
{
int c;
- int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
- int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
+ int open_flags = 0;
+ int write_flags = 0;
const char *wimfile;
const char *image_num_or_name;
WIMStruct *w;
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
+ case 's':
+ write_flags |= WIMLIB_WRITE_FLAG_SOFT_DELETE;
+ break;
default:
usage(DELETE);
return -1;
if (argc != 2) {
if (argc < 1)
- imagex_error("Must specify a WIM file!\n");
+ imagex_error("Must specify a WIM file");
if (argc < 2)
- imagex_error("Must specify an image!\n");
+ imagex_error("Must specify an image");
usage(DELETE);
return -1;
}
wimfile = argv[0];
image_num_or_name = argv[1];
- ret = wimlib_open_wim(wimfile, open_flags, &w);
+ ret = file_writable(wimfile);
+ if (ret != 0)
+ return ret;
+
+ ret = wimlib_open_wim(wimfile, open_flags, &w,
+ imagex_progress_func);
if (ret != 0)
return ret;
image = wimlib_resolve_image(w, image_num_or_name);
- ret = verify_image_exists(image);
+ ret = verify_image_exists(image, image_num_or_name, wimfile);
if (ret != 0)
- goto done;
+ goto out;
ret = wimlib_delete_image(w, image);
if (ret != 0) {
- imagex_error("Failed to delete image from `%s'!\n",
- wimfile);
- goto done;
+ imagex_error("Failed to delete image from `%s'", wimfile);
+ goto out;
}
- ret = wimlib_overwrite(w, write_flags);
+ ret = wimlib_overwrite(w, write_flags, 0, imagex_progress_func);
+ if (ret == WIMLIB_ERR_REOPEN)
+ ret = 0;
if (ret != 0) {
imagex_error("Failed to write the file `%s' with image "
- "deleted!\n", wimfile);
+ "deleted", wimfile);
}
-done:
+out:
wimlib_free(w);
return ret;
}
int num_images;
if (argc < 2) {
- imagex_error("Must specify a WIM file!\n");
+ imagex_error("Must specify a WIM file");
usage(DIR);
return -1;
}
if (argc > 3) {
- imagex_error("Too many arguments!\n");
+ imagex_error("Too many arguments");
usage(DIR);
return -1;
}
wimfile = argv[1];
- ret = wimlib_open_wim(wimfile, 0, &w);
+ ret = wimlib_open_wim(wimfile, WIMLIB_OPEN_FLAG_SPLIT_OK, &w,
+ imagex_progress_func);
if (ret != 0)
return ret;
if (argc == 3) {
image = wimlib_resolve_image(w, argv[2]);
- ret = verify_image_exists(image);
+ ret = verify_image_exists(image, argv[2], wimfile);
if (ret != 0)
- goto done;
+ goto out;
} else {
/* Image was not specified. If the WIM only contains one image,
* choose that one; otherwise, print an error. */
num_images = wimlib_get_num_images(w);
if (num_images != 1) {
imagex_error("The file `%s' contains %d images; Please "
- "select one.\n", wimfile, num_images);
+ "select one.", wimfile, num_images);
usage(DIR);
ret = -1;
- goto done;
+ goto out;
}
image = 1;
}
ret = wimlib_print_files(w, image);
-done:
+out:
wimlib_free(w);
return ret;
}
static int imagex_export(int argc, const char **argv)
{
int c;
- int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
+ int open_flags = 0;
int export_flags = 0;
- int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
- int compression_type = WIM_COMPRESSION_TYPE_NONE;
+ int write_flags = 0;
+ int compression_type = WIMLIB_COMPRESSION_TYPE_NONE;
bool compression_type_specified = false;
const char *src_wimfile;
const char *src_image_num_or_name;
int image;
struct stat stbuf;
bool wim_is_new;
+ const char *swm_glob = NULL;
+ WIMStruct **additional_swms = NULL;
+ unsigned num_additional_swms = 0;
+ unsigned num_threads = 0;
for_opt(c, export_options) {
switch (c) {
break;
case 'x':
compression_type = get_compression_type(optarg);
- if (compression_type == WIM_COMPRESSION_TYPE_INVALID)
+ if (compression_type == WIMLIB_COMPRESSION_TYPE_INVALID)
return -1;
compression_type_specified = true;
break;
+ case 'r':
+ swm_glob = optarg;
+ break;
+ case 't':
+ num_threads = parse_num_threads(optarg);
+ if (num_threads == UINT_MAX)
+ return -1;
+ break;
+ case 'R':
+ write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
+ break;
default:
usage(EXPORT);
return -1;
dest_wimfile = argv[2];
dest_name = (argc >= 4) ? argv[3] : NULL;
dest_desc = (argc >= 5) ? argv[4] : NULL;
- ret = wimlib_open_wim(src_wimfile, open_flags, &src_w);
+ ret = wimlib_open_wim(src_wimfile,
+ open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK, &src_w,
+ imagex_progress_func);
if (ret != 0)
return ret;
- /* Determine if the destination is an existing file or not.
+ /* Determine if the destination is an existing file or not.
* If so, we try to append the exported image(s) to it; otherwise, we
* create a new WIM containing the exported image(s). */
if (stat(dest_wimfile, &stbuf) == 0) {
+ int dest_ctype;
+
wim_is_new = false;
/* Destination file exists. */
- if (!S_ISREG(stbuf.st_mode)) {
- imagex_error("`%s' is not a regular file!\n",
+ if (!S_ISREG(stbuf.st_mode) && !S_ISLNK(stbuf.st_mode)) {
+ imagex_error("`%s' is not a regular file",
dest_wimfile);
- goto done;
+ ret = -1;
+ goto out;
}
- ret = wimlib_open_wim(dest_wimfile, open_flags, &dest_w);
+ ret = wimlib_open_wim(dest_wimfile, open_flags, &dest_w,
+ imagex_progress_func);
if (ret != 0)
- goto done;
+ goto out;
- if (compression_type_specified && compression_type !=
- wimlib_get_compression_type(dest_w)) {
+ ret = file_writable(dest_wimfile);
+ if (ret != 0)
+ goto out;
+
+ dest_ctype = wimlib_get_compression_type(dest_w);
+ if (compression_type_specified
+ && compression_type != dest_ctype)
+ {
imagex_error("Cannot specify a compression type that is "
- "not the same as that used in the "
- "destination WIM!\n");
- goto done;
+ "not the same as that used in the "
+ "destination WIM");
+ ret = -1;
+ goto out;
}
- compression_type = wimlib_get_compression_type(dest_w);
} else {
wim_is_new = true;
/* dest_wimfile is not an existing file, so create a new WIM. */
+ if (!compression_type_specified)
+ compression_type = wimlib_get_compression_type(src_w);
if (errno == ENOENT) {
ret = wimlib_create_new_wim(compression_type, &dest_w);
if (ret != 0)
- goto done;
+ goto out;
} else {
- imagex_error("Cannot stat file `%s': %m\n",
+ imagex_error_with_errno("Cannot stat file `%s'",
dest_wimfile);
- goto done;
+ ret = -1;
+ goto out;
}
}
image = wimlib_resolve_image(src_w, src_image_num_or_name);
- ret = verify_image_exists(image);
+ ret = verify_image_exists(image, src_image_num_or_name, src_wimfile);
if (ret != 0)
- goto done;
+ goto out;
+
+ if (swm_glob) {
+ ret = open_swms_from_glob(swm_glob, src_wimfile, open_flags,
+ &additional_swms,
+ &num_additional_swms);
+ if (ret != 0)
+ goto out;
+ }
- ret = wimlib_export_image(src_w, image, dest_w, dest_name, dest_desc,
- export_flags);
+ ret = wimlib_export_image(src_w, image, dest_w, dest_name, dest_desc,
+ export_flags, additional_swms,
+ num_additional_swms, imagex_progress_func);
if (ret != 0)
- goto done;
+ goto out;
if (wim_is_new)
- ret = wimlib_write(dest_w, dest_wimfile, WIM_ALL_IMAGES,
- write_flags);
+ ret = wimlib_write(dest_w, dest_wimfile, WIMLIB_ALL_IMAGES,
+ write_flags, num_threads,
+ imagex_progress_func);
else
- ret = wimlib_overwrite(dest_w, write_flags);
-done:
+ ret = wimlib_overwrite(dest_w, write_flags, num_threads,
+ imagex_progress_func);
+out:
+ if (ret == WIMLIB_ERR_REOPEN)
+ ret = 0;
wimlib_free(src_w);
wimlib_free(dest_w);
+ if (additional_swms) {
+ for (unsigned i = 0; i < num_additional_swms; i++)
+ wimlib_free(additional_swms[i]);
+ free(additional_swms);
+ }
return ret;
}
FILE *fp;
int image;
int ret;
+ int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
+ int part_number;
+ int total_parts;
+ int num_images;
for_opt(c, info_options) {
switch (c) {
new_name = argv[2];
if (argc > 3) {
new_desc = argv[3];
- }
+ }
}
}
- ret = wimlib_open_wim(wimfile,
- check ?
- WIMLIB_OPEN_FLAG_CHECK_INTEGRITY |
- WIMLIB_OPEN_FLAG_SHOW_PROGRESS
- : 0,
- &w);
+ if (check)
+ open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+
+ ret = wimlib_open_wim(wimfile, open_flags, &w,
+ imagex_progress_func);
if (ret != 0)
return ret;
+ part_number = wimlib_get_part_number(w, &total_parts);
+
image = wimlib_resolve_image(w, image_num_or_name);
- if (image == WIM_NO_IMAGE && strcmp(image_num_or_name, "0") != 0) {
- imagex_error("The image `%s' does not exist!\n",
- image_num_or_name);
+ if (image == WIMLIB_NO_IMAGE && strcmp(image_num_or_name, "0") != 0) {
+ imagex_error("The image `%s' does not exist",
+ image_num_or_name);
if (boot)
imagex_error("If you would like to set the boot "
- "index to 0, specify image \"0\" with "
- "the --boot flag.\n");
+ "index to 0, specify image \"0\" with "
+ "the --boot flag.");
ret = WIMLIB_ERR_INVALID_IMAGE;
- goto done;
+ goto out;
}
- if (image == WIM_ALL_IMAGES && wimlib_get_num_images(w) > 1) {
+ num_images = wimlib_get_num_images(w);
+
+ if (num_images == 0) {
+ if (boot) {
+ imagex_error("--boot is meaningless on a WIM with no "
+ "images");
+ ret = WIMLIB_ERR_INVALID_IMAGE;
+ goto out;
+ }
+ }
+
+ if (image == WIMLIB_ALL_IMAGES && num_images > 1) {
if (boot) {
imagex_error("Cannot specify the --boot flag "
- "without specifying a specific "
- "image in a multi-image WIM!\n");
+ "without specifying a specific "
+ "image in a multi-image WIM");
ret = WIMLIB_ERR_INVALID_IMAGE;
- goto done;
+ goto out;
}
if (new_name) {
imagex_error("Cannot specify the NEW_NAME "
- "without specifying a specific "
- "image in a multi-image WIM!\n");
+ "without specifying a specific "
+ "image in a multi-image WIM");
ret = WIMLIB_ERR_INVALID_IMAGE;
- goto done;
+ goto out;
}
}
* recreate the WIM file. */
if (!new_name && !boot) {
- if (image == WIM_NO_IMAGE) {
- imagex_error("`%s' is not a valid image!\n",
- image_num_or_name);
+ /* Read-only operations */
+
+ if (image == WIMLIB_NO_IMAGE) {
+ imagex_error("`%s' is not a valid image",
+ image_num_or_name);
ret = WIMLIB_ERR_INVALID_IMAGE;
- goto done;
+ goto out;
}
- if (image == WIM_ALL_IMAGES && short_header)
+ if (image == WIMLIB_ALL_IMAGES && short_header)
wimlib_print_wim_information(w);
if (header)
wimlib_print_header(w);
- if (lookup_table)
+ if (lookup_table) {
+ if (total_parts != 1) {
+ printf("Warning: Only showing the lookup table "
+ "for part %d of a %d-part WIM.\n",
+ part_number, total_parts);
+ }
wimlib_print_lookup_table(w);
+ }
if (xml) {
ret = wimlib_extract_xml_data(w, stdout);
if (ret != 0)
- goto done;
+ goto out;
}
if (xml_out_file) {
fp = fopen(xml_out_file, "wb");
if (!fp) {
- imagex_error("Failed to open the file `%s' for "
- "writing: %m\n", xml_out_file);
- goto done;
+ imagex_error_with_errno("Failed to open the "
+ "file `%s' for "
+ "writing ",
+ xml_out_file);
+ ret = -1;
+ goto out;
}
ret = wimlib_extract_xml_data(w, fp);
if (fclose(fp) != 0) {
- imagex_error("Failed to close the "
- "file `%s': %m\n",
- xml_out_file);
- goto done;
+ imagex_error("Failed to close the file `%s'",
+ xml_out_file);
+ ret = -1;
}
if (ret != 0)
- goto done;
+ goto out;
}
if (short_header)
if (metadata) {
ret = wimlib_print_metadata(w, image);
if (ret != 0)
- goto done;
+ goto out;
}
} else {
- if (image == WIM_ALL_IMAGES)
+
+ /* Modification operations */
+ if (total_parts != 1) {
+ imagex_error("Modifying a split WIM is not supported.");
+ ret = -1;
+ goto out;
+ }
+ if (image == WIMLIB_ALL_IMAGES)
image = 1;
- if (image == WIM_NO_IMAGE && new_name) {
+ if (image == WIMLIB_NO_IMAGE && new_name) {
imagex_error("Cannot specify new_name (`%s') when "
- "using image 0!\n");
- return -1;
+ "using image 0", new_name);
+ ret = -1;
+ goto out;
}
if (boot) {
if (image == wimlib_get_boot_idx(w)) {
printf("Image %d is already marked as "
- "bootable.\n", image);
+ "bootable.\n", image);
boot = false;
} else {
- printf("Marking image %d as bootable.\n",
- image);
+ printf("Marking image %d as bootable.\n",
+ image);
wimlib_set_boot_idx(w, image);
}
}
if (new_name) {
- if (strcmp(wimlib_get_image_name(w, image),
+ if (strcmp(wimlib_get_image_name(w, image),
new_name) == 0) {
printf("Image %d is already named \"%s\".\n",
- image, new_name);
+ image, new_name);
new_name = NULL;
} else {
- printf("Changing the name of image %d to \"%s\".\n",
- image, new_name);
+ printf("Changing the name of image %d to "
+ "\"%s\".\n", image, new_name);
ret = wimlib_set_image_name(w, image, new_name);
if (ret != 0)
- goto done;
+ goto out;
}
}
if (new_desc) {
old_desc = wimlib_get_image_description(w, image);
if (old_desc && strcmp(old_desc, new_desc) == 0) {
printf("The description of image %d is already "
- "\"%s\".\n", image, new_desc);
+ "\"%s\".\n", image, new_desc);
new_desc = NULL;
} else {
printf("Changing the description of image %d "
- "to \"%s\".\n", image, new_desc);
- ret = wimlib_set_image_descripton(w, image,
+ "to \"%s\".\n", image, new_desc);
+ ret = wimlib_set_image_descripton(w, image,
new_desc);
if (ret != 0)
- goto done;
+ goto out;
}
}
- /* Only call wimlib_overwrite_xml_and_header() if something
- * actually needs to be changed. */
- if (boot || new_name || new_desc ||
- check != wimlib_has_integrity_table(w)) {
+ /* Only call wimlib_overwrite() if something actually needs to
+ * be changed. */
+ if (boot || new_name || new_desc ||
+ (check && !wimlib_has_integrity_table(w)))
+ {
+ int write_flags;
+
+ ret = file_writable(wimfile);
+ if (ret != 0)
+ return ret;
- ret = wimlib_overwrite_xml_and_header(w, check ?
- WIMLIB_WRITE_FLAG_CHECK_INTEGRITY |
- WIMLIB_WRITE_FLAG_SHOW_PROGRESS : 0);
+ if (check)
+ write_flags = WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
+ else
+ write_flags = 0;
+
+ ret = wimlib_overwrite(w, write_flags, 1,
+ imagex_progress_func);
+ if (ret == WIMLIB_ERR_REOPEN)
+ ret = 0;
} else {
printf("The file `%s' was not modified because nothing "
- "needed to be done.\n", wimfile);
+ "needed to be done.\n", wimfile);
ret = 0;
}
}
-
-done:
+out:
wimlib_free(w);
return ret;
}
+/* Join split WIMs into one part WIM */
+static int imagex_join(int argc, const char **argv)
+{
+ int c;
+ int swm_open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
+ int wim_write_flags = 0;
+ const char *output_path;
+
+ for_opt(c, join_options) {
+ switch (c) {
+ case 'c':
+ swm_open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+ wim_write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
+ break;
+ default:
+ goto err;
+ }
+ }
+ argc -= optind;
+ argv += optind;
+
+ if (argc < 2) {
+ imagex_error("Must specify one or more split WIM (.swm) parts "
+ "to join");
+ goto err;
+ }
+ output_path = argv[0];
+ return wimlib_join(++argv, --argc, output_path, swm_open_flags,
+ wim_write_flags, imagex_progress_func);
+err:
+ usage(JOIN);
+ return -1;
+}
+
/* Mounts an image using a FUSE mount. */
static int imagex_mount_rw_or_ro(int argc, const char **argv)
{
- bool ro;
int c;
int mount_flags = 0;
- int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
+ int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
const char *wimfile;
const char *dir;
WIMStruct *w;
int image;
int num_images;
int ret;
+ const char *swm_glob = NULL;
+ WIMStruct **additional_swms = NULL;
+ unsigned num_additional_swms = 0;
+ const char *staging_dir = NULL;
if (strcmp(argv[0], "mountrw") == 0)
mount_flags |= WIMLIB_MOUNT_FLAG_READWRITE;
+
for_opt(c, mount_options) {
switch (c) {
+ case 'A':
+ mount_flags |= WIMLIB_MOUNT_FLAG_ALLOW_OTHER;
+ break;
case 'c':
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
break;
case 'd':
mount_flags |= WIMLIB_MOUNT_FLAG_DEBUG;
break;
+ case 's':
+ if (strcasecmp(optarg, "none") == 0)
+ mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_NONE;
+ else if (strcasecmp(optarg, "xattr") == 0)
+ mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR;
+ else if (strcasecmp(optarg, "windows") == 0)
+ mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS;
+ else {
+ imagex_error("Unknown stream interface \"%s\"", optarg);
+ goto mount_usage;
+ }
+ break;
+ case 'r':
+ swm_glob = optarg;
+ break;
+ case 'D':
+ staging_dir = optarg;
+ break;
+ case 'U':
+ mount_flags |= WIMLIB_MOUNT_FLAG_UNIX_DATA;
+ break;
default:
- usage(ro ? MOUNT : MOUNTRW);
- return -1;
+ goto mount_usage;
}
}
argc -= optind;
argv += optind;
- if (argc != 2 && argc != 3) {
- usage(ro ? MOUNT : MOUNTRW);
- return -1;
- }
+ if (argc != 2 && argc != 3)
+ goto mount_usage;
wimfile = argv[0];
- ret = wimlib_open_wim(wimfile, open_flags, &w);
+ ret = wimlib_open_wim(wimfile, open_flags, &w,
+ imagex_progress_func);
if (ret != 0)
return ret;
+ if (swm_glob) {
+ ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
+ &additional_swms,
+ &num_additional_swms);
+ if (ret != 0)
+ goto out;
+ }
+
if (argc == 2) {
image = 1;
num_images = wimlib_get_num_images(w);
if (num_images != 1) {
imagex_error("The file `%s' contains %d images; Please "
- "select one.\n", wimfile, num_images);
- usage(ro ? MOUNT : MOUNTRW);
- ret = WIMLIB_ERR_INVALID_IMAGE;
- goto done;
+ "select one.", wimfile, num_images);
+ usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
+ ? MOUNTRW : MOUNT);
+ ret = -1;
+ goto out;
}
dir = argv[1];
} else {
image = wimlib_resolve_image(w, argv[1]);
dir = argv[2];
+ ret = verify_image_exists_and_is_single(image, argv[1], wimfile);
+ if (ret != 0)
+ goto out;
}
- ret = verify_image_exists_and_is_single(image);
- if (ret != 0)
- goto done;
+ if (mount_flags & WIMLIB_MOUNT_FLAG_READWRITE) {
+ ret = file_writable(wimfile);
+ if (ret != 0)
+ goto out;
+ }
- ret = wimlib_mount(w, image, dir, mount_flags);
+ ret = wimlib_mount_image(w, image, dir, mount_flags, additional_swms,
+ num_additional_swms, staging_dir);
if (ret != 0) {
- imagex_error("Failed to mount image %d from `%s' on `%s'!\n",
- image, wimfile, dir);
+ imagex_error("Failed to mount image %d from `%s' on `%s'",
+ image, wimfile, dir);
+
+ }
+out:
+ wimlib_free(w);
+ if (additional_swms) {
+ for (unsigned i = 0; i < num_additional_swms; i++)
+ wimlib_free(additional_swms[i]);
+ free(additional_swms);
+ }
+ return ret;
+mount_usage:
+ usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
+ ? MOUNTRW : MOUNT);
+ return -1;
+}
+
+static int imagex_optimize(int argc, const char **argv)
+{
+ int c;
+ int open_flags = 0;
+ int write_flags = WIMLIB_WRITE_FLAG_REBUILD;
+ int ret;
+ WIMStruct *w;
+ const char *wimfile;
+ off_t old_size;
+ off_t new_size;
+
+ for_opt(c, optimize_options) {
+ switch (c) {
+ case 'c':
+ open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+ write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
+ break;
+ case 'r':
+ write_flags |= WIMLIB_WRITE_FLAG_RECOMPRESS;
+ break;
+ default:
+ usage(OPTIMIZE);
+ return -1;
+ }
+ }
+ argc -= optind;
+ argv += optind;
+
+ if (argc != 1) {
+ usage(OPTIMIZE);
+ return -1;
+ }
+
+ wimfile = argv[0];
+
+ ret = wimlib_open_wim(wimfile, open_flags, &w,
+ imagex_progress_func);
+ if (ret != 0)
+ return ret;
+
+ old_size = file_get_size(argv[0]);
+ printf("`%s' original size: ", wimfile);
+ if (old_size == -1)
+ puts("Unknown");
+ else
+ printf("%"PRIu64" KiB\n", old_size >> 10);
+
+ ret = wimlib_overwrite(w, write_flags, 0, imagex_progress_func);
+
+ if (ret == 0) {
+ new_size = file_get_size(argv[0]);
+ printf("`%s' optimized size: ", wimfile);
+ if (new_size == -1)
+ puts("Unknown");
+ else
+ printf("%"PRIu64" KiB\n", new_size >> 10);
+
+ fputs("Space saved: ", stdout);
+ if (new_size != -1 && old_size != -1) {
+ printf("%lld KiB\n",
+ ((long long)old_size - (long long)new_size) >> 10);
+ } else {
+ puts("Unknown");
+ }
+ }
+
+ wimlib_free(w);
+ return ret;
+}
+
+/* Split a WIM into a spanned set */
+static int imagex_split(int argc, const char **argv)
+{
+ int c;
+ int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
+ int write_flags = 0;
+ unsigned long part_size;
+ char *tmp;
+ int ret;
+ WIMStruct *w;
+
+ for_opt(c, split_options) {
+ switch (c) {
+ case 'c':
+ open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+ write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
+ break;
+ default:
+ usage(SPLIT);
+ return -1;
+ }
+ }
+ argc -= optind;
+ argv += optind;
+ if (argc != 3) {
+ usage(SPLIT);
+ return -1;
+ }
+ part_size = strtod(argv[2], &tmp) * (1 << 20);
+ if (tmp == argv[2] || *tmp) {
+ imagex_error("Invalid part size \"%s\"", argv[2]);
+ imagex_error("The part size must be an integer or floating-point number of megabytes.");
+ return -1;
}
-done:
+ ret = wimlib_open_wim(argv[0], open_flags, &w, imagex_progress_func);
+ if (ret != 0)
+ return ret;
+ ret = wimlib_split(w, argv[1], part_size, write_flags, imagex_progress_func);
wimlib_free(w);
return ret;
}
case 'C':
unmount_flags |= WIMLIB_UNMOUNT_FLAG_CHECK_INTEGRITY;
break;
+ case 'R':
+ unmount_flags |= WIMLIB_UNMOUNT_FLAG_REBUILD;
+ break;
default:
usage(UNMOUNT);
return -1;
return -1;
}
- ret = wimlib_unmount(argv[0], unmount_flags);
+ ret = wimlib_unmount_image(argv[0], unmount_flags,
+ imagex_progress_func);
if (ret != 0)
- imagex_error("Failed to unmount `%s'!\n", argv[0]);
+ imagex_error("Failed to unmount `%s'", argv[0]);
return ret;
}
int cmd;
};
-static struct imagex_command imagex_commands[] = {
- {"append", imagex_append, APPEND},
- {"apply", imagex_apply, APPLY},
- {"capture", imagex_capture, CAPTURE},
- {"delete", imagex_delete, DELETE},
- {"dir", imagex_dir, DIR},
- {"export", imagex_export, EXPORT},
- {"info", imagex_info, INFO},
- {"mount", imagex_mount_rw_or_ro, MOUNT},
- {"mountrw", imagex_mount_rw_or_ro, MOUNTRW},
- {"unmount", imagex_unmount, UNMOUNT},
-};
#define for_imagex_command(p) for (p = &imagex_commands[0]; \
p != &imagex_commands[ARRAY_LEN(imagex_commands)]; p++)
+static const struct imagex_command imagex_commands[] = {
+ {"append", imagex_capture_or_append, APPEND},
+ {"apply", imagex_apply, APPLY},
+ {"capture", imagex_capture_or_append, CAPTURE},
+ {"delete", imagex_delete, DELETE},
+ {"dir", imagex_dir, DIR},
+ {"export", imagex_export, EXPORT},
+ {"info", imagex_info, INFO},
+ {"join", imagex_join, JOIN},
+ {"mount", imagex_mount_rw_or_ro, MOUNT},
+ {"mountrw", imagex_mount_rw_or_ro, MOUNTRW},
+ {"optimize",imagex_optimize, OPTIMIZE},
+ {"split", imagex_split, SPLIT},
+ {"unmount", imagex_unmount, UNMOUNT},
+};
+
+static void version()
+{
+ static const char *s =
+ "imagex (" PACKAGE ") " PACKAGE_VERSION "\n"
+ "Copyright (C) 2012 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"
+ "\n"
+ "Report bugs to "PACKAGE_BUGREPORT".\n";
+ fputs(s, stdout);
+}
+
+
static void help_or_version(int argc, const char **argv)
{
int i;
const char *p;
- struct imagex_command *cmd;
+ const struct imagex_command *cmd;
for (i = 1; i < argc; i++) {
p = argv[i];
continue;
if (*p == '-')
p++;
- if (strcmp(p, "help") == 0 || (*p == '?' && *(p + 1) == '\0')) {
+ if (strcmp(p, "help") == 0) {
for_imagex_command(cmd) {
if (strcmp(cmd->name, argv[1]) == 0) {
usage(cmd->cmd);
}
+static void usage(int cmd_type)
+{
+ const struct imagex_command *cmd;
+ printf("Usage: %s", usage_strings[cmd_type]);
+ for_imagex_command(cmd) {
+ if (cmd->cmd == cmd_type)
+ printf("\nTry `man imagex-%s' for more details.\n",
+ cmd->name);
+ }
+}
+
+static void usage_all()
+{
+ puts("IMAGEX: Usage:");
+ for (int i = 0; i < ARRAY_LEN(usage_strings); i++)
+ printf(" %s", usage_strings[i]);
+ static const char *extra =
+" imagex --help\n"
+" imagex --version\n"
+"\n"
+" The compression TYPE may be \"maximum\", \"fast\", or \"none\".\n"
+"\n"
+" Try `man imagex' for more information.\n"
+ ;
+ fputs(extra, stdout);
+}
+
+
int main(int argc, const char **argv)
{
- struct imagex_command *cmd;
+ const struct imagex_command *cmd;
int ret;
if (argc < 2) {
- imagex_error("No command specified!\n");
+ imagex_error("No command specified");
usage_all();
return 1;
}
argv++;
wimlib_set_print_errors(true);
+ ret = wimlib_global_init();
+ if (ret)
+ goto out;
for_imagex_command(cmd) {
if (strcmp(cmd->name, *argv) == 0) {
ret = cmd->func(argc, argv);
- if (ret > 0) {
- imagex_error("Exiting with error code %d:\n"
- " %s.\n", ret,
- wimlib_get_error_string(ret));
- }
- return ret;
+ goto out;
}
}
- imagex_error("Unrecognized command: `%s'\n", argv[0]);
+ imagex_error("Unrecognized command: `%s'", argv[0]);
usage_all();
return 1;
+out:
+ if (ret > 0) {
+ imagex_error("Exiting with error code %d:\n"
+ " %s.", ret,
+ wimlib_get_error_string(ret));
+ if (ret == WIMLIB_ERR_NTFS_3G && errno != 0)
+ imagex_error_with_errno("errno");
+ }
+ wimlib_global_cleanup();
+ return ret;
}
git://wimlib.net / wimlib / blobdiff