#include <getopt.h>
#include <stdlib.h>
#include <stdarg.h>
+#include <glob.h>
#include <string.h>
#include <errno.h>
+#include <libgen.h>
#include <sys/stat.h>
-#ifdef WITH_NTFS_3G
-#include <unistd.h>
-#include <sys/wait.h>
-#endif
-
#define ARRAY_LEN(array) (sizeof(array) / sizeof(array[0]))
#define swap(a, b) ({ typeof(a) __a = (a); typeof(b) __b = (b); \
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] [--flags EDITIONID] [--dereference]\n",
+" imagex append (DIRECTORY | NTFS_VOLUME) WIMFILE [IMAGE_NAME]\n"
+" [DESCRIPTION] [--boot] [--check] [--flags EDITION_ID]\n"
+" [--verbose] [--dereference] [--config=FILE]\n",
[APPLY] =
-" imagex apply WIMFILE [IMAGE_NUM | IMAGE_NAME | all] DIRECTORY [--check]\n"
-" [--hardlink] [--symlink] [--verbose]\n",
+" imagex apply WIMFILE [IMAGE_NUM | IMAGE_NAME | all]\n"
+" (DIRECTORY | NTFS_VOLUME) [--check] [--hardlink]\n"
+" [--symlink] [--verbose] [--ref=\"GLOB\"]\n",
[CAPTURE] =
-" imagex capture DIRECTORY WIMFILE [\"IMAGE_NAME\"] [\"DESCRIPTION\"]\n"
-" l [--boot] [--check] [--compress[=TYPE]]\n"
-" [--flags \"EditionID\"] [--verbose] [--dereference]\n",
+" imagex capture (DIRECTORY | NTFS_VOLUME) WIMFILE [IMAGE_NAME]\n"
+" [DESCRIPTION] [--boot] [--check] [--compress=TYPE]\n"
+" [--flags EDITION_ID] [--verbose] [--dereference]\n"
+" [--config=FILE]\n",
[DELETE] =
" imagex delete WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--check]\n",
[DIR] =
-" imagex dir WIMFILE (IMAGE_NUM | IMAGE_NAME | \"all\")\n",
+" 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",
+" DEST_WIMFILE [DEST_IMAGE_NAME]\n"
+" [DEST_IMAGE_DESCRIPTION] [--boot] [--check]\n"
+" [--compress=TYPE] [--ref=\"GLOB\"]\n",
[INFO] =
" imagex info WIMFILE [IMAGE_NUM | IMAGE_NAME] [NEW_NAME]\n"
" [NEW_DESC] [--boot] [--check] [--header] [--lookup-table]\n"
" imagex join [--check] WIMFILE SPLIT_WIM...\n",
[MOUNT] =
" imagex mount WIMFILE (IMAGE_NUM | IMAGE_NAME) DIRECTORY\n"
-" [--check] [--debug] [--stream-interface=INTERFACE]\n",
+" [--check] [--debug] [--streams-interface=INTERFACE]\n"
+" [--ref=\"GLOB\"]\n",
[MOUNTRW] =
" imagex mountrw WIMFILE [IMAGE_NUM | IMAGE_NAME] DIRECTORY\n"
-" [--check] [--debug] [--stream-interface=INTERFACE]\n",
+" [--check] [--debug] [--streams-interface=INTERFACE]\n",
[SPLIT] =
-" imagex split WIMFILE SPLIT_WIMFILE PART_SIZE [--check]\n",
+" imagex split WIMFILE SPLIT_WIMFILE PART_SIZE_MB [--check]\n",
[UNMOUNT] =
" imagex unmount DIRECTORY [--commit] [--check]\n",
};
{NULL, 0, NULL, 0},
};
-static const struct option append_options[] = {
- {"boot", no_argument, NULL, 'b'},
- {"check", no_argument, NULL, 'c'},
- {"flags", required_argument, NULL, 'f'},
- {"dereference", no_argument, NULL, 'L'},
- {NULL, 0, NULL, 0},
-};
static const struct option apply_options[] = {
{"check", no_argument, NULL, 'c'},
{"hardlink", no_argument, NULL, 'h'},
{"symlink", no_argument, NULL, 's'},
{"verbose", no_argument, NULL, 'v'},
- {"mkntfs-args", required_argument, NULL, 'm'},
+ {"ref", required_argument, NULL, 'r'},
{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'},
- {"flags", required_argument, NULL, 'f'},
- {"verbose", no_argument, NULL,'v'},
- {"dereference", no_argument, NULL, 'L'},
+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'},
{NULL, 0, NULL, 0},
};
static const struct option delete_options[] = {
};
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'},
{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 mount_options[] = {
{"check", no_argument, NULL, 'c'},
{"debug", no_argument, NULL, 'd'},
- {"stream-interface", required_argument, NULL, 's'},
+ {"streams-interface", required_argument, NULL, 's'},
+ {"ref", required_argument, NULL, 'r'},
{NULL, 0, NULL, 0},
};
};
+
/* Print formatted error message to stderr. */
static void imagex_error(const char *format, ...)
{
va_end(va);
}
-
-static inline void version()
+static const char *path_basename(const char *path)
{
- 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);
-}
+ const char *p = path;
+ while (*p)
+ p++;
+ p--;
-static inline void usage(int cmd)
-{
- puts("IMAGEX: Usage:");
- fputs(usage_strings[cmd], stdout);
-}
+ /* Trailing slashes. */
+ while ((p != path - 1) && *p == '/')
+ p--;
-static void usage_all()
-{
- 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);
+ while ((p != path - 1) && *p != '/')
+ p--;
+
+ return p + 1;
}
+
static int verify_image_exists(int image)
{
if (image == WIM_NO_IMAGE) {
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;
else if (strcasecmp(optarg, "fast") == 0 || strcasecmp(optarg, "xpress") == 0)
}
}
-static int imagex_append(int argc, const char **argv)
+static char *file_get_contents(const char *filename, size_t *len_ret)
{
- 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 stbuf;
+ char *buf;
+ size_t len;
+ FILE *fp;
- 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 'f':
- flags_element = optarg;
- break;
- case 'L':
- add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
- break;
- default:
- usage(APPEND);
- return -1;
- }
+ 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);
- if (ret != 0)
- goto done;
- ret = wimlib_overwrite(w, write_flags);
-done:
- wimlib_free(w);
+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;
+ }
+ size_t offset = 0;
+ for (size_t 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]);
+ 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;
}
+
/* 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 open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
+ int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS |
+ WIMLIB_OPEN_FLAG_SPLIT_OK;
int image;
int num_images;
WIMStruct *w;
const char *wimfile;
const char *dir;
const char *image_num_or_name;
- const char *mkntfs_args = "";
int extract_flags = 0;
+ const char *swm_glob = NULL;
+ WIMStruct **additional_swms = NULL;
+ unsigned num_additional_swms = 0;
for_opt(c, apply_options) {
switch (c) {
case 'v':
extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
break;
- case 'm':
- mkntfs_args = optarg;
+ case 'r':
+ swm_glob = optarg;
break;
default:
usage(APPLY);
dir = argv[2];
}
-#ifdef WITH_NTFS_3G
- char tmpdir[strlen(dir) + 50];
- tmpdir[0] = '\0';
-#endif
-
ret = wimlib_open_wim(wimfile, open_flags, &w);
if (ret != 0)
- goto out;
+ return ret;
image = wimlib_resolve_image(w, image_num_or_name);
ret = verify_image_exists(image);
goto out;
}
+ if (swm_glob) {
+ ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
+ &additional_swms,
+ &num_additional_swms);
+ if (ret != 0)
+ goto out;
+ }
+
#ifdef WITH_NTFS_3G
- /* Check to see if a block device file or regular file was specified.
- * If so, try to create a NTFS filesystem on it, mount it on a temporary
- * directory, and replace @dir with the name of the temporary directory
- * so that we extract the files to the NTFS filesystem. */
struct stat stbuf;
ret = stat(dir, &stbuf);
- if (ret != 0)
- imagex_error_with_errno("Failed to stat `%s'", dir);
- if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode)) {
- extract_flags |= WIMLIB_EXTRACT_FLAG_NTFS;
-
- const char *dev = dir;
- printf("Making NTFS filesystem on `%s'\n", dev);
-
- char mkntfs_cmdline[sizeof("mkntfs ") + strlen(mkntfs_args) +
- sizeof(" ") + strlen(dev)];
- sprintf(mkntfs_cmdline, "mkntfs %s %s", mkntfs_args, dev);
- puts(mkntfs_cmdline);
- ret = system(mkntfs_cmdline);
- if (ret == -1) {
- imagex_error_with_errno("Failed to execute the "
- "`mkntfs' program");
- return -1;
- } else if (ret > 0) {
- imagex_error("`mkntfs' exited with failure status");
- imagex_error("Note: You can pass additional arguments "
- "to `mkntfs' using the --mkntfs-args "
- "argument");
- return -1;
- }
- sprintf(tmpdir, "/tmp/imagex-%d-ntfsmount-%s-XXXXXX",
- getpid(), dev);
- dir = mkdtemp(tmpdir);
- if (!dir) {
- imagex_error_with_errno("Failed to create "
- "temporary directory "
- "`%s'", tmpdir);
- }
- char ntfs_3g_cmdline[sizeof("ntfs-3g ") + strlen(dev) +
- sizeof(" ") + strlen(dir)];
- sprintf(ntfs_3g_cmdline, "ntfs-3g %s %s", dev, dir);
- puts(ntfs_3g_cmdline);
- ret = system(ntfs_3g_cmdline);
- if (ret == -1) {
- imagex_error_with_errno("Failed to execute the "
- "`ntfs-3g' program");
- ret = -1;
- goto out;
- } else if (ret > 0) {
- imagex_error("`ntfs-3g' exited with failure status");
- ret = -1;
+ if (ret == 0) {
+ if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode)) {
+ const char *ntfs_device = dir;
+ printf("Applying image %d of `%s' to NTFS filesystem on `%s'\n",
+ image, wimfile, ntfs_device);
+ ret = wimlib_apply_image_to_ntfs_volume(w, image,
+ ntfs_device,
+ extract_flags,
+ additional_swms,
+ num_additional_swms);
goto out;
}
- printf("Applying image %d of `%s' to NTFS filesystem on `%s'\n",
- image, wimfile, dev);
+ } else {
+ if (errno != ENOENT)
+ imagex_error_with_errno("Failed to stat `%s'", dir);
}
#endif
- ret = wimlib_extract_image(w, image, dir, extract_flags);
+ ret = wimlib_extract_image(w, image, dir, extract_flags,
+ additional_swms, num_additional_swms);
out:
wimlib_free(w);
-#ifdef WITH_NTFS_3G
- if (tmpdir[0] != '\0') {
- /* Unmount and remove the NTFS-3g mounted directory */
-
- int pid = fork();
- int status;
- if (pid == -1) {
- imagex_error_with_errno("Failed to fork()");
- return -1;
- }
- if (pid == 0) {
- execlp("fusermount", "fusermount", "-u", dir, NULL);
- imagex_error_with_errno("Failed to execute `fusermount'");
- return -1;
- }
-
- if (waitpid(pid, &status, 0) == -1) {
- imagex_error_with_errno("Failed to wait for "
- "fusermount process to "
- "terminate");
- return -1;
- }
-
- if (status != 0) {
- imagex_error("fusermount exited with status %d",
- status);
- return -1;
- }
- if (rmdir(tmpdir) != 0) {
- imagex_error_with_errno("Failed to remove temporary "
- "directory `%s'", tmpdir);
- }
- }
-#endif
+ if (additional_swms)
+ for (size_t i = 0; i < num_additional_swms; i++)
+ wimlib_free(additional_swms[i]);
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 = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
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;
+ int compression_type = WIM_COMPRESSION_TYPE_XPRESS;
const char *dir;
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;
- 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)
case 'f':
flags_element = optarg;
break;
- case 'v':
- add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
- break;
- case 'N':
- add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_NTFS;
- break;
case 'L':
add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
break;
+ case 'v':
+ add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
+ 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];
wimfile = argv[1];
- name = (argc >= 3) ? argv[2] : dir;
+
+ char dir_copy[strlen(dir) + 1];
+ memcpy(dir_copy, dir, strlen(dir) + 1);
+ default_name = basename(dir_copy);
+
+ name = (argc >= 3) ? argv[2] : default_name;
desc = (argc >= 4) ? argv[3] : NULL;
- ret = wimlib_create_new_wim(compression_type, &w);
+ 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);
+ else
+ ret = wimlib_create_new_wim(compression_type, &w);
if (ret != 0)
- return ret;
+ goto out;
- ret = wimlib_add_image(w, dir, name, desc, flags_element,
- add_image_flags);
- if (ret != 0) {
- imagex_error("Failed to add the image `%s'", dir);
- goto done;
+#ifdef WITH_NTFS_3G
+ struct stat stbuf;
+
+ ret = stat(dir, &stbuf);
+ if (ret == 0) {
+ if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode)) {
+ const char *ntfs_device = dir;
+ printf("Capturing WIM image NTFS filesystem on `%s'\n",
+ ntfs_device);
+ ret = wimlib_add_image_from_ntfs_volume(w, ntfs_device,
+ name,
+ config_str,
+ config_len,
+ add_image_flags);
+ goto out_write;
+ }
+ } else {
+ if (errno != ENOENT) {
+ imagex_error_with_errno("Failed to stat `%s'", dir);
+ ret = -1;
+ goto out;
+ }
}
+#endif
+ ret = wimlib_add_image(w, dir, name, config_str, config_len,
+ add_image_flags);
- ret = wimlib_write(w, wimfile, WIM_ALL_IMAGES, write_flags);
+out_write:
+ if (ret != 0)
+ 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);
+ else
+ ret = wimlib_write(w, wimfile, WIM_ALL_IMAGES, write_flags);
if (ret != 0)
imagex_error("Failed to write the WIM file `%s'", wimfile);
-done:
+out:
wimlib_free(w);
+ free(config_str);
return ret;
}
int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
int export_flags = 0;
int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
- int compression_type = WIM_COMPRESSION_TYPE_NONE;
+ int compression_type = WIM_COMPRESSION_TYPE_XPRESS;
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;
for_opt(c, export_options) {
switch (c) {
return -1;
compression_type_specified = true;
break;
+ case 'r':
+ swm_glob = optarg;
+ 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);
if (ret != 0)
return ret;
if (stat(dest_wimfile, &stbuf) == 0) {
wim_is_new = false;
/* Destination file exists. */
- if (!S_ISREG(stbuf.st_mode)) {
+ if (!S_ISREG(stbuf.st_mode) && !S_ISLNK(stbuf.st_mode)) {
imagex_error("`%s' is not a regular file",
dest_wimfile);
- goto done;
+ goto out;
}
ret = wimlib_open_wim(dest_wimfile, open_flags, &dest_w);
if (ret != 0)
- goto done;
+ goto out;
if (compression_type_specified && compression_type !=
wimlib_get_compression_type(dest_w)) {
"not the same as that used in the "
"destination WIM");
ret = -1;
- goto done;
+ goto out;
}
compression_type = wimlib_get_compression_type(dest_w);
} else {
if (errno == ENOENT) {
ret = wimlib_create_new_wim(compression_type, &dest_w);
if (ret != 0)
- goto done;
+ goto out;
} else {
imagex_error_with_errno("Cannot stat file `%s'",
dest_wimfile);
- goto done;
+ goto out;
}
}
image = wimlib_resolve_image(src_w, src_image_num_or_name);
ret = verify_image_exists(image);
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);
+ export_flags, additional_swms,
+ num_additional_swms);
if (ret != 0)
- goto done;
+ goto out;
if (wim_is_new)
write_flags);
else
ret = wimlib_overwrite(dest_w, write_flags);
-done:
+out:
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]);
return ret;
}
wimlib_print_available_images(w, image);
if (metadata) {
- if (total_parts != 1 && part_number != 1) {
- imagex_error("Select part 1 of this %d-part WIM "
- "to see the image metadata",
- total_parts);
- return WIMLIB_ERR_SPLIT_UNSUPPORTED;
- }
ret = wimlib_print_metadata(w, image);
if (ret != 0)
goto done;
{
int c;
int mount_flags = 0;
- int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
+ int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS |
+ 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;
if (strcmp(argv[0], "mountrw") == 0)
mount_flags |= WIMLIB_MOUNT_FLAG_READWRITE;
goto mount_usage;
}
break;
+ case 'r':
+ swm_glob = optarg;
+ break;
default:
goto mount_usage;
}
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);
usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
? MOUNTRW : MOUNT);
ret = WIMLIB_ERR_INVALID_IMAGE;
- goto done;
+ goto out;
}
dir = argv[1];
} else {
ret = verify_image_exists_and_is_single(image);
if (ret != 0)
- goto done;
+ goto out;
- ret = wimlib_mount(w, image, dir, mount_flags);
+ ret = wimlib_mount(w, image, dir, mount_flags, additional_swms,
+ num_additional_swms);
if (ret != 0) {
imagex_error("Failed to mount image %d from `%s' on `%s'",
image, wimfile, dir);
}
-done:
+out:
wimlib_free(w);
+ if (additional_swms)
+ for (unsigned i = 0; i < num_additional_swms; i++)
+ wimlib_free(additional_swms[i]);
return ret;
mount_usage:
usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
int cmd;
};
+
+#define for_imagex_command(p) for (p = &imagex_commands[0]; \
+ p != &imagex_commands[ARRAY_LEN(imagex_commands)]; p++)
+
static struct imagex_command imagex_commands[] = {
- {"append", imagex_append, APPEND},
+ {"append", imagex_capture_or_append, APPEND},
{"apply", imagex_apply, APPLY},
- {"capture", imagex_capture, CAPTURE},
+ {"capture", imagex_capture_or_append, CAPTURE},
{"delete", imagex_delete, DELETE},
{"dir", imagex_dir, DIR},
{"export", imagex_export, EXPORT},
{"unmount", imagex_unmount, UNMOUNT},
};
-#define for_imagex_command(p) for (p = &imagex_commands[0]; \
- p != &imagex_commands[ARRAY_LEN(imagex_commands)]; p++)
+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)
{
}
+static void usage(int cmd_type)
+{
+ struct imagex_command *cmd;
+ puts("IMAGEX: Usage:");
+ fputs(usage_strings[cmd_type], stdout);
+ 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++)
+ 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"
+"\n"
+" Try `man imagex' for more information.\n"
+ ;
+ fputs(extra, stdout);
+}
+
+
int main(int argc, const char **argv)
{
struct imagex_command *cmd;
usage_all();
return 1;
}
-/*#ifndef WITH_NTFS_3G*/
- /*ERROR("wimlib was not compiled with support for NTFS-3g, so we cannot extract");*/
- /*ERROR("a WIM to a NTFS filesystem while preserving NTFS-specific metadata.");*/
- /*ERROR("Please apply the WIM to a directory rather than a block device, ");*/
- /*ERROR("and without the NTFS flag; or compile in support for NTFS-3g.");*/
- /*return WIMLIB_ERR_UNSUPPORTED;*/
-/*#endif*/