* 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 <stdarg.h>
#include <glob.h>
-#include <string.h>
-#include <errno.h>
+#include <inttypes.h>
#include <libgen.h>
#include <limits.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#define for_opt(c, opts) while ((c = getopt_long_only(argc, (char**)argv, "", \
opts, NULL)) != -1)
-
enum imagex_op_type {
APPEND,
APPLY,
JOIN,
MOUNT,
MOUNTRW,
+ OPTIMIZE,
SPLIT,
UNMOUNT,
};
"imagex append (DIRECTORY | NTFS_VOLUME) WIMFILE [IMAGE_NAME]\n"
" [DESCRIPTION] [--boot] [--check] [--flags EDITION_ID]\n"
" [--verbose] [--dereference] [--config=FILE]\n"
-" [--threads=NUM_THREADS]\n",
+" [--threads=NUM_THREADS] [--rebuild]\n",
[APPLY] =
"imagex apply WIMFILE [IMAGE_NUM | IMAGE_NAME | all]\n"
" (DIRECTORY | NTFS_VOLUME) [--check] [--hardlink]\n"
" [--flags EDITION_ID] [--verbose] [--dereference]\n"
" [--config=FILE] [--threads=NUM_THREADS]\n",
[DELETE] =
-"imagex delete WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--check]\n",
+"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]\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"
" [--ref=\"GLOB\"]\n",
[MOUNTRW] =
"imagex mountrw WIMFILE [IMAGE_NUM | IMAGE_NAME] DIRECTORY\n"
-" [--check] [--debug] [--streams-interface=INTERFACE]\n",
+" [--check] [--debug] [--streams-interface=INTERFACE]\n"
+" [--staging-dir=DIR]\n",
+[OPTIMIZE] =
+"imagex optimize WIMFILE [--check] [--recompress]\n",
[SPLIT] =
"imagex split WIMFILE SPLIT_WIMFILE PART_SIZE_MB [--check]\n",
[UNMOUNT] =
{"flags", required_argument, NULL, 'f'},
{"verbose", no_argument, NULL, 'v'},
{"threads", required_argument, NULL, 't'},
+ {"rebuild", no_argument, NULL, 'R'},
{NULL, 0, NULL, 0},
};
static const struct option delete_options[] = {
{"check", no_argument, NULL, 'c'},
+ {"soft", no_argument, NULL, 's'},
{NULL, 0, NULL, 0},
};
{"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 mount_options[] = {
- {"check", no_argument, NULL, 'c'},
- {"debug", no_argument, NULL, 'd'},
+ {"check", no_argument, NULL, 'c'},
+ {"debug", no_argument, NULL, 'd'},
{"streams-interface", required_argument, NULL, 's'},
- {"ref", required_argument, NULL, 'r'},
+ {"ref", required_argument, NULL, 'r'},
+ {"staging-dir", required_argument, NULL, 'D'},
+ {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 int verify_image_exists(int image, const char *image_name,
const char *wim_name)
{
- if (image == WIM_NO_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"
static int verify_image_is_single(int image)
{
- if (image == WIM_ALL_IMAGES) {
+ if (image == WIMLIB_ALL_IMAGES) {
imagex_error("Cannot specify all images for this action!");
return -1;
}
static int get_compression_type(const char *optarg)
{
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\".", optarg);
- return WIM_COMPRESSION_TYPE_INVALID;
+ return WIMLIB_COMPRESSION_TYPE_INVALID;
}
}
+static off_t file_get_size(const char *filename)
+{
+ struct stat st;
+ if (stat(filename, &st) == 0)
+ return st.st_size;
+ else
+ return (off_t)-1;
+}
+
static char *file_get_contents(const char *filename, size_t *len_ret)
{
struct stat stbuf;
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) to `%s'\n",*/
+ /*info->extract.image,*/
+ /*info->extract.image_name,*/
+ /*info->extract.target);*/
+ break;
+ /*case WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END:*/
+ /*printf("Done applying image %d!\n",*/
+ /*info->extract.image);*/
+ /*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_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,
}
ret = wimlib_open_wim(globbuf.gl_pathv[i],
open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK,
- &additional_swms[i - offset]);
+ &additional_swms[i - offset],
+ imagex_progress_func);
if (ret != 0)
goto out_close_swms;
}
static int imagex_apply(int argc, const char **argv)
{
int c;
- int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS |
- WIMLIB_OPEN_FLAG_SPLIT_OK;
+ 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 = 0;
+ int extract_flags = WIMLIB_EXTRACT_FLAG_SEQUENTIAL;
const char *swm_glob = NULL;
WIMStruct **additional_swms = NULL;
wimfile = argv[0];
if (argc == 2) {
image_num_or_name = "1";
- dir = argv[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;
goto out;
}
-#ifdef WITH_NTFS_3G
struct stat stbuf;
- ret = stat(dir, &stbuf);
+ ret = stat(target, &stbuf);
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;
+ extract_flags |= WIMLIB_EXTRACT_FLAG_NTFS;
+ printf("Applying `%s' image %d to NTFS volume `%s'\n",
+ wimfile, image, target);
}
} else {
if (errno != ENOENT) {
- imagex_error_with_errno("Failed to stat `%s'", dir);
+ imagex_error_with_errno("Failed to stat `%s'", target);
ret = -1;
goto out;
}
}
-#endif
- ret = wimlib_extract_image(w, image, dir, extract_flags,
- additional_swms, num_additional_swms);
+ ret = wimlib_extract_image(w, image, target, extract_flags,
+ additional_swms, num_additional_swms,
+ imagex_progress_func);
out:
wimlib_free(w);
if (additional_swms) {
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 = WIMLIB_ADD_IMAGE_FLAG_SHOW_PROGRESS;
- int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
- int compression_type = WIM_COMPRESSION_TYPE_XPRESS;
- const char *dir;
+ int open_flags = 0;
+ int add_image_flags = 0;
+ int write_flags = 0;
+ int compression_type = WIMLIB_COMPRESSION_TYPE_XPRESS;
+ const char *source;
const char *wimfile;
const char *name;
const char *desc;
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 'f':
break;
case 'v':
add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
- write_flags |= WIMLIB_WRITE_FLAG_VERBOSE;
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(cmd);
return -1;
usage(cmd);
return -1;
}
- dir = argv[0];
+ source = argv[0];
wimfile = argv[1];
- char dir_copy[strlen(dir) + 1];
- memcpy(dir_copy, dir, strlen(dir) + 1);
- default_name = basename(dir_copy);
+ 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 (cmd == APPEND)
- ret = wimlib_open_wim(wimfile, open_flags, &w);
+ ret = wimlib_open_wim(wimfile, open_flags, &w,
+ imagex_progress_func);
else
ret = wimlib_create_new_wim(compression_type, &w);
if (ret != 0)
goto out;
-#ifdef WITH_NTFS_3G
struct stat stbuf;
- ret = stat(dir, &stbuf);
+ ret = stat(source, &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;
+ 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'", dir);
+ imagex_error_with_errno("Failed to stat `%s'", source);
ret = -1;
goto out;
}
}
-#endif
- ret = wimlib_add_image(w, dir, name, config_str, config_len,
- add_image_flags);
-out_write:
+ ret = wimlib_add_image(w, source, name, config_str, config_len,
+ add_image_flags, imagex_progress_func);
+
if (ret != 0)
goto out;
cur_image = wimlib_get_num_images(w);
goto out;
}
if (cmd == APPEND) {
- ret = wimlib_overwrite(w, write_flags, num_threads);
+ ret = wimlib_overwrite(w, write_flags, num_threads,
+ imagex_progress_func);
} else {
- ret = wimlib_write(w, wimfile, WIM_ALL_IMAGES, write_flags,
- num_threads);
+ ret = wimlib_write(w, wimfile, WIMLIB_ALL_IMAGES, write_flags,
+ num_threads, imagex_progress_func);
}
if (ret == WIMLIB_ERR_REOPEN)
ret = 0;
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 (ret != 0)
return ret;
- ret = wimlib_open_wim(wimfile, open_flags, &w);
+ ret = wimlib_open_wim(wimfile, open_flags, &w,
+ imagex_progress_func);
if (ret != 0)
return ret;
goto out;
}
- ret = wimlib_overwrite(w, write_flags, 0);
+ ret = wimlib_overwrite(w, write_flags, 0, imagex_progress_func);
if (ret == WIMLIB_ERR_REOPEN)
ret = 0;
if (ret != 0) {
}
wimfile = argv[1];
- ret = wimlib_open_wim(wimfile, WIMLIB_OPEN_FLAG_SPLIT_OK, &w);
+ ret = wimlib_open_wim(wimfile, WIMLIB_OPEN_FLAG_SPLIT_OK, &w,
+ imagex_progress_func);
if (ret != 0)
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;
+ 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;
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;
if (num_threads == UINT_MAX)
return -1;
break;
+ case 'R':
+ write_flags |= WIMLIB_WRITE_FLAG_REBUILD;
+ break;
default:
usage(EXPORT);
return -1;
dest_name = (argc >= 4) ? argv[3] : NULL;
dest_desc = (argc >= 5) ? argv[4] : NULL;
ret = wimlib_open_wim(src_wimfile,
- open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK, &src_w);
+ open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK, &src_w,
+ imagex_progress_func);
if (ret != 0)
return ret;
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 out;
ret = wimlib_export_image(src_w, image, dest_w, dest_name, dest_desc,
export_flags, additional_swms,
- num_additional_swms);
+ num_additional_swms, imagex_progress_func);
if (ret != 0)
goto out;
if (wim_is_new)
- ret = wimlib_write(dest_w, dest_wimfile, WIM_ALL_IMAGES,
- write_flags, num_threads);
+ 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, num_threads);
+ ret = wimlib_overwrite(dest_w, write_flags, num_threads,
+ imagex_progress_func);
out:
if (ret == WIMLIB_ERR_REOPEN)
ret = 0;
FILE *fp;
int image;
int ret;
- int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS |
- WIMLIB_OPEN_FLAG_SPLIT_OK;
+ int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
int part_number;
int total_parts;
if (check)
open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
- ret = wimlib_open_wim(wimfile, open_flags, &w);
+ 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) {
+ 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)
goto out;
}
- if (image == WIM_ALL_IMAGES && wimlib_get_num_images(w) > 1) {
+ if (image == WIMLIB_ALL_IMAGES && wimlib_get_num_images(w) > 1) {
if (boot) {
imagex_error("Cannot specify the --boot flag "
"without specifying a specific "
/* Read-only operations */
- if (image == WIM_NO_IMAGE) {
+ if (image == WIMLIB_NO_IMAGE) {
imagex_error("`%s' is not a valid image",
image_num_or_name);
ret = WIMLIB_ERR_INVALID_IMAGE;
goto out;
}
- if (image == WIM_ALL_IMAGES && short_header)
+ if (image == WIMLIB_ALL_IMAGES && short_header)
wimlib_print_wim_information(w);
if (header)
imagex_error("Modifying a split WIM is not supported.");
return -1;
}
- if (image == WIM_ALL_IMAGES)
+ 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", new_name);
return -1;
int write_flags;
if (check) {
- write_flags = WIMLIB_WRITE_FLAG_CHECK_INTEGRITY |
- WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
+ write_flags = WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
} else {
write_flags = 0;
}
- ret = wimlib_overwrite(w, write_flags, 1);
+ ret = wimlib_overwrite(w, write_flags, 1,
+ imagex_progress_func);
if (ret == WIMLIB_ERR_REOPEN)
ret = 0;
} else {
static int imagex_join(int argc, const char **argv)
{
int c;
- int flags = WIMLIB_OPEN_FLAG_SPLIT_OK | WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
+ 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':
- flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+ swm_open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+ wim_write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
default:
goto err;
argv += optind;
if (argc < 2) {
- imagex_error("Must specify at least one split WIM (.swm) parts "
+ 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, flags);
+ return wimlib_join(++argv, --argc, output_path, swm_open_flags,
+ wim_write_flags, imagex_progress_func);
err:
usage(JOIN);
return -1;
{
int c;
int mount_flags = 0;
- int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS |
- WIMLIB_OPEN_FLAG_SPLIT_OK;
+ int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
const char *wimfile;
const char *dir;
WIMStruct *w;
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;
case 'r':
swm_glob = optarg;
break;
+ case 'D':
+ staging_dir = optarg;
+ break;
default:
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;
return ret;
}
- ret = wimlib_mount(w, image, dir, mount_flags, additional_swms,
- num_additional_swms);
+ 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'",
image, wimfile, dir);
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);
+
+ 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 flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
+ 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':
- flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+ open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
+ write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
break;
default:
usage(SPLIT);
imagex_error("The part size must be an integer or floating-point number of megabytes.");
return -1;
}
- return wimlib_split(argv[0], argv[1], part_size, flags);
+ 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;
}
/* Unmounts an image. */
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'", argv[0]);
return ret;
{"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},
};
git://wimlib.net / wimlib / blobdiff