builtin/apply: make build_fake_ancestor() return -1 on error
[gitweb.git] / builtin / apply.c
index eb918e583b989beb1030cc8be16f1bf601c6166d..575981bd030823bd361bb5421057e6981a5122c5 100644 (file)
@@ -827,54 +827,56 @@ static int gitdiff_hdrend(struct apply_state *state,
 #define DIFF_OLD_NAME 0
 #define DIFF_NEW_NAME 1
 
-static void gitdiff_verify_name(struct apply_state *state,
-                               const char *line,
-                               int isnull,
-                               char **name,
-                               int side)
+static int gitdiff_verify_name(struct apply_state *state,
+                              const char *line,
+                              int isnull,
+                              char **name,
+                              int side)
 {
        if (!*name && !isnull) {
                *name = find_name(state, line, NULL, state->p_value, TERM_TAB);
-               return;
+               return 0;
        }
 
        if (*name) {
                int len = strlen(*name);
                char *another;
                if (isnull)
-                       die(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"),
-                           *name, state->linenr);
+                       return error(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"),
+                                    *name, state->linenr);
                another = find_name(state, line, NULL, state->p_value, TERM_TAB);
-               if (!another || memcmp(another, *name, len + 1))
-                       die((side == DIFF_NEW_NAME) ?
+               if (!another || memcmp(another, *name, len + 1)) {
+                       free(another);
+                       return error((side == DIFF_NEW_NAME) ?
                            _("git apply: bad git-diff - inconsistent new filename on line %d") :
                            _("git apply: bad git-diff - inconsistent old filename on line %d"), state->linenr);
+               }
                free(another);
        } else {
                /* expect "/dev/null" */
                if (memcmp("/dev/null", line, 9) || line[9] != '\n')
-                       die(_("git apply: bad git-diff - expected /dev/null on line %d"), state->linenr);
+                       return error(_("git apply: bad git-diff - expected /dev/null on line %d"), state->linenr);
        }
+
+       return 0;
 }
 
 static int gitdiff_oldname(struct apply_state *state,
                           const char *line,
                           struct patch *patch)
 {
-       gitdiff_verify_name(state, line,
-                           patch->is_new, &patch->old_name,
-                           DIFF_OLD_NAME);
-       return 0;
+       return gitdiff_verify_name(state, line,
+                                  patch->is_new, &patch->old_name,
+                                  DIFF_OLD_NAME);
 }
 
 static int gitdiff_newname(struct apply_state *state,
                           const char *line,
                           struct patch *patch)
 {
-       gitdiff_verify_name(state, line,
-                           patch->is_delete, &patch->new_name,
-                           DIFF_NEW_NAME);
-       return 0;
+       return gitdiff_verify_name(state, line,
+                                  patch->is_delete, &patch->new_name,
+                                  DIFF_NEW_NAME);
 }
 
 static int gitdiff_oldmode(struct apply_state *state,
@@ -3702,7 +3704,7 @@ static int path_is_beyond_symlink(struct apply_state *state, const char *name_)
        return ret;
 }
 
-static void die_on_unsafe_path(struct patch *patch)
+static int check_unsafe_path(struct patch *patch)
 {
        const char *old_name = NULL;
        const char *new_name = NULL;
@@ -3714,9 +3716,10 @@ static void die_on_unsafe_path(struct patch *patch)
                new_name = patch->new_name;
 
        if (old_name && !verify_path(old_name))
-               die(_("invalid path '%s'"), old_name);
+               return error(_("invalid path '%s'"), old_name);
        if (new_name && !verify_path(new_name))
-               die(_("invalid path '%s'"), new_name);
+               return error(_("invalid path '%s'"), new_name);
+       return 0;
 }
 
 /*
@@ -3806,8 +3809,8 @@ static int check_patch(struct apply_state *state, struct patch *patch)
                }
        }
 
-       if (!state->unsafe_paths)
-               die_on_unsafe_path(patch);
+       if (!state->unsafe_paths && check_unsafe_path(patch))
+               return -128;
 
        /*
         * An attempt to read from or delete a path that is beyond a
@@ -3835,10 +3838,14 @@ static int check_patch_list(struct apply_state *state, struct patch *patch)
        prepare_symlink_changes(state, patch);
        prepare_fn_table(state, patch);
        while (patch) {
+               int res;
                if (state->apply_verbosely)
                        say_patch_name(stderr,
                                       _("Checking patch %s..."), patch);
-               err |= check_patch(state, patch);
+               res = check_patch(state, patch);
+               if (res == -128)
+                       return -128;
+               err |= res;
                patch = patch->next;
        }
        return err;
@@ -3893,11 +3900,12 @@ static int preimage_sha1_in_gitlink_patch(struct patch *p, unsigned char sha1[20
 }
 
 /* Build an index that contains the just the files needed for a 3way merge */
-static void build_fake_ancestor(struct patch *list, const char *filename)
+static int build_fake_ancestor(struct patch *list, const char *filename)
 {
        struct patch *patch;
        struct index_state result = { NULL };
        static struct lock_file lock;
+       int res;
 
        /* Once we start supporting the reverse patch, it may be
         * worth showing the new sha1 prefix, but until then...
@@ -3915,31 +3923,38 @@ static void build_fake_ancestor(struct patch *list, const char *filename)
                        if (!preimage_sha1_in_gitlink_patch(patch, sha1))
                                ; /* ok, the textual part looks sane */
                        else
-                               die("sha1 information is lacking or useless for submodule %s",
-                                   name);
+                               return error("sha1 information is lacking or "
+                                            "useless for submodule %s", name);
                } else if (!get_sha1_blob(patch->old_sha1_prefix, sha1)) {
                        ; /* ok */
                } else if (!patch->lines_added && !patch->lines_deleted) {
                        /* mode-only change: update the current */
                        if (get_current_sha1(patch->old_name, sha1))
-                               die("mode change for %s, which is not "
-                                   "in current HEAD", name);
+                               return error("mode change for %s, which is not "
+                                            "in current HEAD", name);
                } else
-                       die("sha1 information is lacking or useless "
-                           "(%s).", name);
+                       return error("sha1 information is lacking or useless "
+                                    "(%s).", name);
 
                ce = make_cache_entry(patch->old_mode, sha1, name, 0, 0);
                if (!ce)
-                       die(_("make_cache_entry failed for path '%s'"), name);
-               if (add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))
-                       die ("Could not add %s to temporary index", name);
+                       return error(_("make_cache_entry failed for path '%s'"),
+                                    name);
+               if (add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD)) {
+                       free(ce);
+                       return error("Could not add %s to temporary index",
+                                    name);
+               }
        }
 
        hold_lock_file_for_update(&lock, filename, LOCK_DIE_ON_ERROR);
