translate_text_to_tstr(): Correctly compare byte values
[wimlib] / programs / imagex.c
index e3800ca..772b86e 100644 (file)
@@ -158,6 +158,7 @@ enum {
        IMAGEX_THREADS_OPTION,
        IMAGEX_TO_STDOUT_OPTION,
        IMAGEX_UNIX_DATA_OPTION,
+       IMAGEX_UPDATE_OF_OPTION,
        IMAGEX_VERBOSE_OPTION,
        IMAGEX_XML_OPTION,
 };
@@ -202,6 +203,7 @@ static const struct option capture_or_append_options[] = {
        {T("norpfix"),     no_argument,       NULL, IMAGEX_NORPFIX_OPTION},
        {T("pipable"),     no_argument,       NULL, IMAGEX_PIPABLE_OPTION},
        {T("not-pipable"), no_argument,       NULL, IMAGEX_NOT_PIPABLE_OPTION},
+       {T("update-of"),   required_argument, NULL, IMAGEX_UPDATE_OF_OPTION},
        {T("delta-from"),  required_argument, NULL, IMAGEX_DELTA_FROM_OPTION},
        {NULL, 0, NULL, 0},
 };
@@ -364,11 +366,13 @@ verify_image_exists(int image, const tchar *image_name, const tchar *wim_name)
        if (image == WIMLIB_NO_IMAGE) {
                imagex_error(T("\"%"TS"\" is not a valid image in \"%"TS"\"!\n"
                             "       Please specify a 1-based image index or "
-                            "image name.\n"
-                            "       You may use `%"TS"' to list the images "
-                            "contained in a WIM."),
-                            image_name, wim_name, get_cmd_string(CMD_INFO, false));
-               return -1;
+                            "image name.  To list the images\n"
+                            "       contained in the WIM archive, run\n"
+                            "\n"
+                            "           %"TS" \"%"TS"\"\n"),
+                            image_name, wim_name,
+                            get_cmd_string(CMD_INFO, false), wim_name);
+               return WIMLIB_ERR_INVALID_IMAGE;
        }
        return 0;
 }
@@ -378,7 +382,7 @@ verify_image_is_single(int image)
 {
        if (image == WIMLIB_ALL_IMAGES) {
                imagex_error(T("Cannot specify all images for this action!"));
-               return -1;
+               return WIMLIB_ERR_INVALID_IMAGE;
        }
        return 0;
 }
