wimlib.net Git - wimlib/blob - programs/imagex.c

   1 /*
   2  * imagex.c
   3  *
   4  * Use wimlib to create, modify, extract, mount, unmount, or display information
   5  * about a WIM file
   6  */
   7
   8 /*
   9  * Copyright (C) 2012 Eric Biggers
  10  *
  11  * This program is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation, either version 3 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 #include "wimlib.h"
  26 #include "config.h"
  27 #include <getopt.h>
  28 #include <stdlib.h>
  29 #include <stdarg.h>
  30 #include <glob.h>
  31 #include <string.h>
  32 #include <errno.h>
  33 #include <sys/stat.h>
  34
  35 #define ARRAY_LEN(array) (sizeof(array) / sizeof(array[0]))
  36
  37 #define swap(a, b) ({ typeof(a) __a = (a); typeof(b) __b = (b); \
  38                                 a = __b; b = __a; })
  39
  40 #define for_opt(c, opts) while ((c = getopt_long_only(argc, (char**)argv, "", \
  41                                 opts, NULL)) != -1)
  42
  43
  44 enum imagex_op_type {
  45         APPEND,
  46         APPLY,
  47         CAPTURE,
  48         DELETE,
  49         DIR,
  50         EXPORT,
  51         INFO,
  52         JOIN,
  53         MOUNT,
  54         MOUNTRW,
  55         SPLIT,
  56         UNMOUNT,
  57 };
  58
  59 static void usage(int cmd_type);
  60 static void usage_all();
  61
  62 static const char *usage_strings[] = {
  63 [APPEND] =
  64 "    imagex append (DIRECTORY | NTFS_VOLUME) WIMFILE [IMAGE_NAME]\n"
  65 "                  [DESCRIPTION] [--boot] [--check] [--flags EDITION_ID]\n"
  66 "                  [--verbose] [--dereference] [--config=FILE]\n",
  67 [APPLY] =
  68 "    imagex apply WIMFILE [IMAGE_NUM | IMAGE_NAME | all]\n"
  69 "                 (DIRECTORY | NTFS_VOLUME) [--check] [--hardlink]\n"
  70 "                 [--symlink] [--verbose] [--ref=\"GLOB\"]\n",
  71 [CAPTURE] =
  72 "    imagex capture (DIRECTORY | NTFS_VOLUME) WIMFILE [IMAGE_NAME]\n"
  73 "                   [DESCRIPTION] [--boot] [--check] [--compress=TYPE]\n"
  74 "                   [--flags EDITION_ID] [--verbose] [--dereference]\n"
  75 "                   [--config=FILE]\n",
  76 [DELETE] =
  77 "    imagex delete WIMFILE (IMAGE_NUM | IMAGE_NAME | all) [--check]\n",
  78 [DIR] =
  79 "    imagex dir WIMFILE (IMAGE_NUM | IMAGE_NAME | all)\n",
  80 [EXPORT] =
  81 "    imagex export SRC_WIMFILE (SRC_IMAGE_NUM | SRC_IMAGE_NAME | all ) \n"
  82 "                  DEST_WIMFILE [DEST_IMAGE_NAME]\n"
  83 "                  [DEST_IMAGE_DESCRIPTION] [--boot] [--check]\n"
  84 "                  [--compress=TYPE] [--ref=\"GLOB\"]\n",
  85 [INFO] =
  86 "    imagex info WIMFILE [IMAGE_NUM | IMAGE_NAME] [NEW_NAME]\n"
  87 "                [NEW_DESC] [--boot] [--check] [--header] [--lookup-table]\n"
  88 "                [--xml] [--extract-xml FILE] [--metadata]\n",
  89 [JOIN] =
  90 "    imagex join [--check] WIMFILE SPLIT_WIM...\n",
  91 [MOUNT] =
  92 "    imagex mount WIMFILE (IMAGE_NUM | IMAGE_NAME) DIRECTORY\n"
  93 "                 [--check] [--debug] [--streams-interface=INTERFACE]\n"
  94 "                 [--ref=\"GLOB\"]\n",
  95 [MOUNTRW] =
  96 "    imagex mountrw WIMFILE [IMAGE_NUM | IMAGE_NAME] DIRECTORY\n"
  97 "                   [--check] [--debug] [--streams-interface=INTERFACE]\n",
  98 [SPLIT] =
  99 "    imagex split WIMFILE SPLIT_WIMFILE PART_SIZE_MB [--check]\n",
 100 [UNMOUNT] =
 101 "    imagex unmount DIRECTORY [--commit] [--check]\n",
 102 };
 103
 104 static const struct option common_options[] = {
 105         {"help", 0, NULL, 'h'},
 106         {"version", 0, NULL, 'v'},
 107         {NULL, 0, NULL, 0},
 108 };
 109
 110 static const struct option append_options[] = {
 111         {"boot",        no_argument,       NULL, 'b'},
 112         {"check",       no_argument,       NULL, 'c'},
 113         {"config",      required_argument, NULL, 'C'},
 114         {"dereference", no_argument,       NULL, 'L'},
 115         {"flags",       required_argument, NULL, 'f'},
 116         {"verbose",     no_argument,       NULL, 'v'},
 117         {NULL, 0, NULL, 0},
 118 };
 119 static const struct option apply_options[] = {
 120         {"check",    no_argument,       NULL, 'c'},
 121         {"hardlink", no_argument,       NULL, 'h'},
 122         {"symlink",  no_argument,       NULL, 's'},
 123         {"verbose",  no_argument,       NULL, 'v'},
 124         {"ref",      required_argument, NULL, 'r'},
 125         {NULL, 0, NULL, 0},
 126 };
 127 static const struct option capture_options[] = {
 128         {"boot",        no_argument,       NULL, 'b'},
 129         {"check",       no_argument,       NULL, 'c'},
 130         {"compress",    required_argument, NULL, 'x'},
 131         {"config",      required_argument, NULL, 'C'},
 132         {"dereference", no_argument,       NULL, 'L'},
 133         {"flags",       required_argument, NULL, 'f'},
 134         {"verbose",     no_argument,       NULL, 'v'},
 135         {NULL, 0, NULL, 0},
 136 };
 137 static const struct option delete_options[] = {
 138         {"check", no_argument, NULL, 'c'},
 139         {NULL, 0, NULL, 0},
 140 };
 141
 142 static const struct option export_options[] = {
 143         {"boot",       no_argument,       NULL, 'b'},
 144         {"check",      no_argument,       NULL, 'c'},
 145         {"compress",   required_argument, NULL, 'x'},
 146         {"ref",        required_argument, NULL, 'r'},
 147         {NULL, 0, NULL, 0},
 148 };
 149
 150 static const struct option info_options[] = {
 151         {"boot",         no_argument, NULL, 'b'},
 152         {"check",        no_argument, NULL, 'c'},
 153         {"extract-xml",  required_argument, NULL, 'X'},
 154         {"header",       no_argument, NULL, 'h'},
 155         {"lookup-table", no_argument, NULL, 'l'},
 156         {"metadata",     no_argument, NULL, 'm'},
 157         {"xml",          no_argument, NULL, 'x'},
 158         {NULL, 0, NULL, 0},
 159 };
 160
 161 static const struct option join_options[] = {
 162         {"check", no_argument, NULL, 'c'},
 163         {NULL, 0, NULL, 0},
 164 };
 165
 166 static const struct option mount_options[] = {
 167         {"check", no_argument, NULL, 'c'},
 168         {"debug", no_argument, NULL, 'd'},
 169         {"streams-interface", required_argument, NULL, 's'},
 170         {"ref",      required_argument, NULL, 'r'},
 171         {NULL, 0, NULL, 0},
 172 };
 173
 174 static const struct option split_options[] = {
 175         {"check", no_argument, NULL, 'c'},
 176         {NULL, 0, NULL, 0},
 177 };
 178
 179 static const struct option unmount_options[] = {
 180         {"commit", no_argument, NULL, 'c'},
 181         {"check", no_argument, NULL, 'C'},
 182         {NULL, 0, NULL, 0},
 183 };
 184
 185
 186
 187 /* Print formatted error message to stderr. */
 188 static void imagex_error(const char *format, ...)
 189 {
 190         va_list va;
 191         va_start(va, format);
 192         fputs("ERROR: ", stderr);
 193         vfprintf(stderr, format, va);
 194         putc('\n', stderr);
 195         va_end(va);
 196 }
 197
 198 /* Print formatted error message to stderr. */
 199 static void imagex_error_with_errno(const char *format, ...)
 200 {
 201         int errno_save = errno;
 202         va_list va;
 203         va_start(va, format);
 204         fputs("ERROR: ", stderr);
 205         vfprintf(stderr, format, va);
 206         fprintf(stderr, ": %s\n", strerror(errno_save));
 207         va_end(va);
 208 }
 209
 210 static const char *path_basename(const char *path)
 211 {
 212         const char *p = path;
 213         while (*p)
 214                 p++;
 215         p--;
 216
 217         /* Trailing slashes. */
 218         while ((p != path - 1) && *p == '/')
 219                 p--;
 220
 221         while ((p != path - 1) && *p != '/')
 222                 p--;
 223
 224         return p + 1;
 225 }
 226
 227
 228 static int verify_image_exists(int image)
 229 {
 230         if (image == WIM_NO_IMAGE) {
 231                 imagex_error("Not a valid image");
 232                 return WIMLIB_ERR_INVALID_IMAGE;
 233         }
 234         return 0;
 235 }
 236
 237 static int verify_image_is_single(int image)
 238 {
 239         if (image == WIM_ALL_IMAGES) {
 240                 imagex_error("Cannot specify all images for this action");
 241                 return WIMLIB_ERR_INVALID_IMAGE;
 242         }
 243         return 0;
 244 }
 245
 246 static int verify_image_exists_and_is_single(int image)
 247 {
 248         int ret;
 249         ret = verify_image_exists(image);
 250         if (ret == 0)
 251                 ret = verify_image_is_single(image);
 252         return ret;
 253 }
 254
 255 static int get_compression_type(const char *optarg)
 256 {
 257         if (strcasecmp(optarg, "maximum") == 0 || strcasecmp(optarg, "lzx") == 0)
 258                 return WIM_COMPRESSION_TYPE_LZX;
 259         else if (strcasecmp(optarg, "fast") == 0 || strcasecmp(optarg, "xpress") == 0)
 260                 return WIM_COMPRESSION_TYPE_XPRESS;
 261         else if (strcasecmp(optarg, "none") == 0)
 262                 return WIM_COMPRESSION_TYPE_NONE;
 263         else {
 264                 imagex_error("Invalid compression type `%s'! Must be "
 265                              "\"maximum\", \"fast\", or \"none\".", optarg);
 266                 return WIM_COMPRESSION_TYPE_INVALID;
 267         }
 268 }
 269
 270 static const char *file_get_contents(const char *filename, size_t *len_ret)
 271 {
 272         struct stat stbuf;
 273         char *buf;
 274         size_t len;
 275         FILE *fp;
 276
 277         if (stat(filename, &stbuf) != 0) {
 278                 imagex_error_with_errno("Failed to stat the file `%s'", filename);
 279                 return NULL;
 280         }
 281         len = stbuf.st_size;
 282
 283         fp = fopen(filename, "rb");
 284         if (!fp) {
 285                 imagex_error_with_errno("Failed to open the file `%s'", filename);
 286                 return NULL;
 287         }
 288
 289         buf = malloc(len);
 290         if (!buf) {
 291                 imagex_error("Failed to allocate buffer of %zu bytes to hold "
 292                              "contents of file `%s'", len, filename);
 293                 goto out_fclose;
 294         }
 295         if (fread(buf, 1, len, fp) != len) {
 296                 imagex_error_with_errno("Failed to read %lu bytes from the "
 297                                         "file `%s'", len, filename);
 298                 goto out_free_buf;
 299         }
 300         *len_ret = len;
 301         return buf;
 302 out_free_buf:
 303         free(buf);
 304 out_fclose:
 305         fclose(fp);
 306         return NULL;
 307 }
 308
 309 static int open_swms_from_glob(const char *swm_glob,
 310                                const char *first_part,
 311                                int open_flags,
 312                                WIMStruct ***additional_swms_ret,
 313                                unsigned *num_additional_swms_ret)
 314 {
 315         unsigned num_additional_swms = 0;
 316         WIMStruct **additional_swms = NULL;
 317         glob_t globbuf;
 318         int ret;
 319
 320         ret = glob(swm_glob, GLOB_ERR | GLOB_NOSORT, NULL, &globbuf);
 321         if (ret != 0) {
 322                 if (ret == GLOB_NOMATCH) {
 323                         imagex_error("Found no files for glob \"%s\"",
 324                                      swm_glob);
 325                 } else {
 326                         imagex_error_with_errno("Failed to process glob "
 327                                                 "\"%s\"", swm_glob);
 328                 }
 329                 ret = -1;
 330                 goto out;
 331         }
 332         num_additional_swms = globbuf.gl_pathc;
 333         additional_swms = calloc(num_additional_swms, sizeof(additional_swms[0]));
 334         if (!additional_swms) {
 335                 imagex_error("Out of memory");
 336                 ret = -1;
 337                 goto out_globfree;
 338         }
 339         size_t offset = 0;
 340         for (size_t i = 0; i < num_additional_swms; i++) {
 341                 if (strcmp(globbuf.gl_pathv[i], first_part) == 0) {
 342                         offset++;
 343                         continue;
 344                 }
 345                 ret = wimlib_open_wim(globbuf.gl_pathv[i],
 346                                       open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK,
 347                                       &additional_swms[i - offset]);
 348                 if (ret != 0)
 349                         goto out_close_swms;
 350         }
 351         *additional_swms_ret = additional_swms;
 352         *num_additional_swms_ret = num_additional_swms - offset;
 353         ret = 0;
 354         goto out_globfree;
 355 out_close_swms:
 356         for (unsigned i = 0; i < num_additional_swms; i++)
 357                 wimlib_free(additional_swms[i]);
 358         free(additional_swms);
 359 out_globfree:
 360         globfree(&globbuf);
 361 out:
 362         return ret;
 363 }
 364
 365 static int imagex_append(int argc, const char **argv)
 366 {
 367         int c;
 368         const char *flags_element = NULL;
 369         int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
 370         int add_image_flags = 0;
 371         int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
 372         const char *dir;
 373         const char *wimfile;
 374         const char *name;
 375         const char *desc;
 376         const char *config_file = NULL;
 377         const char *config_str = NULL;
 378         size_t config_len = 0;
 379         WIMStruct *w;
 380         int ret;
 381         int cur_image;
 382
 383         for_opt(c, append_options) {
 384                 switch (c) {
 385                 case 'b':
 386                         add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_BOOT;
 387                         break;
 388                 case 'c':
 389                         open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
 390                         write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
 391                         break;
 392                 case 'C':
 393                         config_file = optarg;
 394                         break;
 395                 case 'f':
 396                         flags_element = optarg;
 397                         break;
 398                 case 'L':
 399                         add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
 400                         break;
 401                 case 'v':
 402                         add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
 403                         break;
 404                 default:
 405                         usage(APPEND);
 406                         return -1;
 407                 }
 408         }
 409         argc -= optind;
 410         argv += optind;
 411         if (argc < 2 || argc > 4) {
 412                 usage(APPEND);
 413                 return -1;
 414         }
 415         dir     = argv[0];
 416         wimfile = argv[1];
 417         name    = (argc >= 3) ? argv[2] : path_basename(dir);
 418         desc    = (argc >= 4) ? argv[3] : NULL;
 419
 420         if (config_file) {
 421                 config_str = file_get_contents(config_file, &config_len);
 422                 if (!config_str)
 423                         return -1;
 424         }
 425
 426         ret = wimlib_open_wim(wimfile, open_flags, &w);
 427         if (ret != 0)
 428                 return ret;
 429
 430 #ifdef WITH_NTFS_3G
 431         struct stat stbuf;
 432
 433         ret = stat(dir, &stbuf);
 434         if (ret == 0) {
 435                 if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode)) {
 436                         const char *ntfs_device = dir;
 437                         printf("Capturing WIM image NTFS filesystem on `%s'\n",
 438                                ntfs_device);
 439                         ret = wimlib_add_image_from_ntfs_volume(w, ntfs_device,
 440                                                                 name,
 441                                                                 config_str,
 442                                                                 config_len,
 443                                                                 add_image_flags);
 444                         goto out_write;
 445                 }
 446         } else {
 447                 if (errno != ENOENT)
 448                         imagex_error_with_errno("Failed to stat `%s'", dir);
 449         }
 450 #endif
 451         ret = wimlib_add_image(w, dir, name, config_str, config_len,
 452                                add_image_flags);
 453
 454 out_write:
 455         if (ret != 0)
 456                 goto out;
 457         cur_image = wimlib_get_num_images(w);
 458         if (desc) {
 459                 ret = wimlib_set_image_descripton(w, cur_image, desc);
 460                 if (ret != 0)
 461                         goto out;
 462         }
 463         if (flags_element) {
 464                 ret = wimlib_set_image_flags(w, cur_image, flags_element);
 465                 if (ret != 0)
 466                         goto out;
 467         }
 468         ret = wimlib_overwrite(w, write_flags);
 469 out:
 470         wimlib_free(w);
 471         return ret;
 472 }
 473
 474 /* Extract one image, or all images, from a WIM file into a directory. */
 475 static int imagex_apply(int argc, const char **argv)
 476 {
 477         int c;
 478         int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS |
 479                          WIMLIB_OPEN_FLAG_SPLIT_OK;
 480         int image;
 481         int num_images;
 482         WIMStruct *w;
 483         int ret;
 484         const char *wimfile;
 485         const char *dir;
 486         const char *image_num_or_name;
 487         int extract_flags = 0;
 488
 489         const char *swm_glob = NULL;
 490         WIMStruct **additional_swms = NULL;
 491         unsigned num_additional_swms = 0;
 492
 493         for_opt(c, apply_options) {
 494                 switch (c) {
 495                 case 'c':
 496                         open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
 497                         break;
 498                 case 'h':
 499                         extract_flags |= WIMLIB_EXTRACT_FLAG_HARDLINK;
 500                         break;
 501                 case 's':
 502                         extract_flags |= WIMLIB_EXTRACT_FLAG_SYMLINK;
 503                         break;
 504                 case 'v':
 505                         extract_flags |= WIMLIB_EXTRACT_FLAG_VERBOSE;
 506                         break;
 507                 case 'r':
 508                         swm_glob = optarg;
 509                         break;
 510                 default:
 511                         usage(APPLY);
 512                         return -1;
 513                 }
 514         }
 515         argc -= optind;
 516         argv += optind;
 517         if (argc != 2 && argc != 3) {
 518                 usage(APPLY);
 519                 return -1;
 520         }
 521
 522         wimfile = argv[0];
 523         if (argc == 2) {
 524                 image_num_or_name =  "1";
 525                 dir = argv[1];
 526         } else {
 527                 image_num_or_name = argv[1];
 528                 dir = argv[2];
 529         }
 530
 531         ret = wimlib_open_wim(wimfile, open_flags, &w);
 532         if (ret != 0)
 533                 return ret;
 534
 535         image = wimlib_resolve_image(w, image_num_or_name);
 536         ret = verify_image_exists(image);
 537         if (ret != 0)
 538                 goto out;
 539
 540         num_images = wimlib_get_num_images(w);
 541         if (argc == 2 && num_images != 1) {
 542                 imagex_error("`%s' contains %d images; Please select one "
 543                              "(or all)", wimfile, num_images);
 544                 usage(APPLY);
 545                 ret = -1;
 546                 goto out;
 547         }
 548
 549         if (swm_glob) {
 550                 ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
 551                                           &additional_swms,
 552                                           &num_additional_swms);
 553                 if (ret != 0)
 554                         goto out;
 555         }
 556
 557 #ifdef WITH_NTFS_3G
 558         struct stat stbuf;
 559
 560         ret = stat(dir, &stbuf);
 561         if (ret == 0) {
 562                 if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode)) {
 563                         const char *ntfs_device = dir;
 564                         printf("Applying image %d of `%s' to NTFS filesystem on `%s'\n",
 565                                image, wimfile, ntfs_device);
 566                         ret = wimlib_apply_image_to_ntfs_volume(w, image,
 567                                                                 ntfs_device,
 568                                                                 extract_flags,
 569                                                                 additional_swms,
 570                                                                 num_additional_swms);
 571                         goto out;
 572                 }
 573         } else {
 574                 if (errno != ENOENT)
 575                         imagex_error_with_errno("Failed to stat `%s'", dir);
 576         }
 577 #endif
 578
 579         ret = wimlib_extract_image(w, image, dir, extract_flags,
 580                                    additional_swms, num_additional_swms);
 581 out:
 582         wimlib_free(w);
 583         if (additional_swms)
 584                 for (size_t i = 0; i < num_additional_swms; i++)
 585                         wimlib_free(additional_swms[i]);
 586         return ret;
 587 }
 588
 589
 590 /* Create a WIM file from a directory. */
 591 static int imagex_capture(int argc, const char **argv)
 592 {
 593         int c;
 594         int add_image_flags = 0;
 595         int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
 596         int compression_type = WIM_COMPRESSION_TYPE_XPRESS;
 597         const char *flags_element = NULL;
 598         const char *dir;
 599         const char *wimfile;
 600         const char *name;
 601         const char *desc;
 602         const char *config_file = NULL;
 603         const char *config_str = NULL;
 604         size_t config_len = 0;
 605         WIMStruct *w;
 606         int cur_image;
 607         int ret;
 608
 609         for_opt(c, capture_options) {
 610                 switch (c) {
 611                 case 'b':
 612                         add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_BOOT;
 613                         break;
 614                 case 'c':
 615                         write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
 616                         break;
 617                 case 'C':
 618                         config_file = optarg;
 619                         break;
 620                 case 'x':
 621                         compression_type = get_compression_type(optarg);
 622                         if (compression_type == WIM_COMPRESSION_TYPE_INVALID)
 623                                 return -1;
 624                         break;
 625                 case 'f':
 626                         flags_element = optarg;
 627                         break;
 628                 case 'v':
 629                         add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_VERBOSE;
 630                         write_flags |= WIMLIB_WRITE_FLAG_VERBOSE;
 631                         break;
 632                 case 'L':
 633                         add_image_flags |= WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE;
 634                         break;
 635                 default:
 636                         usage(CAPTURE);
 637                         return -1;
 638                 }
 639         }
 640
 641         argc -= optind;
 642         argv += optind;
 643         if (argc < 2 || argc > 4) {
 644                 usage(CAPTURE);
 645                 return -1;
 646         }
 647         dir     = argv[0];
 648         wimfile = argv[1];
 649         name    = (argc >= 3) ? argv[2] : dir;
 650         desc    = (argc >= 4) ? argv[3] : NULL;
 651
 652         if (config_file) {
 653                 config_str = file_get_contents(config_file, &config_len);
 654                 if (!config_str)
 655                         return -1;
 656         }
 657
 658         ret = wimlib_create_new_wim(compression_type, &w);
 659         if (ret != 0)
 660                 return ret;
 661
 662 #ifdef WITH_NTFS_3G
 663         struct stat stbuf;
 664
 665         ret = stat(dir, &stbuf);
 666         if (ret == 0) {
 667                 if (S_ISBLK(stbuf.st_mode) || S_ISREG(stbuf.st_mode)) {
 668                         const char *ntfs_device = dir;
 669                         printf("Capturing WIM image NTFS filesystem on `%s'\n",
 670                                ntfs_device);
 671                         ret = wimlib_add_image_from_ntfs_volume(w, ntfs_device,
 672                                                                 name,
 673                                                                 config_str,
 674                                                                 config_len,
 675                                                                 add_image_flags);
 676                         goto out_write;
 677                 }
 678         } else {
 679                 if (errno != ENOENT)
 680                         imagex_error_with_errno("Failed to stat `%s'", dir);
 681         }
 682 #endif
 683         ret = wimlib_add_image(w, dir, name, config_str,
 684                                config_len, add_image_flags);
 685
 686 out_write:
 687         if (ret != 0) {
 688                 imagex_error("Failed to add the image `%s'", dir);
 689                 goto out;
 690         }
 691         cur_image = wimlib_get_num_images(w);
 692         if (desc) {
 693                 ret = wimlib_set_image_descripton(w, cur_image, desc);
 694                 if (ret != 0)
 695                         goto out;
 696         }
 697         if (flags_element) {
 698                 ret = wimlib_set_image_flags(w, cur_image, flags_element);
 699                 if (ret != 0)
 700                         goto out;
 701         }
 702
 703         ret = wimlib_write(w, wimfile, WIM_ALL_IMAGES, write_flags);
 704         if (ret != 0)
 705                 imagex_error("Failed to write the WIM file `%s'", wimfile);
 706 out:
 707         wimlib_free(w);
 708         return ret;
 709 }
 710
 711 /* Remove image(s) from a WIM. */
 712 static int imagex_delete(int argc, const char **argv)
 713 {
 714         int c;
 715         int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
 716         int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
 717         const char *wimfile;
 718         const char *image_num_or_name;
 719         WIMStruct *w;
 720         int image;
 721         int ret;
 722
 723         for_opt(c, delete_options) {
 724                 switch (c) {
 725                 case 'c':
 726                         open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
 727                         write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
 728                         break;
 729                 default:
 730                         usage(DELETE);
 731                         return -1;
 732                 }
 733         }
 734         argc -= optind;
 735         argv += optind;
 736
 737         if (argc != 2) {
 738                 if (argc < 1)
 739                         imagex_error("Must specify a WIM file");
 740                 if (argc < 2)
 741                         imagex_error("Must specify an image");
 742                 usage(DELETE);
 743                 return -1;
 744         }
 745         wimfile = argv[0];
 746         image_num_or_name = argv[1];
 747
 748         ret = wimlib_open_wim(wimfile, open_flags, &w);
 749         if (ret != 0)
 750                 return ret;
 751
 752         image = wimlib_resolve_image(w, image_num_or_name);
 753
 754         ret = verify_image_exists(image);
 755         if (ret != 0)
 756                 goto done;
 757
 758         ret = wimlib_delete_image(w, image);
 759         if (ret != 0) {
 760                 imagex_error("Failed to delete image from `%s'", wimfile);
 761                 goto done;
 762         }
 763
 764         ret = wimlib_overwrite(w, write_flags);
 765         if (ret != 0) {
 766                 imagex_error("Failed to write the file `%s' with image "
 767                              "deleted", wimfile);
 768         }
 769 done:
 770         wimlib_free(w);
 771         return ret;
 772 }
 773
 774 /* Print the files contained in an image(s) in a WIM file. */
 775 static int imagex_dir(int argc, const char **argv)
 776 {
 777         const char *wimfile;
 778         WIMStruct *w;
 779         int image;
 780         int ret;
 781         int num_images;
 782         int part_number;
 783
 784         if (argc < 2) {
 785                 imagex_error("Must specify a WIM file");
 786                 usage(DIR);
 787                 return -1;
 788         }
 789         if (argc > 3) {
 790                 imagex_error("Too many arguments");
 791                 usage(DIR);
 792                 return -1;
 793         }
 794
 795         wimfile = argv[1];
 796         ret = wimlib_open_wim(wimfile, WIMLIB_OPEN_FLAG_SPLIT_OK, &w);
 797         if (ret != 0)
 798                 return ret;
 799
 800         part_number = wimlib_get_part_number(w, NULL);
 801         if (part_number != 1) {
 802                 imagex_error("`%s' is part %d of a split WIM!  Specify the "
 803                              "first part to see the files",
 804                              wimfile, part_number);
 805                 ret = WIMLIB_ERR_SPLIT_UNSUPPORTED;
 806                 goto done;
 807         }
 808
 809         if (argc == 3) {
 810                 image = wimlib_resolve_image(w, argv[2]);
 811                 ret = verify_image_exists(image);
 812                 if (ret != 0)
 813                         goto done;
 814         } else {
 815                 /* Image was not specified.  If the WIM only contains one image,
 816                  * choose that one; otherwise, print an error. */
 817                 num_images = wimlib_get_num_images(w);
 818                 if (num_images != 1) {
 819                         imagex_error("The file `%s' contains %d images; Please "
 820                                      "select one.", wimfile, num_images);
 821                         usage(DIR);
 822                         ret = -1;
 823                         goto done;
 824                 }
 825                 image = 1;
 826         }
 827
 828         ret = wimlib_print_files(w, image);
 829 done:
 830         wimlib_free(w);
 831         return ret;
 832 }
 833
 834 /* Exports one, or all, images from a WIM file to a new WIM file or an existing
 835  * WIM file. */
 836 static int imagex_export(int argc, const char **argv)
 837 {
 838         int c;
 839         int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
 840         int export_flags = 0;
 841         int write_flags = WIMLIB_WRITE_FLAG_SHOW_PROGRESS;
 842         int compression_type = WIM_COMPRESSION_TYPE_XPRESS;
 843         bool compression_type_specified = false;
 844         const char *src_wimfile;
 845         const char *src_image_num_or_name;
 846         const char *dest_wimfile;
 847         const char *dest_name;
 848         const char *dest_desc;
 849         WIMStruct *src_w = NULL;
 850         WIMStruct *dest_w = NULL;
 851         int ret;
 852         int image;
 853         struct stat stbuf;
 854         bool wim_is_new;
 855         const char *swm_glob = NULL;
 856         WIMStruct **additional_swms = NULL;
 857         unsigned num_additional_swms = 0;
 858
 859         for_opt(c, export_options) {
 860                 switch (c) {
 861                 case 'b':
 862                         export_flags |= WIMLIB_EXPORT_FLAG_BOOT;
 863                         break;
 864                 case 'c':
 865                         open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
 866                         write_flags |= WIMLIB_WRITE_FLAG_CHECK_INTEGRITY;
 867                         break;
 868                 case 'x':
 869                         compression_type = get_compression_type(optarg);
 870                         if (compression_type == WIM_COMPRESSION_TYPE_INVALID)
 871                                 return -1;
 872                         compression_type_specified = true;
 873                         break;
 874                 case 'r':
 875                         swm_glob = optarg;
 876                         break;
 877                 default:
 878                         usage(EXPORT);
 879                         return -1;
 880                 }
 881         }
 882         argc -= optind;
 883         argv += optind;
 884         if (argc < 3 || argc > 5) {
 885                 usage(EXPORT);
 886                 return -1;
 887         }
 888         src_wimfile           = argv[0];
 889         src_image_num_or_name = argv[1];
 890         dest_wimfile          = argv[2];
 891         dest_name             = (argc >= 4) ? argv[3] : NULL;
 892         dest_desc             = (argc >= 5) ? argv[4] : NULL;
 893         ret = wimlib_open_wim(src_wimfile,
 894                               open_flags | WIMLIB_OPEN_FLAG_SPLIT_OK, &src_w);
 895         if (ret != 0)
 896                 return ret;
 897
 898         /* Determine if the destination is an existing file or not.
 899          * If so, we try to append the exported image(s) to it; otherwise, we
 900          * create a new WIM containing the exported image(s). */
 901         if (stat(dest_wimfile, &stbuf) == 0) {
 902                 wim_is_new = false;
 903                 /* Destination file exists. */
 904                 if (!S_ISREG(stbuf.st_mode) && !S_ISLNK(stbuf.st_mode)) {
 905                         imagex_error("`%s' is not a regular file",
 906                                         dest_wimfile);
 907                         goto out;
 908                 }
 909                 ret = wimlib_open_wim(dest_wimfile, open_flags, &dest_w);
 910                 if (ret != 0)
 911                         goto out;
 912
 913                 if (compression_type_specified && compression_type !=
 914                                 wimlib_get_compression_type(dest_w)) {
 915                         imagex_error("Cannot specify a compression type that is "
 916                                      "not the same as that used in the "
 917                                      "destination WIM");
 918                         ret = -1;
 919                         goto out;
 920                 }
 921                 compression_type = wimlib_get_compression_type(dest_w);
 922         } else {
 923                 wim_is_new = true;
 924                 /* dest_wimfile is not an existing file, so create a new WIM. */
 925                 if (errno == ENOENT) {
 926                         ret = wimlib_create_new_wim(compression_type, &dest_w);
 927                         if (ret != 0)
 928                                 goto out;
 929                 } else {
 930                         imagex_error_with_errno("Cannot stat file `%s'",
 931                                                 dest_wimfile);
 932                         goto out;
 933                 }
 934         }
 935
 936         image = wimlib_resolve_image(src_w, src_image_num_or_name);
 937         ret = verify_image_exists(image);
 938         if (ret != 0)
 939                 goto out;
 940
 941         if (swm_glob) {
 942                 ret = open_swms_from_glob(swm_glob, src_wimfile, open_flags,
 943                                           &additional_swms,
 944                                           &num_additional_swms);
 945                 if (ret != 0)
 946                         goto out;
 947         }
 948
 949         ret = wimlib_export_image(src_w, image, dest_w, dest_name, dest_desc,
 950                                   export_flags, additional_swms,
 951                                   num_additional_swms);
 952         if (ret != 0)
 953                 goto out;
 954
 955
 956         if (wim_is_new)
 957                 ret = wimlib_write(dest_w, dest_wimfile, WIM_ALL_IMAGES,
 958                                    write_flags);
 959         else
 960                 ret = wimlib_overwrite(dest_w, write_flags);
 961 out:
 962         wimlib_free(src_w);
 963         wimlib_free(dest_w);
 964         if (additional_swms)
 965                 for (unsigned i = 0; i < num_additional_swms; i++)
 966                         wimlib_free(additional_swms[i]);
 967         return ret;
 968 }
 969
 970 /* Prints information about a WIM file; also can mark an image as bootable,
 971  * change the name of an image, or change the description of an image. */
 972 static int imagex_info(int argc, const char **argv)
 973 {
 974         int c;
 975         bool boot         = false;
 976         bool check        = false;
 977         bool header       = false;
 978         bool lookup_table = false;
 979         bool xml          = false;
 980         bool metadata     = false;
 981         bool short_header = true;
 982         const char *xml_out_file = NULL;
 983         const char *wimfile;
 984         const char *image_num_or_name = "all";
 985         const char *new_name = NULL;
 986         const char *new_desc = NULL;
 987         WIMStruct *w;
 988         FILE *fp;
 989         int image;
 990         int ret;
 991         int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS |
 992                          WIMLIB_OPEN_FLAG_SPLIT_OK;
 993         int part_number;
 994         int total_parts;
 995
 996         for_opt(c, info_options) {
 997                 switch (c) {
 998                 case 'b':
 999                         boot = true;
1000                         break;
1001                 case 'c':
1002                         check = true;
1003                         break;
1004                 case 'h':
1005                         header = true;
1006                         short_header = false;
1007                         break;
1008                 case 'l':
1009                         lookup_table = true;
1010                         short_header = false;
1011                         break;
1012                 case 'x':
1013                         xml = true;
1014                         short_header = false;
1015                         break;
1016                 case 'X':
1017                         xml_out_file = optarg;
1018                         short_header = false;
1019                         break;
1020                 case 'm':
1021                         metadata = true;
1022                         short_header = false;
1023                         break;
1024                 default:
1025                         usage(INFO);
1026                         return -1;
1027                 }
1028         }
1029
1030         argc -= optind;
1031         argv += optind;
1032         if (argc == 0 || argc > 4) {
1033                 usage(INFO);
1034                 return -1;
1035         }
1036         wimfile = argv[0];
1037         if (argc > 1) {
1038                 image_num_or_name = argv[1];
1039                 if (argc > 2) {
1040                         new_name = argv[2];
1041                         if (argc > 3) {
1042                                 new_desc = argv[3];
1043                         }
1044                 }
1045         }
1046
1047         if (check)
1048                 open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
1049
1050         ret = wimlib_open_wim(wimfile, open_flags, &w);
1051         if (ret != 0)
1052                 return ret;
1053
1054         part_number = wimlib_get_part_number(w, &total_parts);
1055
1056         /*if (total_parts > 1 && part_number > 1) {*/
1057                 /*printf("Warning: this is part %d of a %d-part split WIM.\n"*/
1058                        /*"         Select the first part if you want to see information\n"*/
1059                        /*"         about images in the WIM.\n", */
1060                        /*part_number, total_parts);*/
1061         /*}*/
1062
1063         image = wimlib_resolve_image(w, image_num_or_name);
1064         if (image == WIM_NO_IMAGE && strcmp(image_num_or_name, "0") != 0) {
1065                 imagex_error("The image `%s' does not exist",
1066                                                 image_num_or_name);
1067                 if (boot)
1068                         imagex_error("If you would like to set the boot "
1069                                      "index to 0, specify image \"0\" with "
1070                                      "the --boot flag.");
1071                 ret = WIMLIB_ERR_INVALID_IMAGE;
1072                 goto done;
1073         }
1074
1075         if (image == WIM_ALL_IMAGES && wimlib_get_num_images(w) > 1) {
1076                 if (boot) {
1077                         imagex_error("Cannot specify the --boot flag "
1078                                      "without specifying a specific "
1079                                      "image in a multi-image WIM");
1080                         ret = WIMLIB_ERR_INVALID_IMAGE;
1081                         goto done;
1082                 }
1083                 if (new_name) {
1084                         imagex_error("Cannot specify the NEW_NAME "
1085                                      "without specifying a specific "
1086                                      "image in a multi-image WIM");
1087                         ret = WIMLIB_ERR_INVALID_IMAGE;
1088                         goto done;
1089                 }
1090         }
1091
1092         /* Operations that print information are separated from operations that
1093          * recreate the WIM file. */
1094         if (!new_name && !boot) {
1095
1096                 if (image == WIM_NO_IMAGE) {
1097                         imagex_error("`%s' is not a valid image",
1098                                      image_num_or_name);
1099                         ret = WIMLIB_ERR_INVALID_IMAGE;
1100                         goto done;
1101                 }
1102
1103                 if (image == WIM_ALL_IMAGES && short_header)
1104                         wimlib_print_wim_information(w);
1105
1106                 if (header)
1107                         wimlib_print_header(w);
1108
1109                 if (lookup_table) {
1110                         if (total_parts != 1) {
1111                                 printf("Warning: Only showing the lookup table "
1112                                        "for part %d of a %d-part WIM.\n",
1113                                        part_number, total_parts);
1114                         }
1115                         wimlib_print_lookup_table(w);
1116                 }
1117
1118                 if (xml) {
1119                         ret = wimlib_extract_xml_data(w, stdout);
1120                         if (ret != 0)
1121                                 goto done;
1122                 }
1123
1124                 if (xml_out_file) {
1125                         fp = fopen(xml_out_file, "wb");
1126                         if (!fp) {
1127                                 imagex_error_with_errno("Failed to open the "
1128                                                         "file `%s' for "
1129                                                         "writing ",
1130                                                         xml_out_file);
1131                                 goto done;
1132                         }
1133                         ret = wimlib_extract_xml_data(w, fp);
1134                         if (fclose(fp) != 0) {
1135                                 imagex_error("Failed to close the file `%s'",
1136                                              xml_out_file);
1137                                 goto done;
1138                         }
1139
1140                         if (ret != 0)
1141                                 goto done;
1142                 }
1143
1144                 if (short_header)
1145                         wimlib_print_available_images(w, image);
1146
1147                 if (metadata) {
1148                         if (total_parts != 1 && part_number != 1) {
1149                                 imagex_error("Select part 1 of this %d-part WIM "
1150                                              "to see the image metadata",
1151                                              total_parts);
1152                                 return WIMLIB_ERR_SPLIT_UNSUPPORTED;
1153                         }
1154                         ret = wimlib_print_metadata(w, image);
1155                         if (ret != 0)
1156                                 goto done;
1157                 }
1158         } else {
1159                 if (total_parts != 1) {
1160                         imagex_error("Modifying a split WIM is not supported.");
1161                         return -1;
1162                 }
1163                 if (image == WIM_ALL_IMAGES)
1164                         image = 1;
1165
1166                 if (image == WIM_NO_IMAGE && new_name) {
1167                         imagex_error("Cannot specify new_name (`%s') when "
1168                                      "using image 0", new_name);
1169                         return -1;
1170                 }
1171
1172                 if (boot) {
1173                         if (image == wimlib_get_boot_idx(w)) {
1174                                 printf("Image %d is already marked as "
1175                                        "bootable.\n", image);
1176                                 boot = false;
1177                         } else {
1178                                 printf("Marking image %d as bootable.\n",
1179                                        image);
1180                                 wimlib_set_boot_idx(w, image);
1181                         }
1182                 }
1183                 if (new_name) {
1184                         if (strcmp(wimlib_get_image_name(w, image),
1185                                                 new_name) == 0) {
1186                                 printf("Image %d is already named \"%s\".\n",
1187                                        image, new_name);
1188                                 new_name = NULL;
1189                         } else {
1190                                 printf("Changing the name of image %d to "
1191                                        "\"%s\".\n", image, new_name);
1192                                 ret = wimlib_set_image_name(w, image, new_name);
1193                                 if (ret != 0)
1194                                         goto done;
1195                         }
1196                 }
1197                 if (new_desc) {
1198                         const char *old_desc;
1199                         old_desc = wimlib_get_image_description(w, image);
1200                         if (old_desc && strcmp(old_desc, new_desc) == 0) {
1201                                 printf("The description of image %d is already "
1202                                        "\"%s\".\n", image, new_desc);
1203                                 new_desc = NULL;
1204                         } else {
1205                                 printf("Changing the description of image %d "
1206                                        "to \"%s\".\n", image, new_desc);
1207                                 ret = wimlib_set_image_descripton(w, image,
1208                                                                   new_desc);
1209                                 if (ret != 0)
1210                                         goto done;
1211                         }
1212                 }
1213
1214                 /* Only call wimlib_overwrite_xml_and_header() if something
1215                  * actually needs to be changed. */
1216                 if (boot || new_name || new_desc ||
1217                                 check != wimlib_has_integrity_table(w)) {
1218
1219                         ret = wimlib_overwrite_xml_and_header(w, check ?
1220                                         WIMLIB_WRITE_FLAG_CHECK_INTEGRITY |
1221                                         WIMLIB_WRITE_FLAG_SHOW_PROGRESS : 0);
1222                 } else {
1223                         printf("The file `%s' was not modified because nothing "
1224                                         "needed to be done.\n", wimfile);
1225                         ret = 0;
1226                 }
1227         }
1228
1229 done:
1230         wimlib_free(w);
1231         return ret;
1232 }
1233
1234 /* Join split WIMs into one part WIM */
1235 static int imagex_join(int argc, const char **argv)
1236 {
1237         int c;
1238         int flags = WIMLIB_OPEN_FLAG_SPLIT_OK | WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
1239         const char *output_path;
1240
1241         for_opt(c, join_options) {
1242                 switch (c) {
1243                 case 'c':
1244                         flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
1245                         break;
1246                 default:
1247                         goto err;
1248                 }
1249         }
1250         argc -= optind;
1251         argv += optind;
1252
1253         if (argc < 2) {
1254                 imagex_error("Must specify at least one split WIM (.swm) parts "
1255                              "to join");
1256                 goto err;
1257         }
1258         output_path = argv[0];
1259         return wimlib_join(++argv, --argc, output_path, flags);
1260 err:
1261         usage(JOIN);
1262         return -1;
1263 }
1264
1265 /* Mounts an image using a FUSE mount. */
1266 static int imagex_mount_rw_or_ro(int argc, const char **argv)
1267 {
1268         int c;
1269         int mount_flags = 0;
1270         int open_flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS |
1271                          WIMLIB_OPEN_FLAG_SPLIT_OK;
1272         const char *wimfile;
1273         const char *dir;
1274         WIMStruct *w;
1275         int image;
1276         int num_images;
1277         int ret;
1278         const char *swm_glob = NULL;
1279         WIMStruct **additional_swms = NULL;
1280         unsigned num_additional_swms = 0;
1281
1282         if (strcmp(argv[0], "mountrw") == 0)
1283                 mount_flags |= WIMLIB_MOUNT_FLAG_READWRITE;
1284         for_opt(c, mount_options) {
1285                 switch (c) {
1286                 case 'c':
1287                         open_flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
1288                         break;
1289                 case 'd':
1290                         mount_flags |= WIMLIB_MOUNT_FLAG_DEBUG;
1291                         break;
1292                 case 's':
1293                         if (strcasecmp(optarg, "none") == 0)
1294                                 mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_NONE;
1295                         else if (strcasecmp(optarg, "xattr") == 0)
1296                                 mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR;
1297                         else if (strcasecmp(optarg, "windows") == 0)
1298                                 mount_flags |= WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS;
1299                         else {
1300                                 imagex_error("Unknown stream interface \"%s\"", optarg);
1301                                 goto mount_usage;
1302                         }
1303                         break;
1304                 case 'r':
1305                         swm_glob = optarg;
1306                         break;
1307                 default:
1308                         goto mount_usage;
1309                 }
1310         }
1311         argc -= optind;
1312         argv += optind;
1313         if (argc != 2 && argc != 3)
1314                 goto mount_usage;
1315
1316         wimfile = argv[0];
1317
1318         ret = wimlib_open_wim(wimfile, open_flags, &w);
1319         if (ret != 0)
1320                 return ret;
1321
1322         if (swm_glob) {
1323                 ret = open_swms_from_glob(swm_glob, wimfile, open_flags,
1324                                           &additional_swms,
1325                                           &num_additional_swms);
1326                 if (ret != 0)
1327                         goto out;
1328         }
1329
1330         if (argc == 2) {
1331                 image = 1;
1332                 num_images = wimlib_get_num_images(w);
1333                 if (num_images != 1) {
1334                         imagex_error("The file `%s' contains %d images; Please "
1335                                      "select one", wimfile, num_images);
1336                         usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
1337                                         ? MOUNTRW : MOUNT);
1338                         ret = WIMLIB_ERR_INVALID_IMAGE;
1339                         goto out;
1340                 }
1341                 dir = argv[1];
1342         } else {
1343                 image = wimlib_resolve_image(w, argv[1]);
1344                 dir = argv[2];
1345         }
1346
1347         ret = verify_image_exists_and_is_single(image);
1348         if (ret != 0)
1349                 goto out;
1350
1351         ret = wimlib_mount(w, image, dir, mount_flags, additional_swms,
1352                            num_additional_swms);
1353         if (ret != 0) {
1354                 imagex_error("Failed to mount image %d from `%s' on `%s'",
1355                              image, wimfile, dir);
1356
1357         }
1358 out:
1359         wimlib_free(w);
1360         if (additional_swms)
1361                 for (unsigned i = 0; i < num_additional_swms; i++)
1362                         wimlib_free(additional_swms[i]);
1363         return ret;
1364 mount_usage:
1365         usage((mount_flags & WIMLIB_MOUNT_FLAG_READWRITE)
1366                         ? MOUNTRW : MOUNT);
1367         return -1;
1368 }
1369
1370 /* Split a WIM into a spanned set */
1371 static int imagex_split(int argc, const char **argv)
1372 {
1373         int c;
1374         int flags = WIMLIB_OPEN_FLAG_SHOW_PROGRESS;
1375         unsigned long part_size;
1376
1377         for_opt(c, split_options) {
1378                 switch (c) {
1379                 case 'c':
1380                         flags |= WIMLIB_OPEN_FLAG_CHECK_INTEGRITY;
1381                         break;
1382                 default:
1383                         usage(SPLIT);
1384                         return -1;
1385                 }
1386         }
1387         argc -= optind;
1388         argv += optind;
1389
1390         if (argc != 3) {
1391                 usage(SPLIT);
1392                 return -1;
1393         }
1394         part_size = strtoul(argv[2], NULL, 10) * (1 << 20);
1395         return wimlib_split(argv[0], argv[1], part_size, flags);
1396 }
1397
1398 /* Unmounts an image. */
1399 static int imagex_unmount(int argc, const char **argv)
1400 {
1401         int c;
1402         int unmount_flags = 0;
1403         int ret;
1404
1405         for_opt(c, unmount_options) {
1406                 switch (c) {
1407                 case 'c':
1408                         unmount_flags |= WIMLIB_UNMOUNT_FLAG_COMMIT;
1409                         break;
1410                 case 'C':
1411                         unmount_flags |= WIMLIB_UNMOUNT_FLAG_CHECK_INTEGRITY;
1412                         break;
1413                 default:
1414                         usage(UNMOUNT);
1415                         return -1;
1416                 }
1417         }
1418         argc -= optind;
1419         argv += optind;
1420         if (argc != 1) {
1421                 usage(UNMOUNT);
1422                 return -1;
1423         }
1424
1425         ret = wimlib_unmount(argv[0], unmount_flags);
1426         if (ret != 0)
1427                 imagex_error("Failed to unmount `%s'", argv[0]);
1428         return ret;
1429 }
1430
1431 struct imagex_command {
1432         const char *name;
1433         int (*func)(int , const char **);
1434         int cmd;
1435 };
1436
1437
1438 #define for_imagex_command(p) for (p = &imagex_commands[0]; \
1439                 p != &imagex_commands[ARRAY_LEN(imagex_commands)]; p++)
1440
1441 static struct imagex_command imagex_commands[] = {
1442         {"append",  imagex_append,         APPEND},
1443         {"apply",   imagex_apply,          APPLY},
1444         {"capture", imagex_capture,        CAPTURE},
1445         {"delete",  imagex_delete,         DELETE},
1446         {"dir",     imagex_dir,            DIR},
1447         {"export",  imagex_export,         EXPORT},
1448         {"info",    imagex_info,           INFO},
1449         {"join",    imagex_join,           JOIN},
1450         {"mount",   imagex_mount_rw_or_ro, MOUNT},
1451         {"mountrw", imagex_mount_rw_or_ro, MOUNTRW},
1452         {"split",   imagex_split,          SPLIT},
1453         {"unmount", imagex_unmount,        UNMOUNT},
1454 };
1455
1456 static void version()
1457 {
1458         static const char *s =
1459         "imagex (" PACKAGE ") " PACKAGE_VERSION "\n"
1460         "Copyright (C) 2012 Eric Biggers\n"
1461         "License GPLv3+; GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.\n"
1462         "This is free software: you are free to change and redistribute it.\n"
1463         "There is NO WARRANTY, to the extent permitted by law.\n"
1464         "\n"
1465         "Report bugs to "PACKAGE_BUGREPORT".\n";
1466         fputs(s, stdout);
1467 }
1468
1469
1470 static void help_or_version(int argc, const char **argv)
1471 {
1472         int i;
1473         const char *p;
1474         struct imagex_command *cmd;
1475
1476         for (i = 1; i < argc; i++) {
1477                 p = argv[i];
1478                 if (*p == '-')
1479                         p++;
1480                 else
1481                         continue;
1482                 if (*p == '-')
1483                         p++;
1484                 if (strcmp(p, "help") == 0 || (*p == '?' && *(p + 1) == '\0')) {
1485                         for_imagex_command(cmd) {
1486                                 if (strcmp(cmd->name, argv[1]) == 0) {
1487                                         usage(cmd->cmd);
1488                                         exit(0);
1489                                 }
1490                         }
1491                         usage_all();
1492                         exit(0);
1493                 }
1494                 if (strcmp(p, "version") == 0) {
1495                         version();
1496                         exit(0);
1497                 }
1498         }
1499 }
1500
1501
1502 static void usage(int cmd_type)
1503 {
1504         struct imagex_command *cmd;
1505         puts("IMAGEX: Usage:");
1506         fputs(usage_strings[cmd_type], stdout);
1507         for_imagex_command(cmd)
1508                 if (cmd->cmd == cmd_type)
1509                         printf("\nTry `man imagex-%s' for more details.\n",
1510                                cmd->name);
1511 }
1512
1513 static void usage_all()
1514 {
1515         puts("IMAGEX: Usage:");
1516         for (int i = 0; i < ARRAY_LEN(usage_strings); i++)
1517                 fputs(usage_strings[i], stdout);
1518         static const char *extra =
1519 "    imagex --help\n"
1520 "    imagex --version\n"
1521 "\n"
1522 "    The compression TYPE may be \"maximum\", \"fast\", or \"none\".\n"
1523 "\n"
1524 "    Try `man imagex' for more information.\n"
1525         ;
1526         fputs(extra, stdout);
1527 }
1528
1529
1530 int main(int argc, const char **argv)
1531 {
1532         struct imagex_command *cmd;
1533         int ret;
1534
1535         if (argc < 2) {
1536                 imagex_error("No command specified");
1537                 usage_all();
1538                 return 1;
1539         }
1540
1541         help_or_version(argc, argv);
1542         argc--;
1543         argv++;
1544
1545         wimlib_set_print_errors(true);
1546
1547         for_imagex_command(cmd) {
1548                 if (strcmp(cmd->name, *argv) == 0) {
1549                         ret = cmd->func(argc, argv);
1550                         if (ret > 0) {
1551                                 imagex_error("Exiting with error code %d:\n"
1552                                              "       %s.", ret,
1553                                              wimlib_get_error_string(ret));
1554                                 if (ret == WIMLIB_ERR_NTFS_3G)
1555                                         imagex_error_with_errno("errno");
1556                         }
1557                         return ret;
1558                 }
1559         }
1560
1561         imagex_error("Unrecognized command: `%s'", argv[0]);
1562         usage_all();
1563         return 1;
1564 }
1565 /*#ifndef WITH_NTFS_3G*/
1566                 /*ERROR("wimlib was not compiled with support for NTFS-3g, so we cannot extract");*/
1567                 /*ERROR("a WIM to a NTFS filesystem while preserving NTFS-specific metadata.");*/
1568                 /*ERROR("Please apply the WIM to a directory rather than a block device, ");*/
1569                 /*ERROR("and without the NTFS flag; or compile in support for NTFS-3g.");*/
1570                 /*return WIMLIB_ERR_UNSUPPORTED;*/
1571 /*#endif*/