-       if (write_locked_index(&result, &lock, COMMIT_LOCK))
-               die ("Could not write temporary index to %s", filename);
-
+       res = write_locked_index(&result, &lock, COMMIT_LOCK);
        discard_index(&result);
+
+       if (res)
+               return error("Could not write temporary index to %s", filename);
+
+       return 0;
 }
 
 static void stat_patch_list(struct apply_state *state, struct patch *patch)
@@ -4470,11 +4485,16 @@ static int apply_patch(struct apply_state *state,
                goto end;
        }
 
-       if ((state->check || state->apply) &&
-           check_patch_list(state, list) < 0 &&
-           !state->apply_with_reject) {
-               res = -1;
-               goto end;
+       if (state->check || state->apply) {
+               int r = check_patch_list(state, list);
+               if (r == -128) {
+                       res = -128;
+                       goto end;
+               }
+               if (r < 0 && !state->apply_with_reject) {
+                       res = -1;
+                       goto end;
+               }
        }
 
        if (state->apply && write_out_results(state, list)) {
@@ -4483,8 +4503,11 @@ static int apply_patch(struct apply_state *state,
                goto end;
        }
 
-       if (state->fake_ancestor)
-               build_fake_ancestor(list, state->fake_ancestor);
+       if (state->fake_ancestor &&
+           build_fake_ancestor(list, state->fake_ancestor)) {
+               res = -128;
+               goto end;
+       }
 
        if (state->diffstat)
                stat_patch_list(state, list);