@@ -933,8 +937,8 @@ translate_text_to_tstr(char *text, size_t num_bytes, size_t *num_tchars_ret)
        size_t num_wchars;
 
        if (num_bytes >= 2 &&
-           ((text[0] == 0xff && text[1] == 0xfe) ||
-            (text[0] <= 0x7f && text[1] == 0x00)))
+           (((unsigned char)text[0] == 0xff && (unsigned char)text[1] == 0xfe) ||
+            ((unsigned char)text[0] <= 0x7f && (unsigned char)text[1] == 0x00)))
        {
                /* File begins with 0xfeff, the BOM for UTF-16LE, or it begins
                 * with something that looks like an ASCII character encoded as
@@ -1202,7 +1206,7 @@ imagex_progress_func(enum wimlib_progress_msg msg,
                case WIMLIB_UPDATE_OP_DELETE:
                        imagex_printf(T("Deleted WIM path "
                                  "\""WIMLIB_WIM_PATH_SEPARATOR_STRING "%"TS"\"\n"),
-                               info->update.command->delete.wim_path);
+                               info->update.command->delete_.wim_path);
                        break;
                case WIMLIB_UPDATE_OP_RENAME:
                        imagex_printf(T("Renamed WIM path "
@@ -1271,9 +1275,9 @@ update_command_add_option(int op, const tchar *option,
                break;
        case WIMLIB_UPDATE_OP_DELETE:
                if (!tstrcmp(option, T("--force")))
-                       cmd->delete.delete_flags |= WIMLIB_DELETE_FLAG_FORCE;
+                       cmd->delete_.delete_flags |= WIMLIB_DELETE_FLAG_FORCE;
                else if (!tstrcmp(option, T("--recursive")))
-                       cmd->delete.delete_flags |= WIMLIB_DELETE_FLAG_RECURSIVE;
+                       cmd->delete_.delete_flags |= WIMLIB_DELETE_FLAG_RECURSIVE;
                else
                        recognized = false;
                break;
@@ -1304,7 +1308,7 @@ update_command_add_nonoption(int op, const tchar *nonoption,
                        cmd->add.wim_target_path = (tchar*)nonoption;
                break;
        case WIMLIB_UPDATE_OP_DELETE:
-               cmd->delete.wim_path = (tchar*)nonoption;
+               cmd->delete_.wim_path = (tchar*)nonoption;
                break;
        case WIMLIB_UPDATE_OP_RENAME:
                if (num_nonoptions == 0)
@@ -1451,13 +1455,13 @@ imagex_apply(int argc, tchar **argv, int cmd)
 {
        int c;
        int open_flags = WIMLIB_OPEN_FLAG_SPLIT_OK;
-       int image;
+       int image = WIMLIB_NO_IMAGE;
        WIMStruct *wim;
        struct wimlib_wim_info info;
        int ret;
        const tchar *wimfile;
        const tchar *target;
-       const tchar *image_num_or_name;
+       const tchar *image_num_or_name = NULL;
        int extract_flags = WIMLIB_EXTRACT_FLAG_SEQUENTIAL;
 
        REFGLOB_SET(refglobs);
@@ -1639,9 +1643,15 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
        const tchar *name;
        const tchar *desc;
        const tchar *flags_element = NULL;
-       const tchar *template_image_name_or_num = NULL;
-       int template_image;
+
        WIMStruct *wim;
+       WIMStruct *base_wim;
+       const tchar *base_wimfile = NULL;
+       WIMStruct *template_wim;
+       const tchar *template_wimfile = NULL;
+       const tchar *template_image_name_or_num = NULL;
+       int template_image = WIMLIB_NO_IMAGE;
+
        int ret;
        unsigned num_threads = 0;
 
@@ -1653,7 +1663,7 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
        struct wimlib_capture_config *config;
 
        bool source_list = false;
-       size_t source_list_nchars;
+       size_t source_list_nchars = 0;
        tchar *source_list_contents;
        bool capture_sources_malloced;
        struct wimlib_capture_source *capture_sources;
@@ -1722,13 +1732,38 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                case IMAGEX_NOT_PIPABLE_OPTION:
                        write_flags |= WIMLIB_WRITE_FLAG_NOT_PIPABLE;
                        break;
+               case IMAGEX_UPDATE_OF_OPTION:
+                       if (template_image_name_or_num) {
+                               imagex_error(T("'--update-of' can only be "
+                                              "specified one time!"));
+                               goto out_err;
+                       } else {
+                               tchar *colon;
+                               colon = tstrrchr(optarg, T(':'));
+
+                               if (colon) {
+                                       template_wimfile = optarg;
+                                       *colon = T('\0');
+                                       template_image_name_or_num = colon + 1;
+                               } else {
+                                       template_wimfile = NULL;
+                                       template_image_name_or_num = optarg;
+                               }
+                       }
+                       break;
                case IMAGEX_DELTA_FROM_OPTION:
-                       if (cmd == CMD_CAPTURE) {
-                               imagex_error(T("--delta-from=IMAGE is only "
-                                              "valid for append."));
+                       if (cmd != CMD_CAPTURE) {
+                               imagex_error(T("'--delta-from' is only "
+                                              "valid for capture!"));
                                goto out_usage;
                        }
-                       template_image_name_or_num = optarg;
+                       if (base_wimfile) {
+                               imagex_error(T("'--delta-from' can only be "
+                                              "specified one time!"));
+                               goto out_err;
+                       }
+                       base_wimfile = optarg;
+                       write_flags |= WIMLIB_WRITE_FLAG_SKIP_EXTERNAL_WIMS;
                        break;
                default:
                        goto out_usage;
@@ -1767,6 +1802,26 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                set_fd_to_binary_mode(wim_fd);
        }
 
+       /* If template image was specified using --update-of=IMAGE rather
+        * than --update-of=WIMFILE:IMAGE, set the default WIMFILE.  */
+       if (template_image_name_or_num && !template_wimfile) {
+               if (base_wimfile) {
+                       /* Capturing delta WIM:  default to base WIM.  */
+                       template_wimfile = base_wimfile;
+               } else if (cmd == CMD_APPEND) {
+                       /* Appending to WIM:  default to WIM being appended to.
+                        */
+                       template_wimfile = wimfile;
+               } else {
+                       /* Capturing a normal (non-delta) WIM, so the WIM file
+                        * *must* be explicitly specified.  */
+                       imagex_error(T("For capture of non-delta WIM, "
+                                      "'--update-of' must specify "
+                                      "WIMFILE:IMAGE!"));
+                       goto out_usage;
+               }
+       }
+
        if (argc >= 3) {
                name = argv[2];
                name_defaulted = false;
@@ -1808,8 +1863,7 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                }
                capture_sources_malloced = true;
        } else {
-               /* Set up capture source in non-source-list mode (could be
-                * either "normal" mode or "NTFS mode"--- see the man page). */
+               /* Set up capture source in non-source-list mode.  */
                capture_sources = alloca(sizeof(struct wimlib_capture_source));
                capture_sources[0].fs_source_path = source;
                capture_sources[0].wim_target_path = NULL;
@@ -1820,6 +1874,7 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
        }
 
        if (config_file) {
+               /* Read and parse capture configuration file.  */
                size_t config_len;
 
                config_str = file_get_text_contents(config_file, &config_len);
@@ -1833,9 +1888,13 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                if (ret)
                        goto out_free_config;
        } else {
+               /* No capture configuration file specified; use default
+                * configuration for capturing Windows operating systems.  */
                config = NULL;
+               add_image_flags |= WIMLIB_ADD_FLAG_WINCONFIG;
        }
 
