sequencer.con commit sha1_file: refactor has_sha1_file_with_flags (e83e71c)
   1#include "cache.h"
   2#include "lockfile.h"
   3#include "sequencer.h"
   4#include "dir.h"
   5#include "object.h"
   6#include "commit.h"
   7#include "tag.h"
   8#include "run-command.h"
   9#include "exec_cmd.h"
  10#include "utf8.h"
  11#include "cache-tree.h"
  12#include "diff.h"
  13#include "revision.h"
  14#include "rerere.h"
  15#include "merge-recursive.h"
  16#include "refs.h"
  17#include "argv-array.h"
  18#include "quote.h"
  19#include "trailer.h"
  20#include "log-tree.h"
  21#include "wt-status.h"
  22
  23#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
  24
  25const char sign_off_header[] = "Signed-off-by: ";
  26static const char cherry_picked_prefix[] = "(cherry picked from commit ";
  27
  28GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
  29
  30static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
  31static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
  32static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
  33static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
  34
  35static GIT_PATH_FUNC(rebase_path, "rebase-merge")
  36/*
  37 * The file containing rebase commands, comments, and empty lines.
  38 * This file is created by "git rebase -i" then edited by the user. As
  39 * the lines are processed, they are removed from the front of this
  40 * file and written to the tail of 'done'.
  41 */
  42static GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
  43/*
  44 * The rebase command lines that have already been processed. A line
  45 * is moved here when it is first handled, before any associated user
  46 * actions.
  47 */
  48static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
  49/*
  50 * The file to keep track of how many commands were already processed (e.g.
  51 * for the prompt).
  52 */
  53static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum");
  54/*
  55 * The file to keep track of how many commands are to be processed in total
  56 * (e.g. for the prompt).
  57 */
  58static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end");
  59/*
  60 * The commit message that is planned to be used for any changes that
  61 * need to be committed following a user interaction.
  62 */
  63static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
  64/*
  65 * The file into which is accumulated the suggested commit message for
  66 * squash/fixup commands. When the first of a series of squash/fixups
  67 * is seen, the file is created and the commit message from the
  68 * previous commit and from the first squash/fixup commit are written
  69 * to it. The commit message for each subsequent squash/fixup commit
  70 * is appended to the file as it is processed.
  71 *
  72 * The first line of the file is of the form
  73 *     # This is a combination of $count commits.
  74 * where $count is the number of commits whose messages have been
  75 * written to the file so far (including the initial "pick" commit).
  76 * Each time that a commit message is processed, this line is read and
  77 * updated. It is deleted just before the combined commit is made.
  78 */
  79static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
  80/*
  81 * If the current series of squash/fixups has not yet included a squash
  82 * command, then this file exists and holds the commit message of the
  83 * original "pick" commit.  (If the series ends without a "squash"
  84 * command, then this can be used as the commit message of the combined
  85 * commit without opening the editor.)
  86 */
  87static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
  88/*
  89 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
  90 * GIT_AUTHOR_DATE that will be used for the commit that is currently
  91 * being rebased.
  92 */
  93static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
  94/*
  95 * When an "edit" rebase command is being processed, the SHA1 of the
  96 * commit to be edited is recorded in this file.  When "git rebase
  97 * --continue" is executed, if there are any staged changes then they
  98 * will be amended to the HEAD commit, but only provided the HEAD
  99 * commit is still the commit to be edited.  When any other rebase
 100 * command is processed, this file is deleted.
 101 */
 102static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
 103/*
 104 * When we stop at a given patch via the "edit" command, this file contains
 105 * the abbreviated commit name of the corresponding patch.
 106 */
 107static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
 108/*
 109 * For the post-rewrite hook, we make a list of rewritten commits and
 110 * their new sha1s.  The rewritten-pending list keeps the sha1s of
 111 * commits that have been processed, but not committed yet,
 112 * e.g. because they are waiting for a 'squash' command.
 113 */
 114static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
 115static GIT_PATH_FUNC(rebase_path_rewritten_pending,
 116        "rebase-merge/rewritten-pending")
 117/*
 118 * The following files are written by git-rebase just after parsing the
 119 * command-line (and are only consumed, not modified, by the sequencer).
 120 */
 121static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
 122static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
 123static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
 124static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
 125static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
 126static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
 127static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
 128static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
 129
 130static inline int is_rebase_i(const struct replay_opts *opts)
 131{
 132        return opts->action == REPLAY_INTERACTIVE_REBASE;
 133}
 134
 135static const char *get_dir(const struct replay_opts *opts)
 136{
 137        if (is_rebase_i(opts))
 138                return rebase_path();
 139        return git_path_seq_dir();
 140}
 141
 142static const char *get_todo_path(const struct replay_opts *opts)
 143{
 144        if (is_rebase_i(opts))
 145                return rebase_path_todo();
 146        return git_path_todo_file();
 147}
 148
 149/*
 150 * Returns 0 for non-conforming footer
 151 * Returns 1 for conforming footer
 152 * Returns 2 when sob exists within conforming footer
 153 * Returns 3 when sob exists within conforming footer as last entry
 154 */
 155static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
 156        int ignore_footer)
 157{
 158        struct trailer_info info;
 159        int i;
 160        int found_sob = 0, found_sob_last = 0;
 161
 162        trailer_info_get(&info, sb->buf);
 163
 164        if (info.trailer_start == info.trailer_end)
 165                return 0;
 166
 167        for (i = 0; i < info.trailer_nr; i++)
 168                if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
 169                        found_sob = 1;
 170                        if (i == info.trailer_nr - 1)
 171                                found_sob_last = 1;
 172                }
 173
 174        trailer_info_release(&info);
 175
 176        if (found_sob_last)
 177                return 3;
 178        if (found_sob)
 179                return 2;
 180        return 1;
 181}
 182
 183static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
 184{
 185        static struct strbuf buf = STRBUF_INIT;
 186
 187        strbuf_reset(&buf);
 188        if (opts->gpg_sign)
 189                sq_quotef(&buf, "-S%s", opts->gpg_sign);
 190        return buf.buf;
 191}
 192
 193int sequencer_remove_state(struct replay_opts *opts)
 194{
 195        struct strbuf dir = STRBUF_INIT;
 196        int i;
 197
 198        free(opts->gpg_sign);
 199        free(opts->strategy);
 200        for (i = 0; i < opts->xopts_nr; i++)
 201                free(opts->xopts[i]);
 202        free(opts->xopts);
 203
 204        strbuf_addf(&dir, "%s", get_dir(opts));
 205        remove_dir_recursively(&dir, 0);
 206        strbuf_release(&dir);
 207
 208        return 0;
 209}
 210
 211static const char *action_name(const struct replay_opts *opts)
 212{
 213        switch (opts->action) {
 214        case REPLAY_REVERT:
 215                return N_("revert");
 216        case REPLAY_PICK:
 217                return N_("cherry-pick");
 218        case REPLAY_INTERACTIVE_REBASE:
 219                return N_("rebase -i");
 220        }
 221        die(_("Unknown action: %d"), opts->action);
 222}
 223
 224struct commit_message {
 225        char *parent_label;
 226        char *label;
 227        char *subject;
 228        const char *message;
 229};
 230
 231static const char *short_commit_name(struct commit *commit)
 232{
 233        return find_unique_abbrev(commit->object.oid.hash, DEFAULT_ABBREV);
 234}
 235
 236static int get_message(struct commit *commit, struct commit_message *out)
 237{
 238        const char *abbrev, *subject;
 239        int subject_len;
 240
 241        out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
 242        abbrev = short_commit_name(commit);
 243
 244        subject_len = find_commit_subject(out->message, &subject);
 245
 246        out->subject = xmemdupz(subject, subject_len);
 247        out->label = xstrfmt("%s... %s", abbrev, out->subject);
 248        out->parent_label = xstrfmt("parent of %s", out->label);
 249
 250        return 0;
 251}
 252
 253static void free_message(struct commit *commit, struct commit_message *msg)
 254{
 255        free(msg->parent_label);
 256        free(msg->label);
 257        free(msg->subject);
 258        unuse_commit_buffer(commit, msg->message);
 259}
 260
 261static void print_advice(int show_hint, struct replay_opts *opts)
 262{
 263        char *msg = getenv("GIT_CHERRY_PICK_HELP");
 264
 265        if (msg) {
 266                fprintf(stderr, "%s\n", msg);
 267                /*
 268                 * A conflict has occurred but the porcelain
 269                 * (typically rebase --interactive) wants to take care
 270                 * of the commit itself so remove CHERRY_PICK_HEAD
 271                 */
 272                unlink(git_path_cherry_pick_head());
 273                return;
 274        }
 275
 276        if (show_hint) {
 277                if (opts->no_commit)
 278                        advise(_("after resolving the conflicts, mark the corrected paths\n"
 279                                 "with 'git add <paths>' or 'git rm <paths>'"));
 280                else
 281                        advise(_("after resolving the conflicts, mark the corrected paths\n"
 282                                 "with 'git add <paths>' or 'git rm <paths>'\n"
 283                                 "and commit the result with 'git commit'"));
 284        }
 285}
 286
 287static int write_message(const void *buf, size_t len, const char *filename,
 288                         int append_eol)
 289{
 290        static struct lock_file msg_file;
 291
 292        int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
 293        if (msg_fd < 0)
 294                return error_errno(_("could not lock '%s'"), filename);
 295        if (write_in_full(msg_fd, buf, len) < 0) {
 296                rollback_lock_file(&msg_file);
 297                return error_errno(_("could not write to '%s'"), filename);
 298        }
 299        if (append_eol && write(msg_fd, "\n", 1) < 0) {
 300                rollback_lock_file(&msg_file);
 301                return error_errno(_("could not write eol to '%s'"), filename);
 302        }
 303        if (commit_lock_file(&msg_file) < 0) {
 304                rollback_lock_file(&msg_file);
 305                return error(_("failed to finalize '%s'."), filename);
 306        }
 307
 308        return 0;
 309}
 310
 311/*
 312 * Reads a file that was presumably written by a shell script, i.e. with an
 313 * end-of-line marker that needs to be stripped.
 314 *
 315 * Note that only the last end-of-line marker is stripped, consistent with the
 316 * behavior of "$(cat path)" in a shell script.
 317 *
 318 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
 319 */
 320static int read_oneliner(struct strbuf *buf,
 321        const char *path, int skip_if_empty)
 322{
 323        int orig_len = buf->len;
 324
 325        if (!file_exists(path))
 326                return 0;
 327
 328        if (strbuf_read_file(buf, path, 0) < 0) {
 329                warning_errno(_("could not read '%s'"), path);
 330                return 0;
 331        }
 332
 333        if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
 334                if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
 335                        --buf->len;
 336                buf->buf[buf->len] = '\0';
 337        }
 338
 339        if (skip_if_empty && buf->len == orig_len)
 340                return 0;
 341
 342        return 1;
 343}
 344
 345static struct tree *empty_tree(void)
 346{
 347        return lookup_tree(&empty_tree_oid);
 348}
 349
 350static int error_dirty_index(struct replay_opts *opts)
 351{
 352        if (read_cache_unmerged())
 353                return error_resolve_conflict(_(action_name(opts)));
 354
 355        error(_("your local changes would be overwritten by %s."),
 356                _(action_name(opts)));
 357
 358        if (advice_commit_before_merge)
 359                advise(_("commit your changes or stash them to proceed."));
 360        return -1;
 361}
 362
 363static void update_abort_safety_file(void)
 364{
 365        struct object_id head;
 366
 367        /* Do nothing on a single-pick */
 368        if (!file_exists(git_path_seq_dir()))
 369                return;
 370
 371        if (!get_oid("HEAD", &head))
 372                write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
 373        else
 374                write_file(git_path_abort_safety_file(), "%s", "");
 375}
 376
 377static int fast_forward_to(const struct object_id *to, const struct object_id *from,
 378                        int unborn, struct replay_opts *opts)
 379{
 380        struct ref_transaction *transaction;
 381        struct strbuf sb = STRBUF_INIT;
 382        struct strbuf err = STRBUF_INIT;
 383
 384        read_cache();
 385        if (checkout_fast_forward(from, to, 1))
 386                return -1; /* the callee should have complained already */
 387
 388        strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
 389
 390        transaction = ref_transaction_begin(&err);
 391        if (!transaction ||
 392            ref_transaction_update(transaction, "HEAD",
 393                                   to->hash, unborn ? null_sha1 : from->hash,
 394                                   0, sb.buf, &err) ||
 395            ref_transaction_commit(transaction, &err)) {
 396                ref_transaction_free(transaction);
 397                error("%s", err.buf);
 398                strbuf_release(&sb);
 399                strbuf_release(&err);
 400                return -1;
 401        }
 402
 403        strbuf_release(&sb);
 404        strbuf_release(&err);
 405        ref_transaction_free(transaction);
 406        update_abort_safety_file();
 407        return 0;
 408}
 409
 410void append_conflicts_hint(struct strbuf *msgbuf)
 411{
 412        int i;
 413
 414        strbuf_addch(msgbuf, '\n');
 415        strbuf_commented_addf(msgbuf, "Conflicts:\n");
 416        for (i = 0; i < active_nr;) {
 417                const struct cache_entry *ce = active_cache[i++];
 418                if (ce_stage(ce)) {
 419                        strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
 420                        while (i < active_nr && !strcmp(ce->name,
 421                                                        active_cache[i]->name))
 422                                i++;
 423                }
 424        }
 425}
 426
 427static int do_recursive_merge(struct commit *base, struct commit *next,
 428                              const char *base_label, const char *next_label,
 429                              struct object_id *head, struct strbuf *msgbuf,
 430                              struct replay_opts *opts)
 431{
 432        struct merge_options o;
 433        struct tree *result, *next_tree, *base_tree, *head_tree;
 434        int clean;
 435        char **xopt;
 436        static struct lock_file index_lock;
 437
 438        hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
 439
 440        read_cache();
 441
 442        init_merge_options(&o);
 443        o.ancestor = base ? base_label : "(empty tree)";
 444        o.branch1 = "HEAD";
 445        o.branch2 = next ? next_label : "(empty tree)";
 446        if (is_rebase_i(opts))
 447                o.buffer_output = 2;
 448
 449        head_tree = parse_tree_indirect(head);
 450        next_tree = next ? next->tree : empty_tree();
 451        base_tree = base ? base->tree : empty_tree();
 452
 453        for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
 454                parse_merge_opt(&o, *xopt);
 455
 456        clean = merge_trees(&o,
 457                            head_tree,
 458                            next_tree, base_tree, &result);
 459        if (is_rebase_i(opts) && clean <= 0)
 460                fputs(o.obuf.buf, stdout);
 461        strbuf_release(&o.obuf);
 462        if (clean < 0)
 463                return clean;
 464
 465        if (active_cache_changed &&
 466            write_locked_index(&the_index, &index_lock, COMMIT_LOCK))
 467                /*
 468                 * TRANSLATORS: %s will be "revert", "cherry-pick" or
 469                 * "rebase -i".
 470                 */
 471                return error(_("%s: Unable to write new index file"),
 472                        _(action_name(opts)));
 473        rollback_lock_file(&index_lock);
 474
 475        if (opts->signoff)
 476                append_signoff(msgbuf, 0, 0);
 477
 478        if (!clean)
 479                append_conflicts_hint(msgbuf);
 480
 481        return !clean;
 482}
 483
 484static int is_index_unchanged(void)
 485{
 486        struct object_id head_oid;
 487        struct commit *head_commit;
 488
 489        if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, head_oid.hash, NULL))
 490                return error(_("could not resolve HEAD commit\n"));
 491
 492        head_commit = lookup_commit(&head_oid);
 493
 494        /*
 495         * If head_commit is NULL, check_commit, called from
 496         * lookup_commit, would have indicated that head_commit is not
 497         * a commit object already.  parse_commit() will return failure
 498         * without further complaints in such a case.  Otherwise, if
 499         * the commit is invalid, parse_commit() will complain.  So
 500         * there is nothing for us to say here.  Just return failure.
 501         */
 502        if (parse_commit(head_commit))
 503                return -1;
 504
 505        if (!active_cache_tree)
 506                active_cache_tree = cache_tree();
 507
 508        if (!cache_tree_fully_valid(active_cache_tree))
 509                if (cache_tree_update(&the_index, 0))
 510                        return error(_("unable to update cache tree\n"));
 511
 512        return !oidcmp(&active_cache_tree->oid,
 513                       &head_commit->tree->object.oid);
 514}
 515
 516static int write_author_script(const char *message)
 517{
 518        struct strbuf buf = STRBUF_INIT;
 519        const char *eol;
 520        int res;
 521
 522        for (;;)
 523                if (!*message || starts_with(message, "\n")) {
 524missing_author:
 525                        /* Missing 'author' line? */
 526                        unlink(rebase_path_author_script());
 527                        return 0;
 528                } else if (skip_prefix(message, "author ", &message))
 529                        break;
 530                else if ((eol = strchr(message, '\n')))
 531                        message = eol + 1;
 532                else
 533                        goto missing_author;
 534
 535        strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
 536        while (*message && *message != '\n' && *message != '\r')
 537                if (skip_prefix(message, " <", &message))
 538                        break;
 539                else if (*message != '\'')
 540                        strbuf_addch(&buf, *(message++));
 541                else
 542                        strbuf_addf(&buf, "'\\\\%c'", *(message++));
 543        strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
 544        while (*message && *message != '\n' && *message != '\r')
 545                if (skip_prefix(message, "> ", &message))
 546                        break;
 547                else if (*message != '\'')
 548                        strbuf_addch(&buf, *(message++));
 549                else
 550                        strbuf_addf(&buf, "'\\\\%c'", *(message++));
 551        strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
 552        while (*message && *message != '\n' && *message != '\r')
 553                if (*message != '\'')
 554                        strbuf_addch(&buf, *(message++));
 555                else
 556                        strbuf_addf(&buf, "'\\\\%c'", *(message++));
 557        res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
 558        strbuf_release(&buf);
 559        return res;
 560}
 561
 562/*
 563 * Read a list of environment variable assignments (such as the author-script
 564 * file) into an environment block. Returns -1 on error, 0 otherwise.
 565 */
 566static int read_env_script(struct argv_array *env)
 567{
 568        struct strbuf script = STRBUF_INIT;
 569        int i, count = 0;
 570        char *p, *p2;
 571
 572        if (strbuf_read_file(&script, rebase_path_author_script(), 256) <= 0)
 573                return -1;
 574
 575        for (p = script.buf; *p; p++)
 576                if (skip_prefix(p, "'\\\\''", (const char **)&p2))
 577                        strbuf_splice(&script, p - script.buf, p2 - p, "'", 1);
 578                else if (*p == '\'')
 579                        strbuf_splice(&script, p-- - script.buf, 1, "", 0);
 580                else if (*p == '\n') {
 581                        *p = '\0';
 582                        count++;
 583                }
 584
 585        for (i = 0, p = script.buf; i < count; i++) {
 586                argv_array_push(env, p);
 587                p += strlen(p) + 1;
 588        }
 589
 590        return 0;
 591}
 592
 593static const char staged_changes_advice[] =
 594N_("you have staged changes in your working tree\n"
 595"If these changes are meant to be squashed into the previous commit, run:\n"
 596"\n"
 597"  git commit --amend %s\n"
 598"\n"
 599"If they are meant to go into a new commit, run:\n"
 600"\n"
 601"  git commit %s\n"
 602"\n"
 603"In both cases, once you're done, continue with:\n"
 604"\n"
 605"  git rebase --continue\n");
 606
 607#define ALLOW_EMPTY (1<<0)
 608#define EDIT_MSG    (1<<1)
 609#define AMEND_MSG   (1<<2)
 610#define CLEANUP_MSG (1<<3)
 611#define VERIFY_MSG  (1<<4)
 612
 613/*
 614 * If we are cherry-pick, and if the merge did not result in
 615 * hand-editing, we will hit this commit and inherit the original
 616 * author date and name.
 617 *
 618 * If we are revert, or if our cherry-pick results in a hand merge,
 619 * we had better say that the current user is responsible for that.
 620 *
 621 * An exception is when run_git_commit() is called during an
 622 * interactive rebase: in that case, we will want to retain the
 623 * author metadata.
 624 */
 625static int run_git_commit(const char *defmsg, struct replay_opts *opts,
 626                          unsigned int flags)
 627{
 628        struct child_process cmd = CHILD_PROCESS_INIT;
 629        const char *value;
 630
 631        cmd.git_cmd = 1;
 632
 633        if (is_rebase_i(opts)) {
 634                if (!(flags & EDIT_MSG)) {
 635                        cmd.stdout_to_stderr = 1;
 636                        cmd.err = -1;
 637                }
 638
 639                if (read_env_script(&cmd.env_array)) {
 640                        const char *gpg_opt = gpg_sign_opt_quoted(opts);
 641
 642                        return error(_(staged_changes_advice),
 643                                     gpg_opt, gpg_opt);
 644                }
 645        }
 646
 647        argv_array_push(&cmd.args, "commit");
 648
 649        if (!(flags & VERIFY_MSG))
 650                argv_array_push(&cmd.args, "-n");
 651        if ((flags & AMEND_MSG))
 652                argv_array_push(&cmd.args, "--amend");
 653        if (opts->gpg_sign)
 654                argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
 655        if (opts->signoff)
 656                argv_array_push(&cmd.args, "-s");
 657        if (defmsg)
 658                argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
 659        if ((flags & CLEANUP_MSG))
 660                argv_array_push(&cmd.args, "--cleanup=strip");
 661        if ((flags & EDIT_MSG))
 662                argv_array_push(&cmd.args, "-e");
 663        else if (!(flags & CLEANUP_MSG) &&
 664                 !opts->signoff && !opts->record_origin &&
 665                 git_config_get_value("commit.cleanup", &value))
 666                argv_array_push(&cmd.args, "--cleanup=verbatim");
 667
 668        if ((flags & ALLOW_EMPTY))
 669                argv_array_push(&cmd.args, "--allow-empty");
 670
 671        if (opts->allow_empty_message)
 672                argv_array_push(&cmd.args, "--allow-empty-message");
 673
 674        if (cmd.err == -1) {
 675                /* hide stderr on success */
 676                struct strbuf buf = STRBUF_INIT;
 677                int rc = pipe_command(&cmd,
 678                                      NULL, 0,
 679                                      /* stdout is already redirected */
 680                                      NULL, 0,
 681                                      &buf, 0);
 682                if (rc)
 683                        fputs(buf.buf, stderr);
 684                strbuf_release(&buf);
 685                return rc;
 686        }
 687
 688        return run_command(&cmd);
 689}
 690
 691static int is_original_commit_empty(struct commit *commit)
 692{
 693        const unsigned char *ptree_sha1;
 694
 695        if (parse_commit(commit))
 696                return error(_("could not parse commit %s\n"),
 697                             oid_to_hex(&commit->object.oid));
 698        if (commit->parents) {
 699                struct commit *parent = commit->parents->item;
 700                if (parse_commit(parent))
 701                        return error(_("could not parse parent commit %s\n"),
 702                                oid_to_hex(&parent->object.oid));
 703                ptree_sha1 = parent->tree->object.oid.hash;
 704        } else {
 705                ptree_sha1 = EMPTY_TREE_SHA1_BIN; /* commit is root */
 706        }
 707
 708        return !hashcmp(ptree_sha1, commit->tree->object.oid.hash);
 709}
 710
 711/*
 712 * Do we run "git commit" with "--allow-empty"?
 713 */
 714static int allow_empty(struct replay_opts *opts, struct commit *commit)
 715{
 716        int index_unchanged, empty_commit;
 717
 718        /*
 719         * Three cases:
 720         *
 721         * (1) we do not allow empty at all and error out.
 722         *
 723         * (2) we allow ones that were initially empty, but
 724         * forbid the ones that become empty;
 725         *
 726         * (3) we allow both.
 727         */
 728        if (!opts->allow_empty)
 729                return 0; /* let "git commit" barf as necessary */
 730
 731        index_unchanged = is_index_unchanged();
 732        if (index_unchanged < 0)
 733                return index_unchanged;
 734        if (!index_unchanged)
 735                return 0; /* we do not have to say --allow-empty */
 736
 737        if (opts->keep_redundant_commits)
 738                return 1;
 739
 740        empty_commit = is_original_commit_empty(commit);
 741        if (empty_commit < 0)
 742                return empty_commit;
 743        if (!empty_commit)
 744                return 0;
 745        else
 746                return 1;
 747}
 748
 749/*
 750 * Note that ordering matters in this enum. Not only must it match the mapping
 751 * below, it is also divided into several sections that matter.  When adding
 752 * new commands, make sure you add it in the right section.
 753 */
 754enum todo_command {
 755        /* commands that handle commits */
 756        TODO_PICK = 0,
 757        TODO_REVERT,
 758        TODO_EDIT,
 759        TODO_REWORD,
 760        TODO_FIXUP,
 761        TODO_SQUASH,
 762        /* commands that do something else than handling a single commit */
 763        TODO_EXEC,
 764        /* commands that do nothing but are counted for reporting progress */
 765        TODO_NOOP,
 766        TODO_DROP,
 767        /* comments (not counted for reporting progress) */
 768        TODO_COMMENT
 769};
 770
 771static struct {
 772        char c;
 773        const char *str;
 774} todo_command_info[] = {
 775        { 'p', "pick" },
 776        { 0,   "revert" },
 777        { 'e', "edit" },
 778        { 'r', "reword" },
 779        { 'f', "fixup" },
 780        { 's', "squash" },
 781        { 'x', "exec" },
 782        { 0,   "noop" },
 783        { 'd', "drop" },
 784        { 0,   NULL }
 785};
 786
 787static const char *command_to_string(const enum todo_command command)
 788{
 789        if (command < TODO_COMMENT)
 790                return todo_command_info[command].str;
 791        die("Unknown command: %d", command);
 792}
 793
 794static int is_noop(const enum todo_command command)
 795{
 796        return TODO_NOOP <= command;
 797}
 798
 799static int is_fixup(enum todo_command command)
 800{
 801        return command == TODO_FIXUP || command == TODO_SQUASH;
 802}
 803
 804static int update_squash_messages(enum todo_command command,
 805                struct commit *commit, struct replay_opts *opts)
 806{
 807        struct strbuf buf = STRBUF_INIT;
 808        int count, res;
 809        const char *message, *body;
 810
 811        if (file_exists(rebase_path_squash_msg())) {
 812                struct strbuf header = STRBUF_INIT;
 813                char *eol, *p;
 814
 815                if (strbuf_read_file(&buf, rebase_path_squash_msg(), 2048) <= 0)
 816                        return error(_("could not read '%s'"),
 817                                rebase_path_squash_msg());
 818
 819                p = buf.buf + 1;
 820                eol = strchrnul(buf.buf, '\n');
 821                if (buf.buf[0] != comment_line_char ||
 822                    (p += strcspn(p, "0123456789\n")) == eol)
 823                        return error(_("unexpected 1st line of squash message:"
 824                                       "\n\n\t%.*s"),
 825                                     (int)(eol - buf.buf), buf.buf);
 826                count = strtol(p, NULL, 10);
 827
 828                if (count < 1)
 829                        return error(_("invalid 1st line of squash message:\n"
 830                                       "\n\t%.*s"),
 831                                     (int)(eol - buf.buf), buf.buf);
 832
 833                strbuf_addf(&header, "%c ", comment_line_char);
 834                strbuf_addf(&header,
 835                            _("This is a combination of %d commits."), ++count);
 836                strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
 837                strbuf_release(&header);
 838        } else {
 839                struct object_id head;
 840                struct commit *head_commit;
 841                const char *head_message, *body;
 842
 843                if (get_oid("HEAD", &head))
 844                        return error(_("need a HEAD to fixup"));
 845                if (!(head_commit = lookup_commit_reference(&head)))
 846                        return error(_("could not read HEAD"));
 847                if (!(head_message = get_commit_buffer(head_commit, NULL)))
 848                        return error(_("could not read HEAD's commit message"));
 849
 850                find_commit_subject(head_message, &body);
 851                if (write_message(body, strlen(body),
 852                                  rebase_path_fixup_msg(), 0)) {
 853                        unuse_commit_buffer(head_commit, head_message);
 854                        return error(_("cannot write '%s'"),
 855                                     rebase_path_fixup_msg());
 856                }
 857
 858                count = 2;
 859                strbuf_addf(&buf, "%c ", comment_line_char);
 860                strbuf_addf(&buf, _("This is a combination of %d commits."),
 861                            count);
 862                strbuf_addf(&buf, "\n%c ", comment_line_char);
 863                strbuf_addstr(&buf, _("This is the 1st commit message:"));
 864                strbuf_addstr(&buf, "\n\n");
 865                strbuf_addstr(&buf, body);
 866
 867                unuse_commit_buffer(head_commit, head_message);
 868        }
 869
 870        if (!(message = get_commit_buffer(commit, NULL)))
 871                return error(_("could not read commit message of %s"),
 872                             oid_to_hex(&commit->object.oid));
 873        find_commit_subject(message, &body);
 874
 875        if (command == TODO_SQUASH) {
 876                unlink(rebase_path_fixup_msg());
 877                strbuf_addf(&buf, "\n%c ", comment_line_char);
 878                strbuf_addf(&buf, _("This is the commit message #%d:"), count);
 879                strbuf_addstr(&buf, "\n\n");
 880                strbuf_addstr(&buf, body);
 881        } else if (command == TODO_FIXUP) {
 882                strbuf_addf(&buf, "\n%c ", comment_line_char);
 883                strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
 884                            count);
 885                strbuf_addstr(&buf, "\n\n");
 886                strbuf_add_commented_lines(&buf, body, strlen(body));
 887        } else
 888                return error(_("unknown command: %d"), command);
 889        unuse_commit_buffer(commit, message);
 890
 891        res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
 892        strbuf_release(&buf);
 893        return res;
 894}
 895
 896static void flush_rewritten_pending(void) {
 897        struct strbuf buf = STRBUF_INIT;
 898        unsigned char newsha1[20];
 899        FILE *out;
 900
 901        if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), 82) > 0 &&
 902            !get_sha1("HEAD", newsha1) &&
 903            (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
 904                char *bol = buf.buf, *eol;
 905
 906                while (*bol) {
 907                        eol = strchrnul(bol, '\n');
 908                        fprintf(out, "%.*s %s\n", (int)(eol - bol),
 909                                        bol, sha1_to_hex(newsha1));
 910                        if (!*eol)
 911                                break;
 912                        bol = eol + 1;
 913                }
 914                fclose(out);
 915                unlink(rebase_path_rewritten_pending());
 916        }
 917        strbuf_release(&buf);
 918}
 919
 920static void record_in_rewritten(struct object_id *oid,
 921                enum todo_command next_command) {
 922        FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
 923
 924        if (!out)
 925                return;
 926
 927        fprintf(out, "%s\n", oid_to_hex(oid));
 928        fclose(out);
 929
 930        if (!is_fixup(next_command))
 931                flush_rewritten_pending();
 932}
 933
 934static int do_pick_commit(enum todo_command command, struct commit *commit,
 935                struct replay_opts *opts, int final_fixup)
 936{
 937        unsigned int flags = opts->edit ? EDIT_MSG : 0;
 938        const char *msg_file = opts->edit ? NULL : git_path_merge_msg();
 939        struct object_id head;
 940        struct commit *base, *next, *parent;
 941        const char *base_label, *next_label;
 942        struct commit_message msg = { NULL, NULL, NULL, NULL };
 943        struct strbuf msgbuf = STRBUF_INIT;
 944        int res, unborn = 0, allow;
 945
 946        if (opts->no_commit) {
 947                /*
 948                 * We do not intend to commit immediately.  We just want to
 949                 * merge the differences in, so let's compute the tree
 950                 * that represents the "current" state for merge-recursive
 951                 * to work on.
 952                 */
 953                if (write_cache_as_tree(head.hash, 0, NULL))
 954                        return error(_("your index file is unmerged."));
 955        } else {
 956                unborn = get_oid("HEAD", &head);
 957                if (unborn)
 958                        oidcpy(&head, &empty_tree_oid);
 959                if (index_differs_from(unborn ? EMPTY_TREE_SHA1_HEX : "HEAD", 0, 0))
 960                        return error_dirty_index(opts);
 961        }
 962        discard_cache();
 963
 964        if (!commit->parents)
 965                parent = NULL;
 966        else if (commit->parents->next) {
 967                /* Reverting or cherry-picking a merge commit */
 968                int cnt;
 969                struct commit_list *p;
 970
 971                if (!opts->mainline)
 972                        return error(_("commit %s is a merge but no -m option was given."),
 973                                oid_to_hex(&commit->object.oid));
 974
 975                for (cnt = 1, p = commit->parents;
 976                     cnt != opts->mainline && p;
 977                     cnt++)
 978                        p = p->next;
 979                if (cnt != opts->mainline || !p)
 980                        return error(_("commit %s does not have parent %d"),
 981                                oid_to_hex(&commit->object.oid), opts->mainline);
 982                parent = p->item;
 983        } else if (0 < opts->mainline)
 984                return error(_("mainline was specified but commit %s is not a merge."),
 985                        oid_to_hex(&commit->object.oid));
 986        else
 987                parent = commit->parents->item;
 988
 989        if (get_message(commit, &msg) != 0)
 990                return error(_("cannot get commit message for %s"),
 991                        oid_to_hex(&commit->object.oid));
 992
 993        if (opts->allow_ff && !is_fixup(command) &&
 994            ((parent && !oidcmp(&parent->object.oid, &head)) ||
 995             (!parent && unborn))) {
 996                if (is_rebase_i(opts))
 997                        write_author_script(msg.message);
 998                res = fast_forward_to(&commit->object.oid, &head, unborn,
 999                        opts);
1000                if (res || command != TODO_REWORD)
1001                        goto leave;
1002                flags |= EDIT_MSG | AMEND_MSG;
1003                if (command == TODO_REWORD)
1004                        flags |= VERIFY_MSG;
1005                msg_file = NULL;
1006                goto fast_forward_edit;
1007        }
1008        if (parent && parse_commit(parent) < 0)
1009                /* TRANSLATORS: The first %s will be a "todo" command like
1010                   "revert" or "pick", the second %s a SHA1. */
1011                return error(_("%s: cannot parse parent commit %s"),
1012                        command_to_string(command),
1013                        oid_to_hex(&parent->object.oid));
1014
1015        /*
1016         * "commit" is an existing commit.  We would want to apply
1017         * the difference it introduces since its first parent "prev"
1018         * on top of the current HEAD if we are cherry-pick.  Or the
1019         * reverse of it if we are revert.
1020         */
1021
1022        if (command == TODO_REVERT) {
1023                base = commit;
1024                base_label = msg.label;
1025                next = parent;
1026                next_label = msg.parent_label;
1027                strbuf_addstr(&msgbuf, "Revert \"");
1028                strbuf_addstr(&msgbuf, msg.subject);
1029                strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1030                strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1031
1032                if (commit->parents && commit->parents->next) {
1033                        strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1034                        strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1035                }
1036                strbuf_addstr(&msgbuf, ".\n");
1037        } else {
1038                const char *p;
1039
1040                base = parent;
1041                base_label = msg.parent_label;
1042                next = commit;
1043                next_label = msg.label;
1044
1045                /* Append the commit log message to msgbuf. */
1046                if (find_commit_subject(msg.message, &p))
1047                        strbuf_addstr(&msgbuf, p);
1048
1049                if (opts->record_origin) {
1050                        strbuf_complete_line(&msgbuf);
1051                        if (!has_conforming_footer(&msgbuf, NULL, 0))
1052                                strbuf_addch(&msgbuf, '\n');
1053                        strbuf_addstr(&msgbuf, cherry_picked_prefix);
1054                        strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1055                        strbuf_addstr(&msgbuf, ")\n");
1056                }
1057        }
1058
1059        if (command == TODO_REWORD)
1060                flags |= EDIT_MSG | VERIFY_MSG;
1061        else if (is_fixup(command)) {
1062                if (update_squash_messages(command, commit, opts))
1063                        return -1;
1064                flags |= AMEND_MSG;
1065                if (!final_fixup)
1066                        msg_file = rebase_path_squash_msg();
1067                else if (file_exists(rebase_path_fixup_msg())) {
1068                        flags |= CLEANUP_MSG;
1069                        msg_file = rebase_path_fixup_msg();
1070                } else {
1071                        const char *dest = git_path_squash_msg();
1072                        unlink(dest);
1073                        if (copy_file(dest, rebase_path_squash_msg(), 0666))
1074                                return error(_("could not rename '%s' to '%s'"),
1075                                             rebase_path_squash_msg(), dest);
1076                        unlink(git_path_merge_msg());
1077                        msg_file = dest;
1078                        flags |= EDIT_MSG;
1079                }
1080        }
1081
1082        if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1083                res = -1;
1084        else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1085                res = do_recursive_merge(base, next, base_label, next_label,
1086                                         &head, &msgbuf, opts);
1087                if (res < 0)
1088                        return res;
1089                res |= write_message(msgbuf.buf, msgbuf.len,
1090                                     git_path_merge_msg(), 0);
1091        } else {
1092                struct commit_list *common = NULL;
1093                struct commit_list *remotes = NULL;
1094
1095                res = write_message(msgbuf.buf, msgbuf.len,
1096                                    git_path_merge_msg(), 0);
1097
1098                commit_list_insert(base, &common);
1099                commit_list_insert(next, &remotes);
1100                res |= try_merge_command(opts->strategy,
1101                                         opts->xopts_nr, (const char **)opts->xopts,
1102                                        common, oid_to_hex(&head), remotes);
1103                free_commit_list(common);
1104                free_commit_list(remotes);
1105        }
1106        strbuf_release(&msgbuf);
1107
1108        /*
1109         * If the merge was clean or if it failed due to conflict, we write
1110         * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1111         * However, if the merge did not even start, then we don't want to
1112         * write it at all.
1113         */
1114        if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1115            update_ref(NULL, "CHERRY_PICK_HEAD", commit->object.oid.hash, NULL,
1116                       REF_NODEREF, UPDATE_REFS_MSG_ON_ERR))
1117                res = -1;
1118        if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1119            update_ref(NULL, "REVERT_HEAD", commit->object.oid.hash, NULL,
1120                       REF_NODEREF, UPDATE_REFS_MSG_ON_ERR))
1121                res = -1;
1122
1123        if (res) {
1124                error(command == TODO_REVERT
1125                      ? _("could not revert %s... %s")
1126                      : _("could not apply %s... %s"),
1127                      short_commit_name(commit), msg.subject);
1128                print_advice(res == 1, opts);
1129                rerere(opts->allow_rerere_auto);
1130                goto leave;
1131        }
1132
1133        allow = allow_empty(opts, commit);
1134        if (allow < 0) {
1135                res = allow;
1136                goto leave;
1137        } else if (allow)
1138                flags |= ALLOW_EMPTY;
1139        if (!opts->no_commit)
1140fast_forward_edit:
1141                res = run_git_commit(msg_file, opts, flags);
1142
1143        if (!res && final_fixup) {
1144                unlink(rebase_path_fixup_msg());
1145                unlink(rebase_path_squash_msg());
1146        }
1147
1148leave:
1149        free_message(commit, &msg);
1150        update_abort_safety_file();
1151
1152        return res;
1153}
1154
1155static int prepare_revs(struct replay_opts *opts)
1156{
1157        /*
1158         * picking (but not reverting) ranges (but not individual revisions)
1159         * should be done in reverse
1160         */
1161        if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1162                opts->revs->reverse ^= 1;
1163
1164        if (prepare_revision_walk(opts->revs))
1165                return error(_("revision walk setup failed"));
1166
1167        if (!opts->revs->commits)
1168                return error(_("empty commit set passed"));
1169        return 0;
1170}
1171
1172static int read_and_refresh_cache(struct replay_opts *opts)
1173{
1174        static struct lock_file index_lock;
1175        int index_fd = hold_locked_index(&index_lock, 0);
1176        if (read_index_preload(&the_index, NULL) < 0) {
1177                rollback_lock_file(&index_lock);
1178                return error(_("git %s: failed to read the index"),
1179                        _(action_name(opts)));
1180        }
1181        refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
1182        if (the_index.cache_changed && index_fd >= 0) {
1183                if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK)) {
1184                        rollback_lock_file(&index_lock);
1185                        return error(_("git %s: failed to refresh the index"),
1186                                _(action_name(opts)));
1187                }
1188        }
1189        rollback_lock_file(&index_lock);
1190        return 0;
1191}
1192
1193struct todo_item {
1194        enum todo_command command;
1195        struct commit *commit;
1196        const char *arg;
1197        int arg_len;
1198        size_t offset_in_buf;
1199};
1200
1201struct todo_list {
1202        struct strbuf buf;
1203        struct todo_item *items;
1204        int nr, alloc, current;
1205        int done_nr, total_nr;
1206        struct stat_data stat;
1207};
1208
1209#define TODO_LIST_INIT { STRBUF_INIT }
1210
1211static void todo_list_release(struct todo_list *todo_list)
1212{
1213        strbuf_release(&todo_list->buf);
1214        free(todo_list->items);
1215        todo_list->items = NULL;
1216        todo_list->nr = todo_list->alloc = 0;
1217}
1218
1219static struct todo_item *append_new_todo(struct todo_list *todo_list)
1220{
1221        ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
1222        return todo_list->items + todo_list->nr++;
1223}
1224
1225static int parse_insn_line(struct todo_item *item, const char *bol, char *eol)
1226{
1227        struct object_id commit_oid;
1228        char *end_of_object_name;
1229        int i, saved, status, padding;
1230
1231        /* left-trim */
1232        bol += strspn(bol, " \t");
1233
1234        if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
1235                item->command = TODO_COMMENT;
1236                item->commit = NULL;
1237                item->arg = bol;
1238                item->arg_len = eol - bol;
1239                return 0;
1240        }
1241
1242        for (i = 0; i < TODO_COMMENT; i++)
1243                if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
1244                        item->command = i;
1245                        break;
1246                } else if (bol[1] == ' ' && *bol == todo_command_info[i].c) {
1247                        bol++;
1248                        item->command = i;
1249                        break;
1250                }
1251        if (i >= TODO_COMMENT)
1252                return -1;
1253
1254        if (item->command == TODO_NOOP) {
1255                item->commit = NULL;
1256                item->arg = bol;
1257                item->arg_len = eol - bol;
1258                return 0;
1259        }
1260
1261        /* Eat up extra spaces/ tabs before object name */
1262        padding = strspn(bol, " \t");
1263        if (!padding)
1264                return -1;
1265        bol += padding;
1266
1267        if (item->command == TODO_EXEC) {
1268                item->arg = bol;
1269                item->arg_len = (int)(eol - bol);
1270                return 0;
1271        }
1272
1273        end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
1274        saved = *end_of_object_name;
1275        *end_of_object_name = '\0';
1276        status = get_oid(bol, &commit_oid);
1277        *end_of_object_name = saved;
1278
1279        item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
1280        item->arg_len = (int)(eol - item->arg);
1281
1282        if (status < 0)
1283                return -1;
1284
1285        item->commit = lookup_commit_reference(&commit_oid);
1286        return !item->commit;
1287}
1288
1289static int parse_insn_buffer(char *buf, struct todo_list *todo_list)
1290{
1291        struct todo_item *item;
1292        char *p = buf, *next_p;
1293        int i, res = 0, fixup_okay = file_exists(rebase_path_done());
1294
1295        for (i = 1; *p; i++, p = next_p) {
1296                char *eol = strchrnul(p, '\n');
1297
1298                next_p = *eol ? eol + 1 /* skip LF */ : eol;
1299
1300                if (p != eol && eol[-1] == '\r')
1301                        eol--; /* strip Carriage Return */
1302
1303                item = append_new_todo(todo_list);
1304                item->offset_in_buf = p - todo_list->buf.buf;
1305                if (parse_insn_line(item, p, eol)) {
1306                        res = error(_("invalid line %d: %.*s"),
1307                                i, (int)(eol - p), p);
1308                        item->command = TODO_NOOP;
1309                }
1310
1311                if (fixup_okay)
1312                        ; /* do nothing */
1313                else if (is_fixup(item->command))
1314                        return error(_("cannot '%s' without a previous commit"),
1315                                command_to_string(item->command));
1316                else if (!is_noop(item->command))
1317                        fixup_okay = 1;
1318        }
1319
1320        return res;
1321}
1322
1323static int count_commands(struct todo_list *todo_list)
1324{
1325        int count = 0, i;
1326
1327        for (i = 0; i < todo_list->nr; i++)
1328                if (todo_list->items[i].command != TODO_COMMENT)
1329                        count++;
1330
1331        return count;
1332}
1333
1334static int read_populate_todo(struct todo_list *todo_list,
1335                        struct replay_opts *opts)
1336{
1337        struct stat st;
1338        const char *todo_file = get_todo_path(opts);
1339        int fd, res;
1340
1341        strbuf_reset(&todo_list->buf);
1342        fd = open(todo_file, O_RDONLY);
1343        if (fd < 0)
1344                return error_errno(_("could not open '%s'"), todo_file);
1345        if (strbuf_read(&todo_list->buf, fd, 0) < 0) {
1346                close(fd);
1347                return error(_("could not read '%s'."), todo_file);
1348        }
1349        close(fd);
1350
1351        res = stat(todo_file, &st);
1352        if (res)
1353                return error(_("could not stat '%s'"), todo_file);
1354        fill_stat_data(&todo_list->stat, &st);
1355
1356        res = parse_insn_buffer(todo_list->buf.buf, todo_list);
1357        if (res) {
1358                if (is_rebase_i(opts))
1359                        return error(_("please fix this using "
1360                                       "'git rebase --edit-todo'."));
1361                return error(_("unusable instruction sheet: '%s'"), todo_file);
1362        }
1363
1364        if (!todo_list->nr &&
1365            (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
1366                return error(_("no commits parsed."));
1367
1368        if (!is_rebase_i(opts)) {
1369                enum todo_command valid =
1370                        opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
1371                int i;
1372
1373                for (i = 0; i < todo_list->nr; i++)
1374                        if (valid == todo_list->items[i].command)
1375                                continue;
1376                        else if (valid == TODO_PICK)
1377                                return error(_("cannot cherry-pick during a revert."));
1378                        else
1379                                return error(_("cannot revert during a cherry-pick."));
1380        }
1381
1382        if (is_rebase_i(opts)) {
1383                struct todo_list done = TODO_LIST_INIT;
1384                FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
1385
1386                if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
1387                                !parse_insn_buffer(done.buf.buf, &done))
1388                        todo_list->done_nr = count_commands(&done);
1389                else
1390                        todo_list->done_nr = 0;
1391
1392                todo_list->total_nr = todo_list->done_nr
1393                        + count_commands(todo_list);
1394                todo_list_release(&done);
1395
1396                if (f) {
1397                        fprintf(f, "%d\n", todo_list->total_nr);
1398                        fclose(f);
1399                }
1400        }
1401
1402        return 0;
1403}
1404
1405static int git_config_string_dup(char **dest,
1406                                 const char *var, const char *value)
1407{
1408        if (!value)
1409                return config_error_nonbool(var);
1410        free(*dest);
1411        *dest = xstrdup(value);
1412        return 0;
1413}
1414
1415static int populate_opts_cb(const char *key, const char *value, void *data)
1416{
1417        struct replay_opts *opts = data;
1418        int error_flag = 1;
1419
1420        if (!value)
1421                error_flag = 0;
1422        else if (!strcmp(key, "options.no-commit"))
1423                opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
1424        else if (!strcmp(key, "options.edit"))
1425                opts->edit = git_config_bool_or_int(key, value, &error_flag);
1426        else if (!strcmp(key, "options.signoff"))
1427                opts->signoff = git_config_bool_or_int(key, value, &error_flag);
1428        else if (!strcmp(key, "options.record-origin"))
1429                opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
1430        else if (!strcmp(key, "options.allow-ff"))
1431                opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
1432        else if (!strcmp(key, "options.mainline"))
1433                opts->mainline = git_config_int(key, value);
1434        else if (!strcmp(key, "options.strategy"))
1435                git_config_string_dup(&opts->strategy, key, value);
1436        else if (!strcmp(key, "options.gpg-sign"))
1437                git_config_string_dup(&opts->gpg_sign, key, value);
1438        else if (!strcmp(key, "options.strategy-option")) {
1439                ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
1440                opts->xopts[opts->xopts_nr++] = xstrdup(value);
1441        } else
1442                return error(_("invalid key: %s"), key);
1443
1444        if (!error_flag)
1445                return error(_("invalid value for %s: %s"), key, value);
1446
1447        return 0;
1448}
1449
1450static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
1451{
1452        int i;
1453
1454        strbuf_reset(buf);
1455        if (!read_oneliner(buf, rebase_path_strategy(), 0))
1456                return;
1457        opts->strategy = strbuf_detach(buf, NULL);
1458        if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
1459                return;
1460
1461        opts->xopts_nr = split_cmdline(buf->buf, (const char ***)&opts->xopts);
1462        for (i = 0; i < opts->xopts_nr; i++) {
1463                const char *arg = opts->xopts[i];
1464
1465                skip_prefix(arg, "--", &arg);
1466                opts->xopts[i] = xstrdup(arg);
1467        }
1468}
1469
1470static int read_populate_opts(struct replay_opts *opts)
1471{
1472        if (is_rebase_i(opts)) {
1473                struct strbuf buf = STRBUF_INIT;
1474
1475                if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
1476                        if (!starts_with(buf.buf, "-S"))
1477                                strbuf_reset(&buf);
1478                        else {
1479                                free(opts->gpg_sign);
1480                                opts->gpg_sign = xstrdup(buf.buf + 2);
1481                        }
1482                }
1483
1484                if (file_exists(rebase_path_verbose()))
1485                        opts->verbose = 1;
1486
1487                read_strategy_opts(opts, &buf);
1488                strbuf_release(&buf);
1489
1490                return 0;
1491        }
1492
1493        if (!file_exists(git_path_opts_file()))
1494                return 0;
1495        /*
1496         * The function git_parse_source(), called from git_config_from_file(),
1497         * may die() in case of a syntactically incorrect file. We do not care
1498         * about this case, though, because we wrote that file ourselves, so we
1499         * are pretty certain that it is syntactically correct.
1500         */
1501        if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
1502                return error(_("malformed options sheet: '%s'"),
1503                        git_path_opts_file());
1504        return 0;
1505}
1506
1507static int walk_revs_populate_todo(struct todo_list *todo_list,
1508                                struct replay_opts *opts)
1509{
1510        enum todo_command command = opts->action == REPLAY_PICK ?
1511                TODO_PICK : TODO_REVERT;
1512        const char *command_string = todo_command_info[command].str;
1513        struct commit *commit;
1514
1515        if (prepare_revs(opts))
1516                return -1;
1517
1518        while ((commit = get_revision(opts->revs))) {
1519                struct todo_item *item = append_new_todo(todo_list);
1520                const char *commit_buffer = get_commit_buffer(commit, NULL);
1521                const char *subject;
1522                int subject_len;
1523
1524                item->command = command;
1525                item->commit = commit;
1526                item->arg = NULL;
1527                item->arg_len = 0;
1528                item->offset_in_buf = todo_list->buf.len;
1529                subject_len = find_commit_subject(commit_buffer, &subject);
1530                strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
1531                        short_commit_name(commit), subject_len, subject);
1532                unuse_commit_buffer(commit, commit_buffer);
1533        }
1534        return 0;
1535}
1536
1537static int create_seq_dir(void)
1538{
1539        if (file_exists(git_path_seq_dir())) {
1540                error(_("a cherry-pick or revert is already in progress"));
1541                advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
1542                return -1;
1543        } else if (mkdir(git_path_seq_dir(), 0777) < 0)
1544                return error_errno(_("could not create sequencer directory '%s'"),
1545                                   git_path_seq_dir());
1546        return 0;
1547}
1548
1549static int save_head(const char *head)
1550{
1551        static struct lock_file head_lock;
1552        struct strbuf buf = STRBUF_INIT;
1553        int fd;
1554
1555        fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
1556        if (fd < 0) {
1557                rollback_lock_file(&head_lock);
1558                return error_errno(_("could not lock HEAD"));
1559        }
1560        strbuf_addf(&buf, "%s\n", head);
1561        if (write_in_full(fd, buf.buf, buf.len) < 0) {
1562                rollback_lock_file(&head_lock);
1563                return error_errno(_("could not write to '%s'"),
1564                                   git_path_head_file());
1565        }
1566        if (commit_lock_file(&head_lock) < 0) {
1567                rollback_lock_file(&head_lock);
1568                return error(_("failed to finalize '%s'."), git_path_head_file());
1569        }
1570        return 0;
1571}
1572
1573static int rollback_is_safe(void)
1574{
1575        struct strbuf sb = STRBUF_INIT;
1576        struct object_id expected_head, actual_head;
1577
1578        if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
1579                strbuf_trim(&sb);
1580                if (get_oid_hex(sb.buf, &expected_head)) {
1581                        strbuf_release(&sb);
1582                        die(_("could not parse %s"), git_path_abort_safety_file());
1583                }
1584                strbuf_release(&sb);
1585        }
1586        else if (errno == ENOENT)
1587                oidclr(&expected_head);
1588        else
1589                die_errno(_("could not read '%s'"), git_path_abort_safety_file());
1590
1591        if (get_oid("HEAD", &actual_head))
1592                oidclr(&actual_head);
1593
1594        return !oidcmp(&actual_head, &expected_head);
1595}
1596
1597static int reset_for_rollback(const unsigned char *sha1)
1598{
1599        const char *argv[4];    /* reset --merge <arg> + NULL */
1600
1601        argv[0] = "reset";
1602        argv[1] = "--merge";
1603        argv[2] = sha1_to_hex(sha1);
1604        argv[3] = NULL;
1605        return run_command_v_opt(argv, RUN_GIT_CMD);
1606}
1607
1608static int rollback_single_pick(void)
1609{
1610        unsigned char head_sha1[20];
1611
1612        if (!file_exists(git_path_cherry_pick_head()) &&
1613            !file_exists(git_path_revert_head()))
1614                return error(_("no cherry-pick or revert in progress"));
1615        if (read_ref_full("HEAD", 0, head_sha1, NULL))
1616                return error(_("cannot resolve HEAD"));
1617        if (is_null_sha1(head_sha1))
1618                return error(_("cannot abort from a branch yet to be born"));
1619        return reset_for_rollback(head_sha1);
1620}
1621
1622int sequencer_rollback(struct replay_opts *opts)
1623{
1624        FILE *f;
1625        unsigned char sha1[20];
1626        struct strbuf buf = STRBUF_INIT;
1627
1628        f = fopen(git_path_head_file(), "r");
1629        if (!f && errno == ENOENT) {
1630                /*
1631                 * There is no multiple-cherry-pick in progress.
1632                 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
1633                 * a single-cherry-pick in progress, abort that.
1634                 */
1635                return rollback_single_pick();
1636        }
1637        if (!f)
1638                return error_errno(_("cannot open '%s'"), git_path_head_file());
1639        if (strbuf_getline_lf(&buf, f)) {
1640                error(_("cannot read '%s': %s"), git_path_head_file(),
1641                      ferror(f) ?  strerror(errno) : _("unexpected end of file"));
1642                fclose(f);
1643                goto fail;
1644        }
1645        fclose(f);
1646        if (get_sha1_hex(buf.buf, sha1) || buf.buf[40] != '\0') {
1647                error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
1648                        git_path_head_file());
1649                goto fail;
1650        }
1651        if (is_null_sha1(sha1)) {
1652                error(_("cannot abort from a branch yet to be born"));
1653                goto fail;
1654        }
1655
1656        if (!rollback_is_safe()) {
1657                /* Do not error, just do not rollback */
1658                warning(_("You seem to have moved HEAD. "
1659                          "Not rewinding, check your HEAD!"));
1660        } else
1661        if (reset_for_rollback(sha1))
1662                goto fail;
1663        strbuf_release(&buf);
1664        return sequencer_remove_state(opts);
1665fail:
1666        strbuf_release(&buf);
1667        return -1;
1668}
1669
1670static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
1671{
1672        static struct lock_file todo_lock;
1673        const char *todo_path = get_todo_path(opts);
1674        int next = todo_list->current, offset, fd;
1675
1676        /*
1677         * rebase -i writes "git-rebase-todo" without the currently executing
1678         * command, appending it to "done" instead.
1679         */
1680        if (is_rebase_i(opts))
1681                next++;
1682
1683        fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
1684        if (fd < 0)
1685                return error_errno(_("could not lock '%s'"), todo_path);
1686        offset = next < todo_list->nr ?
1687                todo_list->items[next].offset_in_buf : todo_list->buf.len;
1688        if (write_in_full(fd, todo_list->buf.buf + offset,
1689                        todo_list->buf.len - offset) < 0)
1690                return error_errno(_("could not write to '%s'"), todo_path);
1691        if (commit_lock_file(&todo_lock) < 0)
1692                return error(_("failed to finalize '%s'."), todo_path);
1693
1694        if (is_rebase_i(opts)) {
1695                const char *done_path = rebase_path_done();
1696                int fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
1697                int prev_offset = !next ? 0 :
1698                        todo_list->items[next - 1].offset_in_buf;
1699
1700                if (fd >= 0 && offset > prev_offset &&
1701                    write_in_full(fd, todo_list->buf.buf + prev_offset,
1702                                  offset - prev_offset) < 0) {
1703                        close(fd);
1704                        return error_errno(_("could not write to '%s'"),
1705                                           done_path);
1706                }
1707                if (fd >= 0)
1708                        close(fd);
1709        }
1710        return 0;
1711}
1712
1713static int save_opts(struct replay_opts *opts)
1714{
1715        const char *opts_file = git_path_opts_file();
1716        int res = 0;
1717
1718        if (opts->no_commit)
1719                res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
1720        if (opts->edit)
1721                res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
1722        if (opts->signoff)
1723                res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
1724        if (opts->record_origin)
1725                res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
1726        if (opts->allow_ff)
1727                res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
1728        if (opts->mainline) {
1729                struct strbuf buf = STRBUF_INIT;
1730                strbuf_addf(&buf, "%d", opts->mainline);
1731                res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
1732                strbuf_release(&buf);
1733        }
1734        if (opts->strategy)
1735                res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
1736        if (opts->gpg_sign)
1737                res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
1738        if (opts->xopts) {
1739                int i;
1740                for (i = 0; i < opts->xopts_nr; i++)
1741                        res |= git_config_set_multivar_in_file_gently(opts_file,
1742                                                        "options.strategy-option",
1743                                                        opts->xopts[i], "^$", 0);
1744        }
1745        return res;
1746}
1747
1748static int make_patch(struct commit *commit, struct replay_opts *opts)
1749{
1750        struct strbuf buf = STRBUF_INIT;
1751        struct rev_info log_tree_opt;
1752        const char *subject, *p;
1753        int res = 0;
1754
1755        p = short_commit_name(commit);
1756        if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
1757                return -1;
1758
1759        strbuf_addf(&buf, "%s/patch", get_dir(opts));
1760        memset(&log_tree_opt, 0, sizeof(log_tree_opt));
1761        init_revisions(&log_tree_opt, NULL);
1762        log_tree_opt.abbrev = 0;
1763        log_tree_opt.diff = 1;
1764        log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
1765        log_tree_opt.disable_stdin = 1;
1766        log_tree_opt.no_commit_id = 1;
1767        log_tree_opt.diffopt.file = fopen(buf.buf, "w");
1768        log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
1769        if (!log_tree_opt.diffopt.file)
1770                res |= error_errno(_("could not open '%s'"), buf.buf);
1771        else {
1772                res |= log_tree_commit(&log_tree_opt, commit);
1773                fclose(log_tree_opt.diffopt.file);
1774        }
1775        strbuf_reset(&buf);
1776
1777        strbuf_addf(&buf, "%s/message", get_dir(opts));
1778        if (!file_exists(buf.buf)) {
1779                const char *commit_buffer = get_commit_buffer(commit, NULL);
1780                find_commit_subject(commit_buffer, &subject);
1781                res |= write_message(subject, strlen(subject), buf.buf, 1);
1782                unuse_commit_buffer(commit, commit_buffer);
1783        }
1784        strbuf_release(&buf);
1785
1786        return res;
1787}
1788
1789static int intend_to_amend(void)
1790{
1791        unsigned char head[20];
1792        char *p;
1793
1794        if (get_sha1("HEAD", head))
1795                return error(_("cannot read HEAD"));
1796
1797        p = sha1_to_hex(head);
1798        return write_message(p, strlen(p), rebase_path_amend(), 1);
1799}
1800
1801static int error_with_patch(struct commit *commit,
1802        const char *subject, int subject_len,
1803        struct replay_opts *opts, int exit_code, int to_amend)
1804{
1805        if (make_patch(commit, opts))
1806                return -1;
1807
1808        if (to_amend) {
1809                if (intend_to_amend())
1810                        return -1;
1811
1812                fprintf(stderr, "You can amend the commit now, with\n"
1813                        "\n"
1814                        "  git commit --amend %s\n"
1815                        "\n"
1816                        "Once you are satisfied with your changes, run\n"
1817                        "\n"
1818                        "  git rebase --continue\n", gpg_sign_opt_quoted(opts));
1819        } else if (exit_code)
1820                fprintf(stderr, "Could not apply %s... %.*s\n",
1821                        short_commit_name(commit), subject_len, subject);
1822
1823        return exit_code;
1824}
1825
1826static int error_failed_squash(struct commit *commit,
1827        struct replay_opts *opts, int subject_len, const char *subject)
1828{
1829        if (rename(rebase_path_squash_msg(), rebase_path_message()))
1830                return error(_("could not rename '%s' to '%s'"),
1831                        rebase_path_squash_msg(), rebase_path_message());
1832        unlink(rebase_path_fixup_msg());
1833        unlink(git_path_merge_msg());
1834        if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
1835                return error(_("could not copy '%s' to '%s'"),
1836                             rebase_path_message(), git_path_merge_msg());
1837        return error_with_patch(commit, subject, subject_len, opts, 1, 0);
1838}
1839
1840static int do_exec(const char *command_line)
1841{
1842        const char *child_argv[] = { NULL, NULL };
1843        int dirty, status;
1844
1845        fprintf(stderr, "Executing: %s\n", command_line);
1846        child_argv[0] = command_line;
1847        status = run_command_v_opt(child_argv, RUN_USING_SHELL);
1848
1849        /* force re-reading of the cache */
1850        if (discard_cache() < 0 || read_cache() < 0)
1851                return error(_("could not read index"));
1852
1853        dirty = require_clean_work_tree("rebase", NULL, 1, 1);
1854
1855        if (status) {
1856                warning(_("execution failed: %s\n%s"
1857                          "You can fix the problem, and then run\n"
1858                          "\n"
1859                          "  git rebase --continue\n"
1860                          "\n"),
1861                        command_line,
1862                        dirty ? N_("and made changes to the index and/or the "
1863                                "working tree\n") : "");
1864                if (status == 127)
1865                        /* command not found */
1866                        status = 1;
1867        } else if (dirty) {
1868                warning(_("execution succeeded: %s\nbut "
1869                          "left changes to the index and/or the working tree\n"
1870                          "Commit or stash your changes, and then run\n"
1871                          "\n"
1872                          "  git rebase --continue\n"
1873                          "\n"), command_line);
1874                status = 1;
1875        }
1876
1877        return status;
1878}
1879
1880static int is_final_fixup(struct todo_list *todo_list)
1881{
1882        int i = todo_list->current;
1883
1884        if (!is_fixup(todo_list->items[i].command))
1885                return 0;
1886
1887        while (++i < todo_list->nr)
1888                if (is_fixup(todo_list->items[i].command))
1889                        return 0;
1890                else if (!is_noop(todo_list->items[i].command))
1891                        break;
1892        return 1;
1893}
1894
1895static enum todo_command peek_command(struct todo_list *todo_list, int offset)
1896{
1897        int i;
1898
1899        for (i = todo_list->current + offset; i < todo_list->nr; i++)
1900                if (!is_noop(todo_list->items[i].command))
1901                        return todo_list->items[i].command;
1902
1903        return -1;
1904}
1905
1906static int apply_autostash(struct replay_opts *opts)
1907{
1908        struct strbuf stash_sha1 = STRBUF_INIT;
1909        struct child_process child = CHILD_PROCESS_INIT;
1910        int ret = 0;
1911
1912        if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
1913                strbuf_release(&stash_sha1);
1914                return 0;
1915        }
1916        strbuf_trim(&stash_sha1);
1917
1918        child.git_cmd = 1;
1919        child.no_stdout = 1;
1920        child.no_stderr = 1;
1921        argv_array_push(&child.args, "stash");
1922        argv_array_push(&child.args, "apply");
1923        argv_array_push(&child.args, stash_sha1.buf);
1924        if (!run_command(&child))
1925                printf(_("Applied autostash.\n"));
1926        else {
1927                struct child_process store = CHILD_PROCESS_INIT;
1928
1929                store.git_cmd = 1;
1930                argv_array_push(&store.args, "stash");
1931                argv_array_push(&store.args, "store");
1932                argv_array_push(&store.args, "-m");
1933                argv_array_push(&store.args, "autostash");
1934                argv_array_push(&store.args, "-q");
1935                argv_array_push(&store.args, stash_sha1.buf);
1936                if (run_command(&store))
1937                        ret = error(_("cannot store %s"), stash_sha1.buf);
1938                else
1939                        printf(_("Applying autostash resulted in conflicts.\n"
1940                                "Your changes are safe in the stash.\n"
1941                                "You can run \"git stash pop\" or"
1942                                " \"git stash drop\" at any time.\n"));
1943        }
1944
1945        strbuf_release(&stash_sha1);
1946        return ret;
1947}
1948
1949static const char *reflog_message(struct replay_opts *opts,
1950        const char *sub_action, const char *fmt, ...)
1951{
1952        va_list ap;
1953        static struct strbuf buf = STRBUF_INIT;
1954
1955        va_start(ap, fmt);
1956        strbuf_reset(&buf);
1957        strbuf_addstr(&buf, action_name(opts));
1958        if (sub_action)
1959                strbuf_addf(&buf, " (%s)", sub_action);
1960        if (fmt) {
1961                strbuf_addstr(&buf, ": ");
1962                strbuf_vaddf(&buf, fmt, ap);
1963        }
1964        va_end(ap);
1965
1966        return buf.buf;
1967}
1968
1969static int pick_commits(struct todo_list *todo_list, struct replay_opts *opts)
1970{
1971        int res = 0;
1972
1973        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
1974        if (opts->allow_ff)
1975                assert(!(opts->signoff || opts->no_commit ||
1976                                opts->record_origin || opts->edit));
1977        if (read_and_refresh_cache(opts))
1978                return -1;
1979
1980        while (todo_list->current < todo_list->nr) {
1981                struct todo_item *item = todo_list->items + todo_list->current;
1982                if (save_todo(todo_list, opts))
1983                        return -1;
1984                if (is_rebase_i(opts)) {
1985                        if (item->command != TODO_COMMENT) {
1986                                FILE *f = fopen(rebase_path_msgnum(), "w");
1987
1988                                todo_list->done_nr++;
1989
1990                                if (f) {
1991                                        fprintf(f, "%d\n", todo_list->done_nr);
1992                                        fclose(f);
1993                                }
1994                                fprintf(stderr, "Rebasing (%d/%d)%s",
1995                                        todo_list->done_nr,
1996                                        todo_list->total_nr,
1997                                        opts->verbose ? "\n" : "\r");
1998                        }
1999                        unlink(rebase_path_message());
2000                        unlink(rebase_path_author_script());
2001                        unlink(rebase_path_stopped_sha());
2002                        unlink(rebase_path_amend());
2003                }
2004                if (item->command <= TODO_SQUASH) {
2005                        if (is_rebase_i(opts))
2006                                setenv("GIT_REFLOG_ACTION", reflog_message(opts,
2007                                        command_to_string(item->command), NULL),
2008                                        1);
2009                        res = do_pick_commit(item->command, item->commit,
2010                                        opts, is_final_fixup(todo_list));
2011                        if (is_rebase_i(opts) && res < 0) {
2012                                /* Reschedule */
2013                                todo_list->current--;
2014                                if (save_todo(todo_list, opts))
2015                                        return -1;
2016                        }
2017                        if (item->command == TODO_EDIT) {
2018                                struct commit *commit = item->commit;
2019                                if (!res)
2020                                        fprintf(stderr,
2021                                                _("Stopped at %s...  %.*s\n"),
2022                                                short_commit_name(commit),
2023                                                item->arg_len, item->arg);
2024                                return error_with_patch(commit,
2025                                        item->arg, item->arg_len, opts, res,
2026                                        !res);
2027                        }
2028                        if (is_rebase_i(opts) && !res)
2029                                record_in_rewritten(&item->commit->object.oid,
2030                                        peek_command(todo_list, 1));
2031                        if (res && is_fixup(item->command)) {
2032                                if (res == 1)
2033                                        intend_to_amend();
2034                                return error_failed_squash(item->commit, opts,
2035                                        item->arg_len, item->arg);
2036                        } else if (res && is_rebase_i(opts))
2037                                return res | error_with_patch(item->commit,
2038                                        item->arg, item->arg_len, opts, res,
2039                                        item->command == TODO_REWORD);
2040                } else if (item->command == TODO_EXEC) {
2041                        char *end_of_arg = (char *)(item->arg + item->arg_len);
2042                        int saved = *end_of_arg;
2043                        struct stat st;
2044
2045                        *end_of_arg = '\0';
2046                        res = do_exec(item->arg);
2047                        *end_of_arg = saved;
2048
2049                        /* Reread the todo file if it has changed. */
2050                        if (res)
2051                                ; /* fall through */
2052                        else if (stat(get_todo_path(opts), &st))
2053                                res = error_errno(_("could not stat '%s'"),
2054                                                  get_todo_path(opts));
2055                        else if (match_stat_data(&todo_list->stat, &st)) {
2056                                todo_list_release(todo_list);
2057                                if (read_populate_todo(todo_list, opts))
2058                                        res = -1; /* message was printed */
2059                                /* `current` will be incremented below */
2060                                todo_list->current = -1;
2061                        }
2062                } else if (!is_noop(item->command))
2063                        return error(_("unknown command %d"), item->command);
2064
2065                todo_list->current++;
2066                if (res)
2067                        return res;
2068        }
2069
2070        if (is_rebase_i(opts)) {
2071                struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
2072                struct stat st;
2073
2074                /* Stopped in the middle, as planned? */
2075                if (todo_list->current < todo_list->nr)
2076                        return 0;
2077
2078                if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
2079                                starts_with(head_ref.buf, "refs/")) {
2080                        const char *msg;
2081                        unsigned char head[20], orig[20];
2082                        int res;
2083
2084                        if (get_sha1("HEAD", head)) {
2085                                res = error(_("cannot read HEAD"));
2086cleanup_head_ref:
2087                                strbuf_release(&head_ref);
2088                                strbuf_release(&buf);
2089                                return res;
2090                        }
2091                        if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
2092                                        get_sha1_hex(buf.buf, orig)) {
2093                                res = error(_("could not read orig-head"));
2094                                goto cleanup_head_ref;
2095                        }
2096                        strbuf_reset(&buf);
2097                        if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
2098                                res = error(_("could not read 'onto'"));
2099                                goto cleanup_head_ref;
2100                        }
2101                        msg = reflog_message(opts, "finish", "%s onto %s",
2102                                head_ref.buf, buf.buf);
2103                        if (update_ref(msg, head_ref.buf, head, orig,
2104                                        REF_NODEREF, UPDATE_REFS_MSG_ON_ERR)) {
2105                                res = error(_("could not update %s"),
2106                                        head_ref.buf);
2107                                goto cleanup_head_ref;
2108                        }
2109                        msg = reflog_message(opts, "finish", "returning to %s",
2110                                head_ref.buf);
2111                        if (create_symref("HEAD", head_ref.buf, msg)) {
2112                                res = error(_("could not update HEAD to %s"),
2113                                        head_ref.buf);
2114                                goto cleanup_head_ref;
2115                        }
2116                        strbuf_reset(&buf);
2117                }
2118
2119                if (opts->verbose) {
2120                        struct rev_info log_tree_opt;
2121                        struct object_id orig, head;
2122
2123                        memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2124                        init_revisions(&log_tree_opt, NULL);
2125                        log_tree_opt.diff = 1;
2126                        log_tree_opt.diffopt.output_format =
2127                                DIFF_FORMAT_DIFFSTAT;
2128                        log_tree_opt.disable_stdin = 1;
2129
2130                        if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
2131                            !get_sha1(buf.buf, orig.hash) &&
2132                            !get_sha1("HEAD", head.hash)) {
2133                                diff_tree_sha1(orig.hash, head.hash,
2134                                               "", &log_tree_opt.diffopt);
2135                                log_tree_diff_flush(&log_tree_opt);
2136                        }
2137                }
2138                flush_rewritten_pending();
2139                if (!stat(rebase_path_rewritten_list(), &st) &&
2140                                st.st_size > 0) {
2141                        struct child_process child = CHILD_PROCESS_INIT;
2142                        const char *post_rewrite_hook =
2143                                find_hook("post-rewrite");
2144
2145                        child.in = open(rebase_path_rewritten_list(), O_RDONLY);
2146                        child.git_cmd = 1;
2147                        argv_array_push(&child.args, "notes");
2148                        argv_array_push(&child.args, "copy");
2149                        argv_array_push(&child.args, "--for-rewrite=rebase");
2150                        /* we don't care if this copying failed */
2151                        run_command(&child);
2152
2153                        if (post_rewrite_hook) {
2154                                struct child_process hook = CHILD_PROCESS_INIT;
2155
2156                                hook.in = open(rebase_path_rewritten_list(),
2157                                        O_RDONLY);
2158                                hook.stdout_to_stderr = 1;
2159                                argv_array_push(&hook.args, post_rewrite_hook);
2160                                argv_array_push(&hook.args, "rebase");
2161                                /* we don't care if this hook failed */
2162                                run_command(&hook);
2163                        }
2164                }
2165                apply_autostash(opts);
2166
2167                fprintf(stderr, "Successfully rebased and updated %s.\n",
2168                        head_ref.buf);
2169
2170                strbuf_release(&buf);
2171                strbuf_release(&head_ref);
2172        }
2173
2174        /*
2175         * Sequence of picks finished successfully; cleanup by
2176         * removing the .git/sequencer directory
2177         */
2178        return sequencer_remove_state(opts);
2179}
2180
2181static int continue_single_pick(void)
2182{
2183        const char *argv[] = { "commit", NULL };
2184
2185        if (!file_exists(git_path_cherry_pick_head()) &&
2186            !file_exists(git_path_revert_head()))
2187                return error(_("no cherry-pick or revert in progress"));
2188        return run_command_v_opt(argv, RUN_GIT_CMD);
2189}
2190
2191static int commit_staged_changes(struct replay_opts *opts)
2192{
2193        unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
2194
2195        if (has_unstaged_changes(1))
2196                return error(_("cannot rebase: You have unstaged changes."));
2197        if (!has_uncommitted_changes(0)) {
2198                const char *cherry_pick_head = git_path_cherry_pick_head();
2199
2200                if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
2201                        return error(_("could not remove CHERRY_PICK_HEAD"));
2202                return 0;
2203        }
2204
2205        if (file_exists(rebase_path_amend())) {
2206                struct strbuf rev = STRBUF_INIT;
2207                unsigned char head[20], to_amend[20];
2208
2209                if (get_sha1("HEAD", head))
2210                        return error(_("cannot amend non-existing commit"));
2211                if (!read_oneliner(&rev, rebase_path_amend(), 0))
2212                        return error(_("invalid file: '%s'"), rebase_path_amend());
2213                if (get_sha1_hex(rev.buf, to_amend))
2214                        return error(_("invalid contents: '%s'"),
2215                                rebase_path_amend());
2216                if (hashcmp(head, to_amend))
2217                        return error(_("\nYou have uncommitted changes in your "
2218                                       "working tree. Please, commit them\n"
2219                                       "first and then run 'git rebase "
2220                                       "--continue' again."));
2221
2222                strbuf_release(&rev);
2223                flags |= AMEND_MSG;
2224        }
2225
2226        if (run_git_commit(rebase_path_message(), opts, flags))
2227                return error(_("could not commit staged changes."));
2228        unlink(rebase_path_amend());
2229        return 0;
2230}
2231
2232int sequencer_continue(struct replay_opts *opts)
2233{
2234        struct todo_list todo_list = TODO_LIST_INIT;
2235        int res;
2236
2237        if (read_and_refresh_cache(opts))
2238                return -1;
2239
2240        if (is_rebase_i(opts)) {
2241                if (commit_staged_changes(opts))
2242                        return -1;
2243        } else if (!file_exists(get_todo_path(opts)))
2244                return continue_single_pick();
2245        if (read_populate_opts(opts))
2246                return -1;
2247        if ((res = read_populate_todo(&todo_list, opts)))
2248                goto release_todo_list;
2249
2250        if (!is_rebase_i(opts)) {
2251                /* Verify that the conflict has been resolved */
2252                if (file_exists(git_path_cherry_pick_head()) ||
2253                    file_exists(git_path_revert_head())) {
2254                        res = continue_single_pick();
2255                        if (res)
2256                                goto release_todo_list;
2257                }
2258                if (index_differs_from("HEAD", 0, 0)) {
2259                        res = error_dirty_index(opts);
2260                        goto release_todo_list;
2261                }
2262                todo_list.current++;
2263        } else if (file_exists(rebase_path_stopped_sha())) {
2264                struct strbuf buf = STRBUF_INIT;
2265                struct object_id oid;
2266
2267                if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
2268                    !get_sha1_committish(buf.buf, oid.hash))
2269                        record_in_rewritten(&oid, peek_command(&todo_list, 0));
2270                strbuf_release(&buf);
2271        }
2272
2273        res = pick_commits(&todo_list, opts);
2274release_todo_list:
2275        todo_list_release(&todo_list);
2276        return res;
2277}
2278
2279static int single_pick(struct commit *cmit, struct replay_opts *opts)
2280{
2281        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2282        return do_pick_commit(opts->action == REPLAY_PICK ?
2283                TODO_PICK : TODO_REVERT, cmit, opts, 0);
2284}
2285
2286int sequencer_pick_revisions(struct replay_opts *opts)
2287{
2288        struct todo_list todo_list = TODO_LIST_INIT;
2289        struct object_id oid;
2290        int i, res;
2291
2292        assert(opts->revs);
2293        if (read_and_refresh_cache(opts))
2294                return -1;
2295
2296        for (i = 0; i < opts->revs->pending.nr; i++) {
2297                struct object_id oid;
2298                const char *name = opts->revs->pending.objects[i].name;
2299
2300                /* This happens when using --stdin. */
2301                if (!strlen(name))
2302                        continue;
2303
2304                if (!get_oid(name, &oid)) {
2305                        if (!lookup_commit_reference_gently(&oid, 1)) {
2306                                enum object_type type = sha1_object_info(oid.hash, NULL);
2307                                return error(_("%s: can't cherry-pick a %s"),
2308                                        name, typename(type));
2309                        }
2310                } else
2311                        return error(_("%s: bad revision"), name);
2312        }
2313
2314        /*
2315         * If we were called as "git cherry-pick <commit>", just
2316         * cherry-pick/revert it, set CHERRY_PICK_HEAD /
2317         * REVERT_HEAD, and don't touch the sequencer state.
2318         * This means it is possible to cherry-pick in the middle
2319         * of a cherry-pick sequence.
2320         */
2321        if (opts->revs->cmdline.nr == 1 &&
2322            opts->revs->cmdline.rev->whence == REV_CMD_REV &&
2323            opts->revs->no_walk &&
2324            !opts->revs->cmdline.rev->flags) {
2325                struct commit *cmit;
2326                if (prepare_revision_walk(opts->revs))
2327                        return error(_("revision walk setup failed"));
2328                cmit = get_revision(opts->revs);
2329                if (!cmit || get_revision(opts->revs))
2330                        return error("BUG: expected exactly one commit from walk");
2331                return single_pick(cmit, opts);
2332        }
2333
2334        /*
2335         * Start a new cherry-pick/ revert sequence; but
2336         * first, make sure that an existing one isn't in
2337         * progress
2338         */
2339
2340        if (walk_revs_populate_todo(&todo_list, opts) ||
2341                        create_seq_dir() < 0)
2342                return -1;
2343        if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
2344                return error(_("can't revert as initial commit"));
2345        if (save_head(oid_to_hex(&oid)))
2346                return -1;
2347        if (save_opts(opts))
2348                return -1;
2349        update_abort_safety_file();
2350        res = pick_commits(&todo_list, opts);
2351        todo_list_release(&todo_list);
2352        return res;
2353}
2354
2355void append_signoff(struct strbuf *msgbuf, int ignore_footer, unsigned flag)
2356{
2357        unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
2358        struct strbuf sob = STRBUF_INIT;
2359        int has_footer;
2360
2361        strbuf_addstr(&sob, sign_off_header);
2362        strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
2363                                getenv("GIT_COMMITTER_EMAIL")));
2364        strbuf_addch(&sob, '\n');
2365
2366        if (!ignore_footer)
2367                strbuf_complete_line(msgbuf);
2368
2369        /*
2370         * If the whole message buffer is equal to the sob, pretend that we
2371         * found a conforming footer with a matching sob
2372         */
2373        if (msgbuf->len - ignore_footer == sob.len &&
2374            !strncmp(msgbuf->buf, sob.buf, sob.len))
2375                has_footer = 3;
2376        else
2377                has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
2378
2379        if (!has_footer) {
2380                const char *append_newlines = NULL;
2381                size_t len = msgbuf->len - ignore_footer;
2382
2383                if (!len) {
2384                        /*
2385                         * The buffer is completely empty.  Leave foom for
2386                         * the title and body to be filled in by the user.
2387                         */
2388                        append_newlines = "\n\n";
2389                } else if (len == 1) {
2390                        /*
2391                         * Buffer contains a single newline.  Add another
2392                         * so that we leave room for the title and body.
2393                         */
2394                        append_newlines = "\n";
2395                } else if (msgbuf->buf[len - 2] != '\n') {
2396                        /*
2397                         * Buffer ends with a single newline.  Add another
2398                         * so that there is an empty line between the message
2399                         * body and the sob.
2400                         */
2401                        append_newlines = "\n";
2402                } /* else, the buffer already ends with two newlines. */
2403
2404                if (append_newlines)
2405                        strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
2406                                append_newlines, strlen(append_newlines));
2407        }
2408
2409        if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
2410                strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
2411                                sob.buf, sob.len);
2412
2413        strbuf_release(&sob);
2414}