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