+       /* Open the existing WIM, or create a new one.  */
        if (cmd == CMD_APPEND)
                ret = wimlib_open_wim(wimfile, open_flags, &wim,
                                      imagex_progress_func);
@@ -1845,6 +1904,8 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                goto out_free_config;
 
 #ifndef __WIN32__
+       /* Detect if source is regular file or block device and set NTFS volume
+        * capture mode.  */
        if (!source_list) {
                struct stat stbuf;
 
@@ -1859,16 +1920,16 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                                imagex_error_with_errno(T("Failed to stat "
                                                          "\"%"TS"\""), source);
                                ret = -1;
-                               goto out_wimlib_free;
+                               goto out_free_wim;
                        }
                }
        }
 #endif
 
+       /* If the user did not specify an image name, and the basename of the
+        * source already exists as an image name in the WIM file, append a
+        * suffix to make it unique. */
        if (cmd == CMD_APPEND && name_defaulted) {
-               /* If the user did not specify an image name, and the basename
-                * of the source already exists as an image name in the WIM
-                * file, append a suffix to make it unique. */
                unsigned long conflict_idx;
                tchar *name_end = tstrchr(name, T('\0'));
                for (conflict_idx = 1;
@@ -1879,8 +1940,43 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                }
        }
 
+       /* If capturing a delta WIM, reference resources from the base WIM
+        * before adding the new image.  */
+       if (base_wimfile) {
+               ret = wimlib_open_wim(base_wimfile, open_flags,
+                                     &base_wim, imagex_progress_func);
+               if (ret)
+                       goto out_free_wim;
+
+               imagex_printf(T("Capturing delta WIM based on \"%"TS"\"\n"),
+                             base_wimfile);
+
+               ret = wimlib_reference_resources(wim, &base_wim, 1, 0);
+               if (ret)
+                       goto out_free_base_wim;
+       } else {
+               base_wim = NULL;
+       }
+
+       /* If capturing or appending as an update of an existing (template) image,
+        * open the WIM if needed and parse the image index.  */
        if (template_image_name_or_num) {
-               template_image = wimlib_resolve_image(wim, template_image_name_or_num);
+
+
+               if (template_wimfile == base_wimfile) {
+                       template_wim = base_wim;
+               } else if (template_wimfile == wimfile) {
+                       template_wim = wim;
+               } else {
+                       ret = wimlib_open_wim(template_wimfile, open_flags,
+                                             &template_wim, imagex_progress_func);
+                       if (ret)
+                               goto out_free_base_wim;
+               }
+
+               template_image = wimlib_resolve_image(template_wim,
+                                                     template_image_name_or_num);
+
                if (template_image_name_or_num[0] == T('-')) {
                        tchar *tmp;
                        unsigned long n;
@@ -1897,9 +1993,11 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                }
                ret = verify_image_exists_and_is_single(template_image,
                                                        template_image_name_or_num,
-                                                       wimfile);
+                                                       template_wimfile);
                if (ret)
-                       goto out_wimlib_free;
+                       goto out_free_template_wim;
+       } else {
+               template_wim = NULL;
        }
 
        ret = wimlib_add_image_multisource(wim,
@@ -1910,12 +2008,12 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                                           add_image_flags,
                                           imagex_progress_func);
        if (ret)
-               goto out_wimlib_free;
+               goto out_free_template_wim;
 
        if (desc || flags_element || template_image_name_or_num) {
                /* User provided <DESCRIPTION> or <FLAGS> element, or an image
                 * on which the added one is to be based has been specified with
-                * --delta-from=IMAGE.  Get the index of the image we just
+                * --update-of.  Get the index of the image we just
                 *  added, then use it to call the appropriate functions.  */
                struct wimlib_wim_info info;
 
@@ -1926,23 +2024,28 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                                                          info.image_count,
                                                          desc);
                        if (ret)
-                               goto out_wimlib_free;
+                               goto out_free_template_wim;
                }
 
                if (flags_element) {
                        ret = wimlib_set_image_flags(wim, info.image_count,
                                                     flags_element);
                        if (ret)
-                               goto out_wimlib_free;
+                               goto out_free_template_wim;
                }
 
+               /* Reference template image if the user provided one.  */
                if (template_image_name_or_num) {
+                       imagex_printf(T("Using image %d "
+                                       "from \"%"TS"\" as template\n"),
+                                       template_image, template_wimfile);
                        ret = wimlib_reference_template_image(wim,
                                                              info.image_count,
+                                                             template_wim,
                                                              template_image,
                                                              0, NULL);
                        if (ret)
-                               goto out_wimlib_free;
+                               goto out_free_template_wim;
                }
        }
 
@@ -1960,7 +2063,13 @@ imagex_capture_or_append(int argc, tchar **argv, int cmd)
                                         write_flags, num_threads,
                                         imagex_progress_func);
        }
-out_wimlib_free:
+out_free_template_wim:
+       /* template_wim may alias base_wim or wim.  */
+       if (template_wim != base_wim && template_wim != wim)
+               wimlib_free(template_wim);
+out_free_base_wim:
+       wimlib_free(base_wim);
+out_free_wim:
        wimlib_free(wim);
 out_free_config:
        if (config) {
@@ -2697,8 +2806,7 @@ imagex_info(int argc, tchar **argv, int cmd)
        image = wimlib_resolve_image(wim, image_num_or_name);
        ret = WIMLIB_ERR_INVALID_IMAGE;
        if (image == WIMLIB_NO_IMAGE && tstrcmp(image_num_or_name, T("0"))) {
-               imagex_error(T("The image \"%"TS"\" does not exist in \"%"TS"\""),
-                            image_num_or_name, wimfile);
+               verify_image_exists(image, image_num_or_name, wimfile);
                if (boot) {
                        imagex_error(T("If you would like to set the boot "
                                       "index to 0, specify image \"0\" with "
@@ -3255,8 +3363,7 @@ imagex_update(int argc, tchar **argv, int cmd)
        int open_flags = WIMLIB_OPEN_FLAG_WRITE_ACCESS;
        int write_flags = 0;
        int update_flags = WIMLIB_UPDATE_FLAG_SEND_PROGRESS;
-       int default_add_flags = WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE |
-                               WIMLIB_ADD_FLAG_WINCONFIG;
+       int default_add_flags = WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE;
        int default_delete_flags = 0;
        unsigned num_threads = 0;
        int c;
@@ -3382,6 +3489,7 @@ imagex_update(int argc, tchar **argv, int cmd)
                        goto out_free_config;
        } else {
                config = NULL;
+               default_add_flags |= WIMLIB_ADD_FLAG_WINCONFIG;
        }
 
        /* Read update commands from standard input, or the command string if
@@ -3418,7 +3526,7 @@ imagex_update(int argc, tchar **argv, int cmd)
                        cmds[i].add.config = config;
                        break;
                case WIMLIB_UPDATE_OP_DELETE:
-                       cmds[i].delete.delete_flags |= default_delete_flags;
+                       cmds[i].delete_.delete_flags |= default_delete_flags;
                        break;
                default:
                        break;
@@ -3495,7 +3603,7 @@ T(
 "                    [--dereference] [--config=FILE] [--threads=NUM_THREADS]\n"
 "                    [--rebuild] [--unix-data] [--source-list] [--no-acls]\n"
 "                    [--strict-acls] [--rpfix] [--norpfix] [--pipable]\n"
-"                    [--not-pipable] [--delta-from=IMAGE]\n"
+"                    [--not-pipable] [--update-of=[WIMFILE:]IMAGE]\n"
 ),
 [CMD_APPLY] =
 T(
@@ -3513,6 +3621,7 @@ T(
 "                    [--verbose] [--dereference] [--config=FILE]\n"
 "                    [--threads=NUM_THREADS] [--unix-data] [--source-list]\n"
 "                    [--no-acls] [--strict-acls] [--norpfix] [--pipable]\n"
+"                    [--update-of=[WIMFILE:]IMAGE] [--delta-from=WIMFILE]\n"
 ),
 [CMD_DELETE] =
 T(