sequencer.con commit Merge branch 'rj/sparse-updates' (14599b4)
   1#include "cache.h"
   2#include "config.h"
   3#include "lockfile.h"
   4#include "dir.h"
   5#include "object.h"
   6#include "commit.h"
   7#include "sequencer.h"
   8#include "tag.h"
   9#include "run-command.h"
  10#include "exec_cmd.h"
  11#include "utf8.h"
  12#include "cache-tree.h"
  13#include "diff.h"
  14#include "revision.h"
  15#include "rerere.h"
  16#include "merge-recursive.h"
  17#include "refs.h"
  18#include "argv-array.h"
  19#include "quote.h"
  20#include "trailer.h"
  21#include "log-tree.h"
  22#include "wt-status.h"
  23#include "hashmap.h"
  24#include "notes-utils.h"
  25#include "sigchain.h"
  26
  27#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
  28
  29const char sign_off_header[] = "Signed-off-by: ";
  30static const char cherry_picked_prefix[] = "(cherry picked from commit ";
  31
  32GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
  33
  34GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
  35
  36static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
  37static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
  38static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
  39static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
  40
  41static GIT_PATH_FUNC(rebase_path, "rebase-merge")
  42/*
  43 * The file containing rebase commands, comments, and empty lines.
  44 * This file is created by "git rebase -i" then edited by the user. As
  45 * the lines are processed, they are removed from the front of this
  46 * file and written to the tail of 'done'.
  47 */
  48static GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
  49/*
  50 * The rebase command lines that have already been processed. A line
  51 * is moved here when it is first handled, before any associated user
  52 * actions.
  53 */
  54static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
  55/*
  56 * The file to keep track of how many commands were already processed (e.g.
  57 * for the prompt).
  58 */
  59static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum");
  60/*
  61 * The file to keep track of how many commands are to be processed in total
  62 * (e.g. for the prompt).
  63 */
  64static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end");
  65/*
  66 * The commit message that is planned to be used for any changes that
  67 * need to be committed following a user interaction.
  68 */
  69static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
  70/*
  71 * The file into which is accumulated the suggested commit message for
  72 * squash/fixup commands. When the first of a series of squash/fixups
  73 * is seen, the file is created and the commit message from the
  74 * previous commit and from the first squash/fixup commit are written
  75 * to it. The commit message for each subsequent squash/fixup commit
  76 * is appended to the file as it is processed.
  77 *
  78 * The first line of the file is of the form
  79 *     # This is a combination of $count commits.
  80 * where $count is the number of commits whose messages have been
  81 * written to the file so far (including the initial "pick" commit).
  82 * Each time that a commit message is processed, this line is read and
  83 * updated. It is deleted just before the combined commit is made.
  84 */
  85static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
  86/*
  87 * If the current series of squash/fixups has not yet included a squash
  88 * command, then this file exists and holds the commit message of the
  89 * original "pick" commit.  (If the series ends without a "squash"
  90 * command, then this can be used as the commit message of the combined
  91 * commit without opening the editor.)
  92 */
  93static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
  94/*
  95 * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
  96 * GIT_AUTHOR_DATE that will be used for the commit that is currently
  97 * being rebased.
  98 */
  99static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
 100/*
 101 * When an "edit" rebase command is being processed, the SHA1 of the
 102 * commit to be edited is recorded in this file.  When "git rebase
 103 * --continue" is executed, if there are any staged changes then they
 104 * will be amended to the HEAD commit, but only provided the HEAD
 105 * commit is still the commit to be edited.  When any other rebase
 106 * command is processed, this file is deleted.
 107 */
 108static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
 109/*
 110 * When we stop at a given patch via the "edit" command, this file contains
 111 * the abbreviated commit name of the corresponding patch.
 112 */
 113static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
 114/*
 115 * For the post-rewrite hook, we make a list of rewritten commits and
 116 * their new sha1s.  The rewritten-pending list keeps the sha1s of
 117 * commits that have been processed, but not committed yet,
 118 * e.g. because they are waiting for a 'squash' command.
 119 */
 120static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
 121static GIT_PATH_FUNC(rebase_path_rewritten_pending,
 122        "rebase-merge/rewritten-pending")
 123/*
 124 * The following files are written by git-rebase just after parsing the
 125 * command-line (and are only consumed, not modified, by the sequencer).
 126 */
 127static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
 128static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
 129static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
 130static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
 131static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
 132static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
 133static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
 134static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
 135static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
 136
 137static int git_sequencer_config(const char *k, const char *v, void *cb)
 138{
 139        struct replay_opts *opts = cb;
 140        int status;
 141
 142        if (!strcmp(k, "commit.cleanup")) {
 143                const char *s;
 144
 145                status = git_config_string(&s, k, v);
 146                if (status)
 147                        return status;
 148
 149                if (!strcmp(s, "verbatim"))
 150                        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
 151                else if (!strcmp(s, "whitespace"))
 152                        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
 153                else if (!strcmp(s, "strip"))
 154                        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
 155                else if (!strcmp(s, "scissors"))
 156                        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
 157                else
 158                        warning(_("invalid commit message cleanup mode '%s'"),
 159                                  s);
 160
 161                return status;
 162        }
 163
 164        if (!strcmp(k, "commit.gpgsign")) {
 165                opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
 166                return 0;
 167        }
 168
 169        status = git_gpg_config(k, v, NULL);
 170        if (status)
 171                return status;
 172
 173        return git_diff_basic_config(k, v, NULL);
 174}
 175
 176void sequencer_init_config(struct replay_opts *opts)
 177{
 178        opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
 179        git_config(git_sequencer_config, opts);
 180}
 181
 182static inline int is_rebase_i(const struct replay_opts *opts)
 183{
 184        return opts->action == REPLAY_INTERACTIVE_REBASE;
 185}
 186
 187static const char *get_dir(const struct replay_opts *opts)
 188{
 189        if (is_rebase_i(opts))
 190                return rebase_path();
 191        return git_path_seq_dir();
 192}
 193
 194static const char *get_todo_path(const struct replay_opts *opts)
 195{
 196        if (is_rebase_i(opts))
 197                return rebase_path_todo();
 198        return git_path_todo_file();
 199}
 200
 201/*
 202 * Returns 0 for non-conforming footer
 203 * Returns 1 for conforming footer
 204 * Returns 2 when sob exists within conforming footer
 205 * Returns 3 when sob exists within conforming footer as last entry
 206 */
 207static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
 208        int ignore_footer)
 209{
 210        struct trailer_info info;
 211        int i;
 212        int found_sob = 0, found_sob_last = 0;
 213
 214        trailer_info_get(&info, sb->buf);
 215
 216        if (info.trailer_start == info.trailer_end)
 217                return 0;
 218
 219        for (i = 0; i < info.trailer_nr; i++)
 220                if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
 221                        found_sob = 1;
 222                        if (i == info.trailer_nr - 1)
 223                                found_sob_last = 1;
 224                }
 225
 226        trailer_info_release(&info);
 227
 228        if (found_sob_last)
 229                return 3;
 230        if (found_sob)
 231                return 2;
 232        return 1;
 233}
 234
 235static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
 236{
 237        static struct strbuf buf = STRBUF_INIT;
 238
 239        strbuf_reset(&buf);
 240        if (opts->gpg_sign)
 241                sq_quotef(&buf, "-S%s", opts->gpg_sign);
 242        return buf.buf;
 243}
 244
 245int sequencer_remove_state(struct replay_opts *opts)
 246{
 247        struct strbuf dir = STRBUF_INIT;
 248        int i;
 249
 250        free(opts->gpg_sign);
 251        free(opts->strategy);
 252        for (i = 0; i < opts->xopts_nr; i++)
 253                free(opts->xopts[i]);
 254        free(opts->xopts);
 255
 256        strbuf_addstr(&dir, get_dir(opts));
 257        remove_dir_recursively(&dir, 0);
 258        strbuf_release(&dir);
 259
 260        return 0;
 261}
 262
 263static const char *action_name(const struct replay_opts *opts)
 264{
 265        switch (opts->action) {
 266        case REPLAY_REVERT:
 267                return N_("revert");
 268        case REPLAY_PICK:
 269                return N_("cherry-pick");
 270        case REPLAY_INTERACTIVE_REBASE:
 271                return N_("rebase -i");
 272        }
 273        die(_("Unknown action: %d"), opts->action);
 274}
 275
 276struct commit_message {
 277        char *parent_label;
 278        char *label;
 279        char *subject;
 280        const char *message;
 281};
 282
 283static const char *short_commit_name(struct commit *commit)
 284{
 285        return find_unique_abbrev(commit->object.oid.hash, DEFAULT_ABBREV);
 286}
 287
 288static int get_message(struct commit *commit, struct commit_message *out)
 289{
 290        const char *abbrev, *subject;
 291        int subject_len;
 292
 293        out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
 294        abbrev = short_commit_name(commit);
 295
 296        subject_len = find_commit_subject(out->message, &subject);
 297
 298        out->subject = xmemdupz(subject, subject_len);
 299        out->label = xstrfmt("%s... %s", abbrev, out->subject);
 300        out->parent_label = xstrfmt("parent of %s", out->label);
 301
 302        return 0;
 303}
 304
 305static void free_message(struct commit *commit, struct commit_message *msg)
 306{
 307        free(msg->parent_label);
 308        free(msg->label);
 309        free(msg->subject);
 310        unuse_commit_buffer(commit, msg->message);
 311}
 312
 313static void print_advice(int show_hint, struct replay_opts *opts)
 314{
 315        char *msg = getenv("GIT_CHERRY_PICK_HELP");
 316
 317        if (msg) {
 318                fprintf(stderr, "%s\n", msg);
 319                /*
 320                 * A conflict has occurred but the porcelain
 321                 * (typically rebase --interactive) wants to take care
 322                 * of the commit itself so remove CHERRY_PICK_HEAD
 323                 */
 324                unlink(git_path_cherry_pick_head());
 325                return;
 326        }
 327
 328        if (show_hint) {
 329                if (opts->no_commit)
 330                        advise(_("after resolving the conflicts, mark the corrected paths\n"
 331                                 "with 'git add <paths>' or 'git rm <paths>'"));
 332                else
 333                        advise(_("after resolving the conflicts, mark the corrected paths\n"
 334                                 "with 'git add <paths>' or 'git rm <paths>'\n"
 335                                 "and commit the result with 'git commit'"));
 336        }
 337}
 338
 339static int write_message(const void *buf, size_t len, const char *filename,
 340                         int append_eol)
 341{
 342        static struct lock_file msg_file;
 343
 344        int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
 345        if (msg_fd < 0)
 346                return error_errno(_("could not lock '%s'"), filename);
 347        if (write_in_full(msg_fd, buf, len) < 0) {
 348                rollback_lock_file(&msg_file);
 349                return error_errno(_("could not write to '%s'"), filename);
 350        }
 351        if (append_eol && write(msg_fd, "\n", 1) < 0) {
 352                rollback_lock_file(&msg_file);
 353                return error_errno(_("could not write eol to '%s'"), filename);
 354        }
 355        if (commit_lock_file(&msg_file) < 0) {
 356                rollback_lock_file(&msg_file);
 357                return error(_("failed to finalize '%s'."), filename);
 358        }
 359
 360        return 0;
 361}
 362
 363/*
 364 * Reads a file that was presumably written by a shell script, i.e. with an
 365 * end-of-line marker that needs to be stripped.
 366 *
 367 * Note that only the last end-of-line marker is stripped, consistent with the
 368 * behavior of "$(cat path)" in a shell script.
 369 *
 370 * Returns 1 if the file was read, 0 if it could not be read or does not exist.
 371 */
 372static int read_oneliner(struct strbuf *buf,
 373        const char *path, int skip_if_empty)
 374{
 375        int orig_len = buf->len;
 376
 377        if (!file_exists(path))
 378                return 0;
 379
 380        if (strbuf_read_file(buf, path, 0) < 0) {
 381                warning_errno(_("could not read '%s'"), path);
 382                return 0;
 383        }
 384
 385        if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
 386                if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
 387                        --buf->len;
 388                buf->buf[buf->len] = '\0';
 389        }
 390
 391        if (skip_if_empty && buf->len == orig_len)
 392                return 0;
 393
 394        return 1;
 395}
 396
 397static struct tree *empty_tree(void)
 398{
 399        return lookup_tree(the_hash_algo->empty_tree);
 400}
 401
 402static int error_dirty_index(struct replay_opts *opts)
 403{
 404        if (read_cache_unmerged())
 405                return error_resolve_conflict(_(action_name(opts)));
 406
 407        error(_("your local changes would be overwritten by %s."),
 408                _(action_name(opts)));
 409
 410        if (advice_commit_before_merge)
 411                advise(_("commit your changes or stash them to proceed."));
 412        return -1;
 413}
 414
 415static void update_abort_safety_file(void)
 416{
 417        struct object_id head;
 418
 419        /* Do nothing on a single-pick */
 420        if (!file_exists(git_path_seq_dir()))
 421                return;
 422
 423        if (!get_oid("HEAD", &head))
 424                write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
 425        else
 426                write_file(git_path_abort_safety_file(), "%s", "");
 427}
 428
 429static int fast_forward_to(const struct object_id *to, const struct object_id *from,
 430                        int unborn, struct replay_opts *opts)
 431{
 432        struct ref_transaction *transaction;
 433        struct strbuf sb = STRBUF_INIT;
 434        struct strbuf err = STRBUF_INIT;
 435
 436        read_cache();
 437        if (checkout_fast_forward(from, to, 1))
 438                return -1; /* the callee should have complained already */
 439
 440        strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
 441
 442        transaction = ref_transaction_begin(&err);
 443        if (!transaction ||
 444            ref_transaction_update(transaction, "HEAD",
 445                                   to, unborn ? &null_oid : from,
 446                                   0, sb.buf, &err) ||
 447            ref_transaction_commit(transaction, &err)) {
 448                ref_transaction_free(transaction);
 449                error("%s", err.buf);
 450                strbuf_release(&sb);
 451                strbuf_release(&err);
 452                return -1;
 453        }
 454
 455        strbuf_release(&sb);
 456        strbuf_release(&err);
 457        ref_transaction_free(transaction);
 458        update_abort_safety_file();
 459        return 0;
 460}
 461
 462void append_conflicts_hint(struct strbuf *msgbuf)
 463{
 464        int i;
 465
 466        strbuf_addch(msgbuf, '\n');
 467        strbuf_commented_addf(msgbuf, "Conflicts:\n");
 468        for (i = 0; i < active_nr;) {
 469                const struct cache_entry *ce = active_cache[i++];
 470                if (ce_stage(ce)) {
 471                        strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
 472                        while (i < active_nr && !strcmp(ce->name,
 473                                                        active_cache[i]->name))
 474                                i++;
 475                }
 476        }
 477}
 478
 479static int do_recursive_merge(struct commit *base, struct commit *next,
 480                              const char *base_label, const char *next_label,
 481                              struct object_id *head, struct strbuf *msgbuf,
 482                              struct replay_opts *opts)
 483{
 484        struct merge_options o;
 485        struct tree *result, *next_tree, *base_tree, *head_tree;
 486        int clean;
 487        char **xopt;
 488        static struct lock_file index_lock;
 489
 490        if (hold_locked_index(&index_lock, LOCK_REPORT_ON_ERROR) < 0)
 491                return -1;
 492
 493        read_cache();
 494
 495        init_merge_options(&o);
 496        o.ancestor = base ? base_label : "(empty tree)";
 497        o.branch1 = "HEAD";
 498        o.branch2 = next ? next_label : "(empty tree)";
 499        if (is_rebase_i(opts))
 500                o.buffer_output = 2;
 501        o.show_rename_progress = 1;
 502
 503        head_tree = parse_tree_indirect(head);
 504        next_tree = next ? next->tree : empty_tree();
 505        base_tree = base ? base->tree : empty_tree();
 506
 507        for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
 508                parse_merge_opt(&o, *xopt);
 509
 510        clean = merge_trees(&o,
 511                            head_tree,
 512                            next_tree, base_tree, &result);
 513        if (is_rebase_i(opts) && clean <= 0)
 514                fputs(o.obuf.buf, stdout);
 515        strbuf_release(&o.obuf);
 516        diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
 517        if (clean < 0)
 518                return clean;
 519
 520        if (active_cache_changed &&
 521            write_locked_index(&the_index, &index_lock, COMMIT_LOCK))
 522                /*
 523                 * TRANSLATORS: %s will be "revert", "cherry-pick" or
 524                 * "rebase -i".
 525                 */
 526                return error(_("%s: Unable to write new index file"),
 527                        _(action_name(opts)));
 528        rollback_lock_file(&index_lock);
 529
 530        if (!clean)
 531                append_conflicts_hint(msgbuf);
 532
 533        return !clean;
 534}
 535
 536static int is_index_unchanged(void)
 537{
 538        struct object_id head_oid;
 539        struct commit *head_commit;
 540
 541        if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
 542                return error(_("could not resolve HEAD commit"));
 543
 544        head_commit = lookup_commit(&head_oid);
 545
 546        /*
 547         * If head_commit is NULL, check_commit, called from
 548         * lookup_commit, would have indicated that head_commit is not
 549         * a commit object already.  parse_commit() will return failure
 550         * without further complaints in such a case.  Otherwise, if
 551         * the commit is invalid, parse_commit() will complain.  So
 552         * there is nothing for us to say here.  Just return failure.
 553         */
 554        if (parse_commit(head_commit))
 555                return -1;
 556
 557        if (!active_cache_tree)
 558                active_cache_tree = cache_tree();
 559
 560        if (!cache_tree_fully_valid(active_cache_tree))
 561                if (cache_tree_update(&the_index, 0))
 562                        return error(_("unable to update cache tree"));
 563
 564        return !oidcmp(&active_cache_tree->oid,
 565                       &head_commit->tree->object.oid);
 566}
 567
 568static int write_author_script(const char *message)
 569{
 570        struct strbuf buf = STRBUF_INIT;
 571        const char *eol;
 572        int res;
 573
 574        for (;;)
 575                if (!*message || starts_with(message, "\n")) {
 576missing_author:
 577                        /* Missing 'author' line? */
 578                        unlink(rebase_path_author_script());
 579                        return 0;
 580                } else if (skip_prefix(message, "author ", &message))
 581                        break;
 582                else if ((eol = strchr(message, '\n')))
 583                        message = eol + 1;
 584                else
 585                        goto missing_author;
 586
 587        strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
 588        while (*message && *message != '\n' && *message != '\r')
 589                if (skip_prefix(message, " <", &message))
 590                        break;
 591                else if (*message != '\'')
 592                        strbuf_addch(&buf, *(message++));
 593                else
 594                        strbuf_addf(&buf, "'\\\\%c'", *(message++));
 595        strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
 596        while (*message && *message != '\n' && *message != '\r')
 597                if (skip_prefix(message, "> ", &message))
 598                        break;
 599                else if (*message != '\'')
 600                        strbuf_addch(&buf, *(message++));
 601                else
 602                        strbuf_addf(&buf, "'\\\\%c'", *(message++));
 603        strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
 604        while (*message && *message != '\n' && *message != '\r')
 605                if (*message != '\'')
 606                        strbuf_addch(&buf, *(message++));
 607                else
 608                        strbuf_addf(&buf, "'\\\\%c'", *(message++));
 609        res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
 610        strbuf_release(&buf);
 611        return res;
 612}
 613
 614/*
 615 * Read a list of environment variable assignments (such as the author-script
 616 * file) into an environment block. Returns -1 on error, 0 otherwise.
 617 */
 618static int read_env_script(struct argv_array *env)
 619{
 620        struct strbuf script = STRBUF_INIT;
 621        int i, count = 0;
 622        char *p, *p2;
 623
 624        if (strbuf_read_file(&script, rebase_path_author_script(), 256) <= 0)
 625                return -1;
 626
 627        for (p = script.buf; *p; p++)
 628                if (skip_prefix(p, "'\\\\''", (const char **)&p2))
 629                        strbuf_splice(&script, p - script.buf, p2 - p, "'", 1);
 630                else if (*p == '\'')
 631                        strbuf_splice(&script, p-- - script.buf, 1, "", 0);
 632                else if (*p == '\n') {
 633                        *p = '\0';
 634                        count++;
 635                }
 636
 637        for (i = 0, p = script.buf; i < count; i++) {
 638                argv_array_push(env, p);
 639                p += strlen(p) + 1;
 640        }
 641
 642        return 0;
 643}
 644
 645static char *get_author(const char *message)
 646{
 647        size_t len;
 648        const char *a;
 649
 650        a = find_commit_header(message, "author", &len);
 651        if (a)
 652                return xmemdupz(a, len);
 653
 654        return NULL;
 655}
 656
 657static const char staged_changes_advice[] =
 658N_("you have staged changes in your working tree\n"
 659"If these changes are meant to be squashed into the previous commit, run:\n"
 660"\n"
 661"  git commit --amend %s\n"
 662"\n"
 663"If they are meant to go into a new commit, run:\n"
 664"\n"
 665"  git commit %s\n"
 666"\n"
 667"In both cases, once you're done, continue with:\n"
 668"\n"
 669"  git rebase --continue\n");
 670
 671#define ALLOW_EMPTY (1<<0)
 672#define EDIT_MSG    (1<<1)
 673#define AMEND_MSG   (1<<2)
 674#define CLEANUP_MSG (1<<3)
 675#define VERIFY_MSG  (1<<4)
 676
 677/*
 678 * If we are cherry-pick, and if the merge did not result in
 679 * hand-editing, we will hit this commit and inherit the original
 680 * author date and name.
 681 *
 682 * If we are revert, or if our cherry-pick results in a hand merge,
 683 * we had better say that the current user is responsible for that.
 684 *
 685 * An exception is when run_git_commit() is called during an
 686 * interactive rebase: in that case, we will want to retain the
 687 * author metadata.
 688 */
 689static int run_git_commit(const char *defmsg, struct replay_opts *opts,
 690                          unsigned int flags)
 691{
 692        struct child_process cmd = CHILD_PROCESS_INIT;
 693        const char *value;
 694
 695        cmd.git_cmd = 1;
 696
 697        if (is_rebase_i(opts)) {
 698                if (!(flags & EDIT_MSG)) {
 699                        cmd.stdout_to_stderr = 1;
 700                        cmd.err = -1;
 701                }
 702
 703                if (read_env_script(&cmd.env_array)) {
 704                        const char *gpg_opt = gpg_sign_opt_quoted(opts);
 705
 706                        return error(_(staged_changes_advice),
 707                                     gpg_opt, gpg_opt);
 708                }
 709        }
 710
 711        argv_array_push(&cmd.args, "commit");
 712
 713        if (!(flags & VERIFY_MSG))
 714                argv_array_push(&cmd.args, "-n");
 715        if ((flags & AMEND_MSG))
 716                argv_array_push(&cmd.args, "--amend");
 717        if (opts->gpg_sign)
 718                argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
 719        if (defmsg)
 720                argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
 721        if ((flags & CLEANUP_MSG))
 722                argv_array_push(&cmd.args, "--cleanup=strip");
 723        if ((flags & EDIT_MSG))
 724                argv_array_push(&cmd.args, "-e");
 725        else if (!(flags & CLEANUP_MSG) &&
 726                 !opts->signoff && !opts->record_origin &&
 727                 git_config_get_value("commit.cleanup", &value))
 728                argv_array_push(&cmd.args, "--cleanup=verbatim");
 729
 730        if ((flags & ALLOW_EMPTY))
 731                argv_array_push(&cmd.args, "--allow-empty");
 732
 733        if (opts->allow_empty_message)
 734                argv_array_push(&cmd.args, "--allow-empty-message");
 735
 736        if (cmd.err == -1) {
 737                /* hide stderr on success */
 738                struct strbuf buf = STRBUF_INIT;
 739                int rc = pipe_command(&cmd,
 740                                      NULL, 0,
 741                                      /* stdout is already redirected */
 742                                      NULL, 0,
 743                                      &buf, 0);
 744                if (rc)
 745                        fputs(buf.buf, stderr);
 746                strbuf_release(&buf);
 747                return rc;
 748        }
 749
 750        return run_command(&cmd);
 751}
 752
 753static int rest_is_empty(const struct strbuf *sb, int start)
 754{
 755        int i, eol;
 756        const char *nl;
 757
 758        /* Check if the rest is just whitespace and Signed-off-by's. */
 759        for (i = start; i < sb->len; i++) {
 760                nl = memchr(sb->buf + i, '\n', sb->len - i);
 761                if (nl)
 762                        eol = nl - sb->buf;
 763                else
 764                        eol = sb->len;
 765
 766                if (strlen(sign_off_header) <= eol - i &&
 767                    starts_with(sb->buf + i, sign_off_header)) {
 768                        i = eol;
 769                        continue;
 770                }
 771                while (i < eol)
 772                        if (!isspace(sb->buf[i++]))
 773                                return 0;
 774        }
 775
 776        return 1;
 777}
 778
 779/*
 780 * Find out if the message in the strbuf contains only whitespace and
 781 * Signed-off-by lines.
 782 */
 783int message_is_empty(const struct strbuf *sb,
 784                     enum commit_msg_cleanup_mode cleanup_mode)
 785{
 786        if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
 787                return 0;
 788        return rest_is_empty(sb, 0);
 789}
 790
 791/*
 792 * See if the user edited the message in the editor or left what
 793 * was in the template intact
 794 */
 795int template_untouched(const struct strbuf *sb, const char *template_file,
 796                       enum commit_msg_cleanup_mode cleanup_mode)
 797{
 798        struct strbuf tmpl = STRBUF_INIT;
 799        const char *start;
 800
 801        if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
 802                return 0;
 803
 804        if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
 805                return 0;
 806
 807        strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
 808        if (!skip_prefix(sb->buf, tmpl.buf, &start))
 809                start = sb->buf;
 810        strbuf_release(&tmpl);
 811        return rest_is_empty(sb, start - sb->buf);
 812}
 813
 814int update_head_with_reflog(const struct commit *old_head,
 815                            const struct object_id *new_head,
 816                            const char *action, const struct strbuf *msg,
 817                            struct strbuf *err)
 818{
 819        struct ref_transaction *transaction;
 820        struct strbuf sb = STRBUF_INIT;
 821        const char *nl;
 822        int ret = 0;
 823
 824        if (action) {
 825                strbuf_addstr(&sb, action);
 826                strbuf_addstr(&sb, ": ");
 827        }
 828
 829        nl = strchr(msg->buf, '\n');
 830        if (nl) {
 831                strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
 832        } else {
 833                strbuf_addbuf(&sb, msg);
 834                strbuf_addch(&sb, '\n');
 835        }
 836
 837        transaction = ref_transaction_begin(err);
 838        if (!transaction ||
 839            ref_transaction_update(transaction, "HEAD", new_head,
 840                                   old_head ? &old_head->object.oid : &null_oid,
 841                                   0, sb.buf, err) ||
 842            ref_transaction_commit(transaction, err)) {
 843                ret = -1;
 844        }
 845        ref_transaction_free(transaction);
 846        strbuf_release(&sb);
 847
 848        return ret;
 849}
 850
 851static int run_rewrite_hook(const struct object_id *oldoid,
 852                            const struct object_id *newoid)
 853{
 854        struct child_process proc = CHILD_PROCESS_INIT;
 855        const char *argv[3];
 856        int code;
 857        struct strbuf sb = STRBUF_INIT;
 858
 859        argv[0] = find_hook("post-rewrite");
 860        if (!argv[0])
 861                return 0;
 862
 863        argv[1] = "amend";
 864        argv[2] = NULL;
 865
 866        proc.argv = argv;
 867        proc.in = -1;
 868        proc.stdout_to_stderr = 1;
 869
 870        code = start_command(&proc);
 871        if (code)
 872                return code;
 873        strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
 874        sigchain_push(SIGPIPE, SIG_IGN);
 875        write_in_full(proc.in, sb.buf, sb.len);
 876        close(proc.in);
 877        strbuf_release(&sb);
 878        sigchain_pop(SIGPIPE);
 879        return finish_command(&proc);
 880}
 881
 882void commit_post_rewrite(const struct commit *old_head,
 883                         const struct object_id *new_head)
 884{
 885        struct notes_rewrite_cfg *cfg;
 886
 887        cfg = init_copy_notes_for_rewrite("amend");
 888        if (cfg) {
 889                /* we are amending, so old_head is not NULL */
 890                copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
 891                finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
 892        }
 893        run_rewrite_hook(&old_head->object.oid, new_head);
 894}
 895
 896static int run_prepare_commit_msg_hook(struct strbuf *msg, const char *commit)
 897{
 898        struct argv_array hook_env = ARGV_ARRAY_INIT;
 899        int ret;
 900        const char *name;
 901
 902        name = git_path_commit_editmsg();
 903        if (write_message(msg->buf, msg->len, name, 0))
 904                return -1;
 905
 906        argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", get_index_file());
 907        argv_array_push(&hook_env, "GIT_EDITOR=:");
 908        if (commit)
 909                ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
 910                                  "commit", commit, NULL);
 911        else
 912                ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
 913                                  "message", NULL);
 914        if (ret)
 915                ret = error(_("'prepare-commit-msg' hook failed"));
 916        argv_array_clear(&hook_env);
 917
 918        return ret;
 919}
 920
 921static const char implicit_ident_advice_noconfig[] =
 922N_("Your name and email address were configured automatically based\n"
 923"on your username and hostname. Please check that they are accurate.\n"
 924"You can suppress this message by setting them explicitly. Run the\n"
 925"following command and follow the instructions in your editor to edit\n"
 926"your configuration file:\n"
 927"\n"
 928"    git config --global --edit\n"
 929"\n"
 930"After doing this, you may fix the identity used for this commit with:\n"
 931"\n"
 932"    git commit --amend --reset-author\n");
 933
 934static const char implicit_ident_advice_config[] =
 935N_("Your name and email address were configured automatically based\n"
 936"on your username and hostname. Please check that they are accurate.\n"
 937"You can suppress this message by setting them explicitly:\n"
 938"\n"
 939"    git config --global user.name \"Your Name\"\n"
 940"    git config --global user.email you@example.com\n"
 941"\n"
 942"After doing this, you may fix the identity used for this commit with:\n"
 943"\n"
 944"    git commit --amend --reset-author\n");
 945
 946static const char *implicit_ident_advice(void)
 947{
 948        char *user_config = expand_user_path("~/.gitconfig", 0);
 949        char *xdg_config = xdg_config_home("config");
 950        int config_exists = file_exists(user_config) || file_exists(xdg_config);
 951
 952        free(user_config);
 953        free(xdg_config);
 954
 955        if (config_exists)
 956                return _(implicit_ident_advice_config);
 957        else
 958                return _(implicit_ident_advice_noconfig);
 959
 960}
 961
 962void print_commit_summary(const char *prefix, const struct object_id *oid,
 963                          unsigned int flags)
 964{
 965        struct rev_info rev;
 966        struct commit *commit;
 967        struct strbuf format = STRBUF_INIT;
 968        const char *head;
 969        struct pretty_print_context pctx = {0};
 970        struct strbuf author_ident = STRBUF_INIT;
 971        struct strbuf committer_ident = STRBUF_INIT;
 972
 973        commit = lookup_commit(oid);
 974        if (!commit)
 975                die(_("couldn't look up newly created commit"));
 976        if (parse_commit(commit))
 977                die(_("could not parse newly created commit"));
 978
 979        strbuf_addstr(&format, "format:%h] %s");
 980
 981        format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
 982        format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
 983        if (strbuf_cmp(&author_ident, &committer_ident)) {
 984                strbuf_addstr(&format, "\n Author: ");
 985                strbuf_addbuf_percentquote(&format, &author_ident);
 986        }
 987        if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
 988                struct strbuf date = STRBUF_INIT;
 989
 990                format_commit_message(commit, "%ad", &date, &pctx);
 991                strbuf_addstr(&format, "\n Date: ");
 992                strbuf_addbuf_percentquote(&format, &date);
 993                strbuf_release(&date);
 994        }
 995        if (!committer_ident_sufficiently_given()) {
 996                strbuf_addstr(&format, "\n Committer: ");
 997                strbuf_addbuf_percentquote(&format, &committer_ident);
 998                if (advice_implicit_identity) {
 999                        strbuf_addch(&format, '\n');
1000                        strbuf_addstr(&format, implicit_ident_advice());
1001                }
1002        }
1003        strbuf_release(&author_ident);
1004        strbuf_release(&committer_ident);
1005
1006        init_revisions(&rev, prefix);
1007        setup_revisions(0, NULL, &rev, NULL);
1008
1009        rev.diff = 1;
1010        rev.diffopt.output_format =
1011                DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1012
1013        rev.verbose_header = 1;
1014        rev.show_root_diff = 1;
1015        get_commit_format(format.buf, &rev);
1016        rev.always_show_header = 0;
1017        rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1018        rev.diffopt.break_opt = 0;
1019        diff_setup_done(&rev.diffopt);
1020
1021        head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1022        if (!head)
1023                die_errno(_("unable to resolve HEAD after creating commit"));
1024        if (!strcmp(head, "HEAD"))
1025                head = _("detached HEAD");
1026        else
1027                skip_prefix(head, "refs/heads/", &head);
1028        printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1029                                                _(" (root-commit)") : "");
1030
1031        if (!log_tree_commit(&rev, commit)) {
1032                rev.always_show_header = 1;
1033                rev.use_terminator = 1;
1034                log_tree_commit(&rev, commit);
1035        }
1036
1037        strbuf_release(&format);
1038}
1039
1040static int parse_head(struct commit **head)
1041{
1042        struct commit *current_head;
1043        struct object_id oid;
1044
1045        if (get_oid("HEAD", &oid)) {
1046                current_head = NULL;
1047        } else {
1048                current_head = lookup_commit_reference(&oid);
1049                if (!current_head)
1050                        return error(_("could not parse HEAD"));
1051                if (oidcmp(&oid, &current_head->object.oid)) {
1052                        warning(_("HEAD %s is not a commit!"),
1053                                oid_to_hex(&oid));
1054                }
1055                if (parse_commit(current_head))
1056                        return error(_("could not parse HEAD commit"));
1057        }
1058        *head = current_head;
1059
1060        return 0;
1061}
1062
1063/*
1064 * Try to commit without forking 'git commit'. In some cases we need
1065 * to run 'git commit' to display an error message
1066 *
1067 * Returns:
1068 *  -1 - error unable to commit
1069 *   0 - success
1070 *   1 - run 'git commit'
1071 */
1072static int try_to_commit(struct strbuf *msg, const char *author,
1073                         struct replay_opts *opts, unsigned int flags,
1074                         struct object_id *oid)
1075{
1076        struct object_id tree;
1077        struct commit *current_head;
1078        struct commit_list *parents = NULL;
1079        struct commit_extra_header *extra = NULL;
1080        struct strbuf err = STRBUF_INIT;
1081        struct strbuf commit_msg = STRBUF_INIT;
1082        char *amend_author = NULL;
1083        const char *hook_commit = NULL;
1084        enum commit_msg_cleanup_mode cleanup;
1085        int res = 0;
1086
1087        if (parse_head(&current_head))
1088                return -1;
1089
1090        if (flags & AMEND_MSG) {
1091                const char *exclude_gpgsig[] = { "gpgsig", NULL };
1092                const char *out_enc = get_commit_output_encoding();
1093                const char *message = logmsg_reencode(current_head, NULL,
1094                                                      out_enc);
1095
1096                if (!msg) {
1097                        const char *orig_message = NULL;
1098
1099                        find_commit_subject(message, &orig_message);
1100                        msg = &commit_msg;
1101                        strbuf_addstr(msg, orig_message);
1102                        hook_commit = "HEAD";
1103                }
1104                author = amend_author = get_author(message);
1105                unuse_commit_buffer(current_head, message);
1106                if (!author) {
1107                        res = error(_("unable to parse commit author"));
1108                        goto out;
1109                }
1110                parents = copy_commit_list(current_head->parents);
1111                extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1112        } else if (current_head) {
1113                commit_list_insert(current_head, &parents);
1114        }
1115
1116        if (write_cache_as_tree(tree.hash, 0, NULL)) {
1117                res = error(_("git write-tree failed to write a tree"));
1118                goto out;
1119        }
1120
1121        if (!(flags & ALLOW_EMPTY) && !oidcmp(current_head ?
1122                                              &current_head->tree->object.oid :
1123                                              &empty_tree_oid, &tree)) {
1124                res = 1; /* run 'git commit' to display error message */
1125                goto out;
1126        }
1127
1128        if (find_hook("prepare-commit-msg")) {
1129                res = run_prepare_commit_msg_hook(msg, hook_commit);
1130                if (res)
1131                        goto out;
1132                if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1133                                     2048) < 0) {
1134                        res = error_errno(_("unable to read commit message "
1135                                              "from '%s'"),
1136                                            git_path_commit_editmsg());
1137                        goto out;
1138                }
1139                msg = &commit_msg;
1140        }
1141
1142        cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1143                                          opts->default_msg_cleanup;
1144
1145        if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1146                strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1147        if (!opts->allow_empty_message && message_is_empty(msg, cleanup)) {
1148                res = 1; /* run 'git commit' to display error message */
1149                goto out;
1150        }
1151
1152        if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1153                                 oid, author, opts->gpg_sign, extra)) {
1154                res = error(_("failed to write commit object"));
1155                goto out;
1156        }
1157
1158        if (update_head_with_reflog(current_head, oid,
1159                                    getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1160                res = error("%s", err.buf);
1161                goto out;
1162        }
1163
1164        if (flags & AMEND_MSG)
1165                commit_post_rewrite(current_head, oid);
1166
1167out:
1168        free_commit_extra_headers(extra);
1169        strbuf_release(&err);
1170        strbuf_release(&commit_msg);
1171        free(amend_author);
1172
1173        return res;
1174}
1175
1176static int do_commit(const char *msg_file, const char *author,
1177                     struct replay_opts *opts, unsigned int flags)
1178{
1179        int res = 1;
1180
1181        if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG)) {
1182                struct object_id oid;
1183                struct strbuf sb = STRBUF_INIT;
1184
1185                if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1186                        return error_errno(_("unable to read commit message "
1187                                             "from '%s'"),
1188                                           msg_file);
1189
1190                res = try_to_commit(msg_file ? &sb : NULL, author, opts, flags,
1191                                    &oid);
1192                strbuf_release(&sb);
1193                if (!res) {
1194                        unlink(git_path_cherry_pick_head());
1195                        unlink(git_path_merge_msg());
1196                        if (!is_rebase_i(opts))
1197                                print_commit_summary(NULL, &oid,
1198                                                SUMMARY_SHOW_AUTHOR_DATE);
1199                        return res;
1200                }
1201        }
1202        if (res == 1)
1203                return run_git_commit(msg_file, opts, flags);
1204
1205        return res;
1206}
1207
1208static int is_original_commit_empty(struct commit *commit)
1209{
1210        const struct object_id *ptree_oid;
1211
1212        if (parse_commit(commit))
1213                return error(_("could not parse commit %s"),
1214                             oid_to_hex(&commit->object.oid));
1215        if (commit->parents) {
1216                struct commit *parent = commit->parents->item;
1217                if (parse_commit(parent))
1218                        return error(_("could not parse parent commit %s"),
1219                                oid_to_hex(&parent->object.oid));
1220                ptree_oid = &parent->tree->object.oid;
1221        } else {
1222                ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1223        }
1224
1225        return !oidcmp(ptree_oid, &commit->tree->object.oid);
1226}
1227
1228/*
1229 * Do we run "git commit" with "--allow-empty"?
1230 */
1231static int allow_empty(struct replay_opts *opts, struct commit *commit)
1232{
1233        int index_unchanged, empty_commit;
1234
1235        /*
1236         * Three cases:
1237         *
1238         * (1) we do not allow empty at all and error out.
1239         *
1240         * (2) we allow ones that were initially empty, but
1241         * forbid the ones that become empty;
1242         *
1243         * (3) we allow both.
1244         */
1245        if (!opts->allow_empty)
1246                return 0; /* let "git commit" barf as necessary */
1247
1248        index_unchanged = is_index_unchanged();
1249        if (index_unchanged < 0)
1250                return index_unchanged;
1251        if (!index_unchanged)
1252                return 0; /* we do not have to say --allow-empty */
1253
1254        if (opts->keep_redundant_commits)
1255                return 1;
1256
1257        empty_commit = is_original_commit_empty(commit);
1258        if (empty_commit < 0)
1259                return empty_commit;
1260        if (!empty_commit)
1261                return 0;
1262        else
1263                return 1;
1264}
1265
1266/*
1267 * Note that ordering matters in this enum. Not only must it match the mapping
1268 * below, it is also divided into several sections that matter.  When adding
1269 * new commands, make sure you add it in the right section.
1270 */
1271enum todo_command {
1272        /* commands that handle commits */
1273        TODO_PICK = 0,
1274        TODO_REVERT,
1275        TODO_EDIT,
1276        TODO_REWORD,
1277        TODO_FIXUP,
1278        TODO_SQUASH,
1279        /* commands that do something else than handling a single commit */
1280        TODO_EXEC,
1281        /* commands that do nothing but are counted for reporting progress */
1282        TODO_NOOP,
1283        TODO_DROP,
1284        /* comments (not counted for reporting progress) */
1285        TODO_COMMENT
1286};
1287
1288static struct {
1289        char c;
1290        const char *str;
1291} todo_command_info[] = {
1292        { 'p', "pick" },
1293        { 0,   "revert" },
1294        { 'e', "edit" },
1295        { 'r', "reword" },
1296        { 'f', "fixup" },
1297        { 's', "squash" },
1298        { 'x', "exec" },
1299        { 0,   "noop" },
1300        { 'd', "drop" },
1301        { 0,   NULL }
1302};
1303
1304static const char *command_to_string(const enum todo_command command)
1305{
1306        if (command < TODO_COMMENT)
1307                return todo_command_info[command].str;
1308        die("Unknown command: %d", command);
1309}
1310
1311static char command_to_char(const enum todo_command command)
1312{
1313        if (command < TODO_COMMENT && todo_command_info[command].c)
1314                return todo_command_info[command].c;
1315        return comment_line_char;
1316}
1317
1318static int is_noop(const enum todo_command command)
1319{
1320        return TODO_NOOP <= command;
1321}
1322
1323static int is_fixup(enum todo_command command)
1324{
1325        return command == TODO_FIXUP || command == TODO_SQUASH;
1326}
1327
1328static int update_squash_messages(enum todo_command command,
1329                struct commit *commit, struct replay_opts *opts)
1330{
1331        struct strbuf buf = STRBUF_INIT;
1332        int count, res;
1333        const char *message, *body;
1334
1335        if (file_exists(rebase_path_squash_msg())) {
1336                struct strbuf header = STRBUF_INIT;
1337                char *eol, *p;
1338
1339                if (strbuf_read_file(&buf, rebase_path_squash_msg(), 2048) <= 0)
1340                        return error(_("could not read '%s'"),
1341                                rebase_path_squash_msg());
1342
1343                p = buf.buf + 1;
1344                eol = strchrnul(buf.buf, '\n');
1345                if (buf.buf[0] != comment_line_char ||
1346                    (p += strcspn(p, "0123456789\n")) == eol)
1347                        return error(_("unexpected 1st line of squash message:"
1348                                       "\n\n\t%.*s"),
1349                                     (int)(eol - buf.buf), buf.buf);
1350                count = strtol(p, NULL, 10);
1351
1352                if (count < 1)
1353                        return error(_("invalid 1st line of squash message:\n"
1354                                       "\n\t%.*s"),
1355                                     (int)(eol - buf.buf), buf.buf);
1356
1357                strbuf_addf(&header, "%c ", comment_line_char);
1358                strbuf_addf(&header,
1359                            _("This is a combination of %d commits."), ++count);
1360                strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1361                strbuf_release(&header);
1362        } else {
1363                struct object_id head;
1364                struct commit *head_commit;
1365                const char *head_message, *body;
1366
1367                if (get_oid("HEAD", &head))
1368                        return error(_("need a HEAD to fixup"));
1369                if (!(head_commit = lookup_commit_reference(&head)))
1370                        return error(_("could not read HEAD"));
1371                if (!(head_message = get_commit_buffer(head_commit, NULL)))
1372                        return error(_("could not read HEAD's commit message"));
1373
1374                find_commit_subject(head_message, &body);
1375                if (write_message(body, strlen(body),
1376                                  rebase_path_fixup_msg(), 0)) {
1377                        unuse_commit_buffer(head_commit, head_message);
1378                        return error(_("cannot write '%s'"),
1379                                     rebase_path_fixup_msg());
1380                }
1381
1382                count = 2;
1383                strbuf_addf(&buf, "%c ", comment_line_char);
1384                strbuf_addf(&buf, _("This is a combination of %d commits."),
1385                            count);
1386                strbuf_addf(&buf, "\n%c ", comment_line_char);
1387                strbuf_addstr(&buf, _("This is the 1st commit message:"));
1388                strbuf_addstr(&buf, "\n\n");
1389                strbuf_addstr(&buf, body);
1390
1391                unuse_commit_buffer(head_commit, head_message);
1392        }
1393
1394        if (!(message = get_commit_buffer(commit, NULL)))
1395                return error(_("could not read commit message of %s"),
1396                             oid_to_hex(&commit->object.oid));
1397        find_commit_subject(message, &body);
1398
1399        if (command == TODO_SQUASH) {
1400                unlink(rebase_path_fixup_msg());
1401                strbuf_addf(&buf, "\n%c ", comment_line_char);
1402                strbuf_addf(&buf, _("This is the commit message #%d:"), count);
1403                strbuf_addstr(&buf, "\n\n");
1404                strbuf_addstr(&buf, body);
1405        } else if (command == TODO_FIXUP) {
1406                strbuf_addf(&buf, "\n%c ", comment_line_char);
1407                strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1408                            count);
1409                strbuf_addstr(&buf, "\n\n");
1410                strbuf_add_commented_lines(&buf, body, strlen(body));
1411        } else
1412                return error(_("unknown command: %d"), command);
1413        unuse_commit_buffer(commit, message);
1414
1415        res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1416        strbuf_release(&buf);
1417        return res;
1418}
1419
1420static void flush_rewritten_pending(void) {
1421        struct strbuf buf = STRBUF_INIT;
1422        struct object_id newoid;
1423        FILE *out;
1424
1425        if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1426            !get_oid("HEAD", &newoid) &&
1427            (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1428                char *bol = buf.buf, *eol;
1429
1430                while (*bol) {
1431                        eol = strchrnul(bol, '\n');
1432                        fprintf(out, "%.*s %s\n", (int)(eol - bol),
1433                                        bol, oid_to_hex(&newoid));
1434                        if (!*eol)
1435                                break;
1436                        bol = eol + 1;
1437                }
1438                fclose(out);
1439                unlink(rebase_path_rewritten_pending());
1440        }
1441        strbuf_release(&buf);
1442}
1443
1444static void record_in_rewritten(struct object_id *oid,
1445                enum todo_command next_command) {
1446        FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1447
1448        if (!out)
1449                return;
1450
1451        fprintf(out, "%s\n", oid_to_hex(oid));
1452        fclose(out);
1453
1454        if (!is_fixup(next_command))
1455                flush_rewritten_pending();
1456}
1457
1458static int do_pick_commit(enum todo_command command, struct commit *commit,
1459                struct replay_opts *opts, int final_fixup)
1460{
1461        unsigned int flags = opts->edit ? EDIT_MSG : 0;
1462        const char *msg_file = opts->edit ? NULL : git_path_merge_msg();
1463        struct object_id head;
1464        struct commit *base, *next, *parent;
1465        const char *base_label, *next_label;
1466        char *author = NULL;
1467        struct commit_message msg = { NULL, NULL, NULL, NULL };
1468        struct strbuf msgbuf = STRBUF_INIT;
1469        int res, unborn = 0, allow;
1470
1471        if (opts->no_commit) {
1472                /*
1473                 * We do not intend to commit immediately.  We just want to
1474                 * merge the differences in, so let's compute the tree
1475                 * that represents the "current" state for merge-recursive
1476                 * to work on.
1477                 */
1478                if (write_cache_as_tree(head.hash, 0, NULL))
1479                        return error(_("your index file is unmerged."));
1480        } else {
1481                unborn = get_oid("HEAD", &head);
1482                if (unborn)
1483                        oidcpy(&head, the_hash_algo->empty_tree);
1484                if (index_differs_from(unborn ? EMPTY_TREE_SHA1_HEX : "HEAD",
1485                                       NULL, 0))
1486                        return error_dirty_index(opts);
1487        }
1488        discard_cache();
1489
1490        if (!commit->parents)
1491                parent = NULL;
1492        else if (commit->parents->next) {
1493                /* Reverting or cherry-picking a merge commit */
1494                int cnt;
1495                struct commit_list *p;
1496
1497                if (!opts->mainline)
1498                        return error(_("commit %s is a merge but no -m option was given."),
1499                                oid_to_hex(&commit->object.oid));
1500
1501                for (cnt = 1, p = commit->parents;
1502                     cnt != opts->mainline && p;
1503                     cnt++)
1504                        p = p->next;
1505                if (cnt != opts->mainline || !p)
1506                        return error(_("commit %s does not have parent %d"),
1507                                oid_to_hex(&commit->object.oid), opts->mainline);
1508                parent = p->item;
1509        } else if (0 < opts->mainline)
1510                return error(_("mainline was specified but commit %s is not a merge."),
1511                        oid_to_hex(&commit->object.oid));
1512        else
1513                parent = commit->parents->item;
1514
1515        if (get_message(commit, &msg) != 0)
1516                return error(_("cannot get commit message for %s"),
1517                        oid_to_hex(&commit->object.oid));
1518
1519        if (opts->allow_ff && !is_fixup(command) &&
1520            ((parent && !oidcmp(&parent->object.oid, &head)) ||
1521             (!parent && unborn))) {
1522                if (is_rebase_i(opts))
1523                        write_author_script(msg.message);
1524                res = fast_forward_to(&commit->object.oid, &head, unborn,
1525                        opts);
1526                if (res || command != TODO_REWORD)
1527                        goto leave;
1528                flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1529                msg_file = NULL;
1530                goto fast_forward_edit;
1531        }
1532        if (parent && parse_commit(parent) < 0)
1533                /* TRANSLATORS: The first %s will be a "todo" command like
1534                   "revert" or "pick", the second %s a SHA1. */
1535                return error(_("%s: cannot parse parent commit %s"),
1536                        command_to_string(command),
1537                        oid_to_hex(&parent->object.oid));
1538
1539        /*
1540         * "commit" is an existing commit.  We would want to apply
1541         * the difference it introduces since its first parent "prev"
1542         * on top of the current HEAD if we are cherry-pick.  Or the
1543         * reverse of it if we are revert.
1544         */
1545
1546        if (command == TODO_REVERT) {
1547                base = commit;
1548                base_label = msg.label;
1549                next = parent;
1550                next_label = msg.parent_label;
1551                strbuf_addstr(&msgbuf, "Revert \"");
1552                strbuf_addstr(&msgbuf, msg.subject);
1553                strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1554                strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1555
1556                if (commit->parents && commit->parents->next) {
1557                        strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1558                        strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1559                }
1560                strbuf_addstr(&msgbuf, ".\n");
1561        } else {
1562                const char *p;
1563
1564                base = parent;
1565                base_label = msg.parent_label;
1566                next = commit;
1567                next_label = msg.label;
1568
1569                /* Append the commit log message to msgbuf. */
1570                if (find_commit_subject(msg.message, &p))
1571                        strbuf_addstr(&msgbuf, p);
1572
1573                if (opts->record_origin) {
1574                        strbuf_complete_line(&msgbuf);
1575                        if (!has_conforming_footer(&msgbuf, NULL, 0))
1576                                strbuf_addch(&msgbuf, '\n');
1577                        strbuf_addstr(&msgbuf, cherry_picked_prefix);
1578                        strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1579                        strbuf_addstr(&msgbuf, ")\n");
1580                }
1581                if (!is_fixup(command))
1582                        author = get_author(msg.message);
1583        }
1584
1585        if (command == TODO_REWORD)
1586                flags |= EDIT_MSG | VERIFY_MSG;
1587        else if (is_fixup(command)) {
1588                if (update_squash_messages(command, commit, opts))
1589                        return -1;
1590                flags |= AMEND_MSG;
1591                if (!final_fixup)
1592                        msg_file = rebase_path_squash_msg();
1593                else if (file_exists(rebase_path_fixup_msg())) {
1594                        flags |= CLEANUP_MSG;
1595                        msg_file = rebase_path_fixup_msg();
1596                } else {
1597                        const char *dest = git_path_squash_msg();
1598                        unlink(dest);
1599                        if (copy_file(dest, rebase_path_squash_msg(), 0666))
1600                                return error(_("could not rename '%s' to '%s'"),
1601                                             rebase_path_squash_msg(), dest);
1602                        unlink(git_path_merge_msg());
1603                        msg_file = dest;
1604                        flags |= EDIT_MSG;
1605                }
1606        }
1607
1608        if (opts->signoff)
1609                append_signoff(&msgbuf, 0, 0);
1610
1611        if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1612                res = -1;
1613        else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1614                res = do_recursive_merge(base, next, base_label, next_label,
1615                                         &head, &msgbuf, opts);
1616                if (res < 0)
1617                        return res;
1618                res |= write_message(msgbuf.buf, msgbuf.len,
1619                                     git_path_merge_msg(), 0);
1620        } else {
1621                struct commit_list *common = NULL;
1622                struct commit_list *remotes = NULL;
1623
1624                res = write_message(msgbuf.buf, msgbuf.len,
1625                                    git_path_merge_msg(), 0);
1626
1627                commit_list_insert(base, &common);
1628                commit_list_insert(next, &remotes);
1629                res |= try_merge_command(opts->strategy,
1630                                         opts->xopts_nr, (const char **)opts->xopts,
1631                                        common, oid_to_hex(&head), remotes);
1632                free_commit_list(common);
1633                free_commit_list(remotes);
1634        }
1635        strbuf_release(&msgbuf);
1636
1637        /*
1638         * If the merge was clean or if it failed due to conflict, we write
1639         * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1640         * However, if the merge did not even start, then we don't want to
1641         * write it at all.
1642         */
1643        if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1644            update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1645                       REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1646                res = -1;
1647        if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1648            update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1649                       REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1650                res = -1;
1651
1652        if (res) {
1653                error(command == TODO_REVERT
1654                      ? _("could not revert %s... %s")
1655                      : _("could not apply %s... %s"),
1656                      short_commit_name(commit), msg.subject);
1657                print_advice(res == 1, opts);
1658                rerere(opts->allow_rerere_auto);
1659                goto leave;
1660        }
1661
1662        allow = allow_empty(opts, commit);
1663        if (allow < 0) {
1664                res = allow;
1665                goto leave;
1666        } else if (allow)
1667                flags |= ALLOW_EMPTY;
1668        if (!opts->no_commit) {
1669fast_forward_edit:
1670                if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1671                        res = do_commit(msg_file, author, opts, flags);
1672                else
1673                        res = error(_("unable to parse commit author"));
1674        }
1675
1676        if (!res && final_fixup) {
1677                unlink(rebase_path_fixup_msg());
1678                unlink(rebase_path_squash_msg());
1679        }
1680
1681leave:
1682        free_message(commit, &msg);
1683        free(author);
1684        update_abort_safety_file();
1685
1686        return res;
1687}
1688
1689static int prepare_revs(struct replay_opts *opts)
1690{
1691        /*
1692         * picking (but not reverting) ranges (but not individual revisions)
1693         * should be done in reverse
1694         */
1695        if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1696                opts->revs->reverse ^= 1;
1697
1698        if (prepare_revision_walk(opts->revs))
1699                return error(_("revision walk setup failed"));
1700
1701        if (!opts->revs->commits)
1702                return error(_("empty commit set passed"));
1703        return 0;
1704}
1705
1706static int read_and_refresh_cache(struct replay_opts *opts)
1707{
1708        static struct lock_file index_lock;
1709        int index_fd = hold_locked_index(&index_lock, 0);
1710        if (read_index_preload(&the_index, NULL) < 0) {
1711                rollback_lock_file(&index_lock);
1712                return error(_("git %s: failed to read the index"),
1713                        _(action_name(opts)));
1714        }
1715        refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
1716        if (the_index.cache_changed && index_fd >= 0) {
1717                if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK)) {
1718                        return error(_("git %s: failed to refresh the index"),
1719                                _(action_name(opts)));
1720                }
1721        }
1722        rollback_lock_file(&index_lock);
1723        return 0;
1724}
1725
1726struct todo_item {
1727        enum todo_command command;
1728        struct commit *commit;
1729        const char *arg;
1730        int arg_len;
1731        size_t offset_in_buf;
1732};
1733
1734struct todo_list {
1735        struct strbuf buf;
1736        struct todo_item *items;
1737        int nr, alloc, current;
1738        int done_nr, total_nr;
1739        struct stat_data stat;
1740};
1741
1742#define TODO_LIST_INIT { STRBUF_INIT }
1743
1744static void todo_list_release(struct todo_list *todo_list)
1745{
1746        strbuf_release(&todo_list->buf);
1747        FREE_AND_NULL(todo_list->items);
1748        todo_list->nr = todo_list->alloc = 0;
1749}
1750
1751static struct todo_item *append_new_todo(struct todo_list *todo_list)
1752{
1753        ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
1754        return todo_list->items + todo_list->nr++;
1755}
1756
1757static int parse_insn_line(struct todo_item *item, const char *bol, char *eol)
1758{
1759        struct object_id commit_oid;
1760        char *end_of_object_name;
1761        int i, saved, status, padding;
1762
1763        /* left-trim */
1764        bol += strspn(bol, " \t");
1765
1766        if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
1767                item->command = TODO_COMMENT;
1768                item->commit = NULL;
1769                item->arg = bol;
1770                item->arg_len = eol - bol;
1771                return 0;
1772        }
1773
1774        for (i = 0; i < TODO_COMMENT; i++)
1775                if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
1776                        item->command = i;
1777                        break;
1778                } else if (bol[1] == ' ' && *bol == todo_command_info[i].c) {
1779                        bol++;
1780                        item->command = i;
1781                        break;
1782                }
1783        if (i >= TODO_COMMENT)
1784                return -1;
1785
1786        /* Eat up extra spaces/ tabs before object name */
1787        padding = strspn(bol, " \t");
1788        bol += padding;
1789
1790        if (item->command == TODO_NOOP) {
1791                if (bol != eol)
1792                        return error(_("%s does not accept arguments: '%s'"),
1793                                     command_to_string(item->command), bol);
1794                item->commit = NULL;
1795                item->arg = bol;
1796                item->arg_len = eol - bol;
1797                return 0;
1798        }
1799
1800        if (!padding)
1801                return error(_("missing arguments for %s"),
1802                             command_to_string(item->command));
1803
1804        if (item->command == TODO_EXEC) {
1805                item->commit = NULL;
1806                item->arg = bol;
1807                item->arg_len = (int)(eol - bol);
1808                return 0;
1809        }
1810
1811        end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
1812        saved = *end_of_object_name;
1813        *end_of_object_name = '\0';
1814        status = get_oid(bol, &commit_oid);
1815        *end_of_object_name = saved;
1816
1817        item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
1818        item->arg_len = (int)(eol - item->arg);
1819
1820        if (status < 0)
1821                return -1;
1822
1823        item->commit = lookup_commit_reference(&commit_oid);
1824        return !item->commit;
1825}
1826
1827static int parse_insn_buffer(char *buf, struct todo_list *todo_list)
1828{
1829        struct todo_item *item;
1830        char *p = buf, *next_p;
1831        int i, res = 0, fixup_okay = file_exists(rebase_path_done());
1832
1833        for (i = 1; *p; i++, p = next_p) {
1834                char *eol = strchrnul(p, '\n');
1835
1836                next_p = *eol ? eol + 1 /* skip LF */ : eol;
1837
1838                if (p != eol && eol[-1] == '\r')
1839                        eol--; /* strip Carriage Return */
1840
1841                item = append_new_todo(todo_list);
1842                item->offset_in_buf = p - todo_list->buf.buf;
1843                if (parse_insn_line(item, p, eol)) {
1844                        res = error(_("invalid line %d: %.*s"),
1845                                i, (int)(eol - p), p);
1846                        item->command = TODO_NOOP;
1847                }
1848
1849                if (fixup_okay)
1850                        ; /* do nothing */
1851                else if (is_fixup(item->command))
1852                        return error(_("cannot '%s' without a previous commit"),
1853                                command_to_string(item->command));
1854                else if (!is_noop(item->command))
1855                        fixup_okay = 1;
1856        }
1857
1858        return res;
1859}
1860
1861static int count_commands(struct todo_list *todo_list)
1862{
1863        int count = 0, i;
1864
1865        for (i = 0; i < todo_list->nr; i++)
1866                if (todo_list->items[i].command != TODO_COMMENT)
1867                        count++;
1868
1869        return count;
1870}
1871
1872static int read_populate_todo(struct todo_list *todo_list,
1873                        struct replay_opts *opts)
1874{
1875        struct stat st;
1876        const char *todo_file = get_todo_path(opts);
1877        int fd, res;
1878
1879        strbuf_reset(&todo_list->buf);
1880        fd = open(todo_file, O_RDONLY);
1881        if (fd < 0)
1882                return error_errno(_("could not open '%s'"), todo_file);
1883        if (strbuf_read(&todo_list->buf, fd, 0) < 0) {
1884                close(fd);
1885                return error(_("could not read '%s'."), todo_file);
1886        }
1887        close(fd);
1888
1889        res = stat(todo_file, &st);
1890        if (res)
1891                return error(_("could not stat '%s'"), todo_file);
1892        fill_stat_data(&todo_list->stat, &st);
1893
1894        res = parse_insn_buffer(todo_list->buf.buf, todo_list);
1895        if (res) {
1896                if (is_rebase_i(opts))
1897                        return error(_("please fix this using "
1898                                       "'git rebase --edit-todo'."));
1899                return error(_("unusable instruction sheet: '%s'"), todo_file);
1900        }
1901
1902        if (!todo_list->nr &&
1903            (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
1904                return error(_("no commits parsed."));
1905
1906        if (!is_rebase_i(opts)) {
1907                enum todo_command valid =
1908                        opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
1909                int i;
1910
1911                for (i = 0; i < todo_list->nr; i++)
1912                        if (valid == todo_list->items[i].command)
1913                                continue;
1914                        else if (valid == TODO_PICK)
1915                                return error(_("cannot cherry-pick during a revert."));
1916                        else
1917                                return error(_("cannot revert during a cherry-pick."));
1918        }
1919
1920        if (is_rebase_i(opts)) {
1921                struct todo_list done = TODO_LIST_INIT;
1922                FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
1923
1924                if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
1925                                !parse_insn_buffer(done.buf.buf, &done))
1926                        todo_list->done_nr = count_commands(&done);
1927                else
1928                        todo_list->done_nr = 0;
1929
1930                todo_list->total_nr = todo_list->done_nr
1931                        + count_commands(todo_list);
1932                todo_list_release(&done);
1933
1934                if (f) {
1935                        fprintf(f, "%d\n", todo_list->total_nr);
1936                        fclose(f);
1937                }
1938        }
1939
1940        return 0;
1941}
1942
1943static int git_config_string_dup(char **dest,
1944                                 const char *var, const char *value)
1945{
1946        if (!value)
1947                return config_error_nonbool(var);
1948        free(*dest);
1949        *dest = xstrdup(value);
1950        return 0;
1951}
1952
1953static int populate_opts_cb(const char *key, const char *value, void *data)
1954{
1955        struct replay_opts *opts = data;
1956        int error_flag = 1;
1957
1958        if (!value)
1959                error_flag = 0;
1960        else if (!strcmp(key, "options.no-commit"))
1961                opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
1962        else if (!strcmp(key, "options.edit"))
1963                opts->edit = git_config_bool_or_int(key, value, &error_flag);
1964        else if (!strcmp(key, "options.signoff"))
1965                opts->signoff = git_config_bool_or_int(key, value, &error_flag);
1966        else if (!strcmp(key, "options.record-origin"))
1967                opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
1968        else if (!strcmp(key, "options.allow-ff"))
1969                opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
1970        else if (!strcmp(key, "options.mainline"))
1971                opts->mainline = git_config_int(key, value);
1972        else if (!strcmp(key, "options.strategy"))
1973                git_config_string_dup(&opts->strategy, key, value);
1974        else if (!strcmp(key, "options.gpg-sign"))
1975                git_config_string_dup(&opts->gpg_sign, key, value);
1976        else if (!strcmp(key, "options.strategy-option")) {
1977                ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
1978                opts->xopts[opts->xopts_nr++] = xstrdup(value);
1979        } else if (!strcmp(key, "options.allow-rerere-auto"))
1980                opts->allow_rerere_auto =
1981                        git_config_bool_or_int(key, value, &error_flag) ?
1982                                RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
1983        else
1984                return error(_("invalid key: %s"), key);
1985
1986        if (!error_flag)
1987                return error(_("invalid value for %s: %s"), key, value);
1988
1989        return 0;
1990}
1991
1992static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
1993{
1994        int i;
1995
1996        strbuf_reset(buf);
1997        if (!read_oneliner(buf, rebase_path_strategy(), 0))
1998                return;
1999        opts->strategy = strbuf_detach(buf, NULL);
2000        if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2001                return;
2002
2003        opts->xopts_nr = split_cmdline(buf->buf, (const char ***)&opts->xopts);
2004        for (i = 0; i < opts->xopts_nr; i++) {
2005                const char *arg = opts->xopts[i];
2006
2007                skip_prefix(arg, "--", &arg);
2008                opts->xopts[i] = xstrdup(arg);
2009        }
2010}
2011
2012static int read_populate_opts(struct replay_opts *opts)
2013{
2014        if (is_rebase_i(opts)) {
2015                struct strbuf buf = STRBUF_INIT;
2016
2017                if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2018                        if (!starts_with(buf.buf, "-S"))
2019                                strbuf_reset(&buf);
2020                        else {
2021                                free(opts->gpg_sign);
2022                                opts->gpg_sign = xstrdup(buf.buf + 2);
2023                        }
2024                        strbuf_reset(&buf);
2025                }
2026
2027                if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2028                        if (!strcmp(buf.buf, "--rerere-autoupdate"))
2029                                opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2030                        else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2031                                opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2032                        strbuf_reset(&buf);
2033                }
2034
2035                if (file_exists(rebase_path_verbose()))
2036                        opts->verbose = 1;
2037
2038                read_strategy_opts(opts, &buf);
2039                strbuf_release(&buf);
2040
2041                return 0;
2042        }
2043
2044        if (!file_exists(git_path_opts_file()))
2045                return 0;
2046        /*
2047         * The function git_parse_source(), called from git_config_from_file(),
2048         * may die() in case of a syntactically incorrect file. We do not care
2049         * about this case, though, because we wrote that file ourselves, so we
2050         * are pretty certain that it is syntactically correct.
2051         */
2052        if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2053                return error(_("malformed options sheet: '%s'"),
2054                        git_path_opts_file());
2055        return 0;
2056}
2057
2058static int walk_revs_populate_todo(struct todo_list *todo_list,
2059                                struct replay_opts *opts)
2060{
2061        enum todo_command command = opts->action == REPLAY_PICK ?
2062                TODO_PICK : TODO_REVERT;
2063        const char *command_string = todo_command_info[command].str;
2064        struct commit *commit;
2065
2066        if (prepare_revs(opts))
2067                return -1;
2068
2069        while ((commit = get_revision(opts->revs))) {
2070                struct todo_item *item = append_new_todo(todo_list);
2071                const char *commit_buffer = get_commit_buffer(commit, NULL);
2072                const char *subject;
2073                int subject_len;
2074
2075                item->command = command;
2076                item->commit = commit;
2077                item->arg = NULL;
2078                item->arg_len = 0;
2079                item->offset_in_buf = todo_list->buf.len;
2080                subject_len = find_commit_subject(commit_buffer, &subject);
2081                strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2082                        short_commit_name(commit), subject_len, subject);
2083                unuse_commit_buffer(commit, commit_buffer);
2084        }
2085        return 0;
2086}
2087
2088static int create_seq_dir(void)
2089{
2090        if (file_exists(git_path_seq_dir())) {
2091                error(_("a cherry-pick or revert is already in progress"));
2092                advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2093                return -1;
2094        } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2095                return error_errno(_("could not create sequencer directory '%s'"),
2096                                   git_path_seq_dir());
2097        return 0;
2098}
2099
2100static int save_head(const char *head)
2101{
2102        static struct lock_file head_lock;
2103        struct strbuf buf = STRBUF_INIT;
2104        int fd;
2105        ssize_t written;
2106
2107        fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2108        if (fd < 0) {
2109                rollback_lock_file(&head_lock);
2110                return error_errno(_("could not lock HEAD"));
2111        }
2112        strbuf_addf(&buf, "%s\n", head);
2113        written = write_in_full(fd, buf.buf, buf.len);
2114        strbuf_release(&buf);
2115        if (written < 0) {
2116                rollback_lock_file(&head_lock);
2117                return error_errno(_("could not write to '%s'"),
2118                                   git_path_head_file());
2119        }
2120        if (commit_lock_file(&head_lock) < 0) {
2121                rollback_lock_file(&head_lock);
2122                return error(_("failed to finalize '%s'."), git_path_head_file());
2123        }
2124        return 0;
2125}
2126
2127static int rollback_is_safe(void)
2128{
2129        struct strbuf sb = STRBUF_INIT;
2130        struct object_id expected_head, actual_head;
2131
2132        if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2133                strbuf_trim(&sb);
2134                if (get_oid_hex(sb.buf, &expected_head)) {
2135                        strbuf_release(&sb);
2136                        die(_("could not parse %s"), git_path_abort_safety_file());
2137                }
2138                strbuf_release(&sb);
2139        }
2140        else if (errno == ENOENT)
2141                oidclr(&expected_head);
2142        else
2143                die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2144
2145        if (get_oid("HEAD", &actual_head))
2146                oidclr(&actual_head);
2147
2148        return !oidcmp(&actual_head, &expected_head);
2149}
2150
2151static int reset_for_rollback(const struct object_id *oid)
2152{
2153        const char *argv[4];    /* reset --merge <arg> + NULL */
2154
2155        argv[0] = "reset";
2156        argv[1] = "--merge";
2157        argv[2] = oid_to_hex(oid);
2158        argv[3] = NULL;
2159        return run_command_v_opt(argv, RUN_GIT_CMD);
2160}
2161
2162static int rollback_single_pick(void)
2163{
2164        struct object_id head_oid;
2165
2166        if (!file_exists(git_path_cherry_pick_head()) &&
2167            !file_exists(git_path_revert_head()))
2168                return error(_("no cherry-pick or revert in progress"));
2169        if (read_ref_full("HEAD", 0, &head_oid, NULL))
2170                return error(_("cannot resolve HEAD"));
2171        if (is_null_oid(&head_oid))
2172                return error(_("cannot abort from a branch yet to be born"));
2173        return reset_for_rollback(&head_oid);
2174}
2175
2176int sequencer_rollback(struct replay_opts *opts)
2177{
2178        FILE *f;
2179        struct object_id oid;
2180        struct strbuf buf = STRBUF_INIT;
2181        const char *p;
2182
2183        f = fopen(git_path_head_file(), "r");
2184        if (!f && errno == ENOENT) {
2185                /*
2186                 * There is no multiple-cherry-pick in progress.
2187                 * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2188                 * a single-cherry-pick in progress, abort that.
2189                 */
2190                return rollback_single_pick();
2191        }
2192        if (!f)
2193                return error_errno(_("cannot open '%s'"), git_path_head_file());
2194        if (strbuf_getline_lf(&buf, f)) {
2195                error(_("cannot read '%s': %s"), git_path_head_file(),
2196                      ferror(f) ?  strerror(errno) : _("unexpected end of file"));
2197                fclose(f);
2198                goto fail;
2199        }
2200        fclose(f);
2201        if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2202                error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2203                        git_path_head_file());
2204                goto fail;
2205        }
2206        if (is_null_oid(&oid)) {
2207                error(_("cannot abort from a branch yet to be born"));
2208                goto fail;
2209        }
2210
2211        if (!rollback_is_safe()) {
2212                /* Do not error, just do not rollback */
2213                warning(_("You seem to have moved HEAD. "
2214                          "Not rewinding, check your HEAD!"));
2215        } else
2216        if (reset_for_rollback(&oid))
2217                goto fail;
2218        strbuf_release(&buf);
2219        return sequencer_remove_state(opts);
2220fail:
2221        strbuf_release(&buf);
2222        return -1;
2223}
2224
2225static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2226{
2227        static struct lock_file todo_lock;
2228        const char *todo_path = get_todo_path(opts);
2229        int next = todo_list->current, offset, fd;
2230
2231        /*
2232         * rebase -i writes "git-rebase-todo" without the currently executing
2233         * command, appending it to "done" instead.
2234         */
2235        if (is_rebase_i(opts))
2236                next++;
2237
2238        fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2239        if (fd < 0)
2240                return error_errno(_("could not lock '%s'"), todo_path);
2241        offset = next < todo_list->nr ?
2242                todo_list->items[next].offset_in_buf : todo_list->buf.len;
2243        if (write_in_full(fd, todo_list->buf.buf + offset,
2244                        todo_list->buf.len - offset) < 0)
2245                return error_errno(_("could not write to '%s'"), todo_path);
2246        if (commit_lock_file(&todo_lock) < 0)
2247                return error(_("failed to finalize '%s'."), todo_path);
2248
2249        if (is_rebase_i(opts)) {
2250                const char *done_path = rebase_path_done();
2251                int fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
2252                int prev_offset = !next ? 0 :
2253                        todo_list->items[next - 1].offset_in_buf;
2254
2255                if (fd >= 0 && offset > prev_offset &&
2256                    write_in_full(fd, todo_list->buf.buf + prev_offset,
2257                                  offset - prev_offset) < 0) {
2258                        close(fd);
2259                        return error_errno(_("could not write to '%s'"),
2260                                           done_path);
2261                }
2262                if (fd >= 0)
2263                        close(fd);
2264        }
2265        return 0;
2266}
2267
2268static int save_opts(struct replay_opts *opts)
2269{
2270        const char *opts_file = git_path_opts_file();
2271        int res = 0;
2272
2273        if (opts->no_commit)
2274                res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2275        if (opts->edit)
2276                res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2277        if (opts->signoff)
2278                res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2279        if (opts->record_origin)
2280                res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2281        if (opts->allow_ff)
2282                res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2283        if (opts->mainline) {
2284                struct strbuf buf = STRBUF_INIT;
2285                strbuf_addf(&buf, "%d", opts->mainline);
2286                res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2287                strbuf_release(&buf);
2288        }
2289        if (opts->strategy)
2290                res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2291        if (opts->gpg_sign)
2292                res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2293        if (opts->xopts) {
2294                int i;
2295                for (i = 0; i < opts->xopts_nr; i++)
2296                        res |= git_config_set_multivar_in_file_gently(opts_file,
2297                                                        "options.strategy-option",
2298                                                        opts->xopts[i], "^$", 0);
2299        }
2300        if (opts->allow_rerere_auto)
2301                res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2302                                                     opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2303                                                     "true" : "false");
2304        return res;
2305}
2306
2307static int make_patch(struct commit *commit, struct replay_opts *opts)
2308{
2309        struct strbuf buf = STRBUF_INIT;
2310        struct rev_info log_tree_opt;
2311        const char *subject, *p;
2312        int res = 0;
2313
2314        p = short_commit_name(commit);
2315        if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2316                return -1;
2317
2318        strbuf_addf(&buf, "%s/patch", get_dir(opts));
2319        memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2320        init_revisions(&log_tree_opt, NULL);
2321        log_tree_opt.abbrev = 0;
2322        log_tree_opt.diff = 1;
2323        log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2324        log_tree_opt.disable_stdin = 1;
2325        log_tree_opt.no_commit_id = 1;
2326        log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2327        log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2328        if (!log_tree_opt.diffopt.file)
2329                res |= error_errno(_("could not open '%s'"), buf.buf);
2330        else {
2331                res |= log_tree_commit(&log_tree_opt, commit);
2332                fclose(log_tree_opt.diffopt.file);
2333        }
2334        strbuf_reset(&buf);
2335
2336        strbuf_addf(&buf, "%s/message", get_dir(opts));
2337        if (!file_exists(buf.buf)) {
2338                const char *commit_buffer = get_commit_buffer(commit, NULL);
2339                find_commit_subject(commit_buffer, &subject);
2340                res |= write_message(subject, strlen(subject), buf.buf, 1);
2341                unuse_commit_buffer(commit, commit_buffer);
2342        }
2343        strbuf_release(&buf);
2344
2345        return res;
2346}
2347
2348static int intend_to_amend(void)
2349{
2350        struct object_id head;
2351        char *p;
2352
2353        if (get_oid("HEAD", &head))
2354                return error(_("cannot read HEAD"));
2355
2356        p = oid_to_hex(&head);
2357        return write_message(p, strlen(p), rebase_path_amend(), 1);
2358}
2359
2360static int error_with_patch(struct commit *commit,
2361        const char *subject, int subject_len,
2362        struct replay_opts *opts, int exit_code, int to_amend)
2363{
2364        if (make_patch(commit, opts))
2365                return -1;
2366
2367        if (to_amend) {
2368                if (intend_to_amend())
2369                        return -1;
2370
2371                fprintf(stderr, "You can amend the commit now, with\n"
2372                        "\n"
2373                        "  git commit --amend %s\n"
2374                        "\n"
2375                        "Once you are satisfied with your changes, run\n"
2376                        "\n"
2377                        "  git rebase --continue\n", gpg_sign_opt_quoted(opts));
2378        } else if (exit_code)
2379                fprintf(stderr, "Could not apply %s... %.*s\n",
2380                        short_commit_name(commit), subject_len, subject);
2381
2382        return exit_code;
2383}
2384
2385static int error_failed_squash(struct commit *commit,
2386        struct replay_opts *opts, int subject_len, const char *subject)
2387{
2388        if (rename(rebase_path_squash_msg(), rebase_path_message()))
2389                return error(_("could not rename '%s' to '%s'"),
2390                        rebase_path_squash_msg(), rebase_path_message());
2391        unlink(rebase_path_fixup_msg());
2392        unlink(git_path_merge_msg());
2393        if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
2394                return error(_("could not copy '%s' to '%s'"),
2395                             rebase_path_message(), git_path_merge_msg());
2396        return error_with_patch(commit, subject, subject_len, opts, 1, 0);
2397}
2398
2399static int do_exec(const char *command_line)
2400{
2401        struct argv_array child_env = ARGV_ARRAY_INIT;
2402        const char *child_argv[] = { NULL, NULL };
2403        int dirty, status;
2404
2405        fprintf(stderr, "Executing: %s\n", command_line);
2406        child_argv[0] = command_line;
2407        argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2408        status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2409                                          child_env.argv);
2410
2411        /* force re-reading of the cache */
2412        if (discard_cache() < 0 || read_cache() < 0)
2413                return error(_("could not read index"));
2414
2415        dirty = require_clean_work_tree("rebase", NULL, 1, 1);
2416
2417        if (status) {
2418                warning(_("execution failed: %s\n%s"
2419                          "You can fix the problem, and then run\n"
2420                          "\n"
2421                          "  git rebase --continue\n"
2422                          "\n"),
2423                        command_line,
2424                        dirty ? N_("and made changes to the index and/or the "
2425                                "working tree\n") : "");
2426                if (status == 127)
2427                        /* command not found */
2428                        status = 1;
2429        } else if (dirty) {
2430                warning(_("execution succeeded: %s\nbut "
2431                          "left changes to the index and/or the working tree\n"
2432                          "Commit or stash your changes, and then run\n"
2433                          "\n"
2434                          "  git rebase --continue\n"
2435                          "\n"), command_line);
2436                status = 1;
2437        }
2438
2439        argv_array_clear(&child_env);
2440
2441        return status;
2442}
2443
2444static int is_final_fixup(struct todo_list *todo_list)
2445{
2446        int i = todo_list->current;
2447
2448        if (!is_fixup(todo_list->items[i].command))
2449                return 0;
2450
2451        while (++i < todo_list->nr)
2452                if (is_fixup(todo_list->items[i].command))
2453                        return 0;
2454                else if (!is_noop(todo_list->items[i].command))
2455                        break;
2456        return 1;
2457}
2458
2459static enum todo_command peek_command(struct todo_list *todo_list, int offset)
2460{
2461        int i;
2462
2463        for (i = todo_list->current + offset; i < todo_list->nr; i++)
2464                if (!is_noop(todo_list->items[i].command))
2465                        return todo_list->items[i].command;
2466
2467        return -1;
2468}
2469
2470static int apply_autostash(struct replay_opts *opts)
2471{
2472        struct strbuf stash_sha1 = STRBUF_INIT;
2473        struct child_process child = CHILD_PROCESS_INIT;
2474        int ret = 0;
2475
2476        if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
2477                strbuf_release(&stash_sha1);
2478                return 0;
2479        }
2480        strbuf_trim(&stash_sha1);
2481
2482        child.git_cmd = 1;
2483        child.no_stdout = 1;
2484        child.no_stderr = 1;
2485        argv_array_push(&child.args, "stash");
2486        argv_array_push(&child.args, "apply");
2487        argv_array_push(&child.args, stash_sha1.buf);
2488        if (!run_command(&child))
2489                fprintf(stderr, _("Applied autostash.\n"));
2490        else {
2491                struct child_process store = CHILD_PROCESS_INIT;
2492
2493                store.git_cmd = 1;
2494                argv_array_push(&store.args, "stash");
2495                argv_array_push(&store.args, "store");
2496                argv_array_push(&store.args, "-m");
2497                argv_array_push(&store.args, "autostash");
2498                argv_array_push(&store.args, "-q");
2499                argv_array_push(&store.args, stash_sha1.buf);
2500                if (run_command(&store))
2501                        ret = error(_("cannot store %s"), stash_sha1.buf);
2502                else
2503                        fprintf(stderr,
2504                                _("Applying autostash resulted in conflicts.\n"
2505                                  "Your changes are safe in the stash.\n"
2506                                  "You can run \"git stash pop\" or"
2507                                  " \"git stash drop\" at any time.\n"));
2508        }
2509
2510        strbuf_release(&stash_sha1);
2511        return ret;
2512}
2513
2514static const char *reflog_message(struct replay_opts *opts,
2515        const char *sub_action, const char *fmt, ...)
2516{
2517        va_list ap;
2518        static struct strbuf buf = STRBUF_INIT;
2519
2520        va_start(ap, fmt);
2521        strbuf_reset(&buf);
2522        strbuf_addstr(&buf, action_name(opts));
2523        if (sub_action)
2524                strbuf_addf(&buf, " (%s)", sub_action);
2525        if (fmt) {
2526                strbuf_addstr(&buf, ": ");
2527                strbuf_vaddf(&buf, fmt, ap);
2528        }
2529        va_end(ap);
2530
2531        return buf.buf;
2532}
2533
2534static int pick_commits(struct todo_list *todo_list, struct replay_opts *opts)
2535{
2536        int res = 0;
2537
2538        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2539        if (opts->allow_ff)
2540                assert(!(opts->signoff || opts->no_commit ||
2541                                opts->record_origin || opts->edit));
2542        if (read_and_refresh_cache(opts))
2543                return -1;
2544
2545        while (todo_list->current < todo_list->nr) {
2546                struct todo_item *item = todo_list->items + todo_list->current;
2547                if (save_todo(todo_list, opts))
2548                        return -1;
2549                if (is_rebase_i(opts)) {
2550                        if (item->command != TODO_COMMENT) {
2551                                FILE *f = fopen(rebase_path_msgnum(), "w");
2552
2553                                todo_list->done_nr++;
2554
2555                                if (f) {
2556                                        fprintf(f, "%d\n", todo_list->done_nr);
2557                                        fclose(f);
2558                                }
2559                                fprintf(stderr, "Rebasing (%d/%d)%s",
2560                                        todo_list->done_nr,
2561                                        todo_list->total_nr,
2562                                        opts->verbose ? "\n" : "\r");
2563                        }
2564                        unlink(rebase_path_message());
2565                        unlink(rebase_path_author_script());
2566                        unlink(rebase_path_stopped_sha());
2567                        unlink(rebase_path_amend());
2568                }
2569                if (item->command <= TODO_SQUASH) {
2570                        if (is_rebase_i(opts))
2571                                setenv("GIT_REFLOG_ACTION", reflog_message(opts,
2572                                        command_to_string(item->command), NULL),
2573                                        1);
2574                        res = do_pick_commit(item->command, item->commit,
2575                                        opts, is_final_fixup(todo_list));
2576                        if (is_rebase_i(opts) && res < 0) {
2577                                /* Reschedule */
2578                                todo_list->current--;
2579                                if (save_todo(todo_list, opts))
2580                                        return -1;
2581                        }
2582                        if (item->command == TODO_EDIT) {
2583                                struct commit *commit = item->commit;
2584                                if (!res)
2585                                        fprintf(stderr,
2586                                                _("Stopped at %s...  %.*s\n"),
2587                                                short_commit_name(commit),
2588                                                item->arg_len, item->arg);
2589                                return error_with_patch(commit,
2590                                        item->arg, item->arg_len, opts, res,
2591                                        !res);
2592                        }
2593                        if (is_rebase_i(opts) && !res)
2594                                record_in_rewritten(&item->commit->object.oid,
2595                                        peek_command(todo_list, 1));
2596                        if (res && is_fixup(item->command)) {
2597                                if (res == 1)
2598                                        intend_to_amend();
2599                                return error_failed_squash(item->commit, opts,
2600                                        item->arg_len, item->arg);
2601                        } else if (res && is_rebase_i(opts))
2602                                return res | error_with_patch(item->commit,
2603                                        item->arg, item->arg_len, opts, res,
2604                                        item->command == TODO_REWORD);
2605                } else if (item->command == TODO_EXEC) {
2606                        char *end_of_arg = (char *)(item->arg + item->arg_len);
2607                        int saved = *end_of_arg;
2608                        struct stat st;
2609
2610                        *end_of_arg = '\0';
2611                        res = do_exec(item->arg);
2612                        *end_of_arg = saved;
2613
2614                        /* Reread the todo file if it has changed. */
2615                        if (res)
2616                                ; /* fall through */
2617                        else if (stat(get_todo_path(opts), &st))
2618                                res = error_errno(_("could not stat '%s'"),
2619                                                  get_todo_path(opts));
2620                        else if (match_stat_data(&todo_list->stat, &st)) {
2621                                todo_list_release(todo_list);
2622                                if (read_populate_todo(todo_list, opts))
2623                                        res = -1; /* message was printed */
2624                                /* `current` will be incremented below */
2625                                todo_list->current = -1;
2626                        }
2627                } else if (!is_noop(item->command))
2628                        return error(_("unknown command %d"), item->command);
2629
2630                todo_list->current++;
2631                if (res)
2632                        return res;
2633        }
2634
2635        if (is_rebase_i(opts)) {
2636                struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
2637                struct stat st;
2638
2639                /* Stopped in the middle, as planned? */
2640                if (todo_list->current < todo_list->nr)
2641                        return 0;
2642
2643                if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
2644                                starts_with(head_ref.buf, "refs/")) {
2645                        const char *msg;
2646                        struct object_id head, orig;
2647                        int res;
2648
2649                        if (get_oid("HEAD", &head)) {
2650                                res = error(_("cannot read HEAD"));
2651cleanup_head_ref:
2652                                strbuf_release(&head_ref);
2653                                strbuf_release(&buf);
2654                                return res;
2655                        }
2656                        if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
2657                                        get_oid_hex(buf.buf, &orig)) {
2658                                res = error(_("could not read orig-head"));
2659                                goto cleanup_head_ref;
2660                        }
2661                        strbuf_reset(&buf);
2662                        if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
2663                                res = error(_("could not read 'onto'"));
2664                                goto cleanup_head_ref;
2665                        }
2666                        msg = reflog_message(opts, "finish", "%s onto %s",
2667                                head_ref.buf, buf.buf);
2668                        if (update_ref(msg, head_ref.buf, &head, &orig,
2669                                       REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
2670                                res = error(_("could not update %s"),
2671                                        head_ref.buf);
2672                                goto cleanup_head_ref;
2673                        }
2674                        msg = reflog_message(opts, "finish", "returning to %s",
2675                                head_ref.buf);
2676                        if (create_symref("HEAD", head_ref.buf, msg)) {
2677                                res = error(_("could not update HEAD to %s"),
2678                                        head_ref.buf);
2679                                goto cleanup_head_ref;
2680                        }
2681                        strbuf_reset(&buf);
2682                }
2683
2684                if (opts->verbose) {
2685                        struct rev_info log_tree_opt;
2686                        struct object_id orig, head;
2687
2688                        memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2689                        init_revisions(&log_tree_opt, NULL);
2690                        log_tree_opt.diff = 1;
2691                        log_tree_opt.diffopt.output_format =
2692                                DIFF_FORMAT_DIFFSTAT;
2693                        log_tree_opt.disable_stdin = 1;
2694
2695                        if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
2696                            !get_oid(buf.buf, &orig) &&
2697                            !get_oid("HEAD", &head)) {
2698                                diff_tree_oid(&orig, &head, "",
2699                                              &log_tree_opt.diffopt);
2700                                log_tree_diff_flush(&log_tree_opt);
2701                        }
2702                }
2703                flush_rewritten_pending();
2704                if (!stat(rebase_path_rewritten_list(), &st) &&
2705                                st.st_size > 0) {
2706                        struct child_process child = CHILD_PROCESS_INIT;
2707                        const char *post_rewrite_hook =
2708                                find_hook("post-rewrite");
2709
2710                        child.in = open(rebase_path_rewritten_list(), O_RDONLY);
2711                        child.git_cmd = 1;
2712                        argv_array_push(&child.args, "notes");
2713                        argv_array_push(&child.args, "copy");
2714                        argv_array_push(&child.args, "--for-rewrite=rebase");
2715                        /* we don't care if this copying failed */
2716                        run_command(&child);
2717
2718                        if (post_rewrite_hook) {
2719                                struct child_process hook = CHILD_PROCESS_INIT;
2720
2721                                hook.in = open(rebase_path_rewritten_list(),
2722                                        O_RDONLY);
2723                                hook.stdout_to_stderr = 1;
2724                                argv_array_push(&hook.args, post_rewrite_hook);
2725                                argv_array_push(&hook.args, "rebase");
2726                                /* we don't care if this hook failed */
2727                                run_command(&hook);
2728                        }
2729                }
2730                apply_autostash(opts);
2731
2732                fprintf(stderr, "Successfully rebased and updated %s.\n",
2733                        head_ref.buf);
2734
2735                strbuf_release(&buf);
2736                strbuf_release(&head_ref);
2737        }
2738
2739        /*
2740         * Sequence of picks finished successfully; cleanup by
2741         * removing the .git/sequencer directory
2742         */
2743        return sequencer_remove_state(opts);
2744}
2745
2746static int continue_single_pick(void)
2747{
2748        const char *argv[] = { "commit", NULL };
2749
2750        if (!file_exists(git_path_cherry_pick_head()) &&
2751            !file_exists(git_path_revert_head()))
2752                return error(_("no cherry-pick or revert in progress"));
2753        return run_command_v_opt(argv, RUN_GIT_CMD);
2754}
2755
2756static int commit_staged_changes(struct replay_opts *opts)
2757{
2758        unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
2759
2760        if (has_unstaged_changes(1))
2761                return error(_("cannot rebase: You have unstaged changes."));
2762        if (!has_uncommitted_changes(0)) {
2763                const char *cherry_pick_head = git_path_cherry_pick_head();
2764
2765                if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
2766                        return error(_("could not remove CHERRY_PICK_HEAD"));
2767                return 0;
2768        }
2769
2770        if (file_exists(rebase_path_amend())) {
2771                struct strbuf rev = STRBUF_INIT;
2772                struct object_id head, to_amend;
2773
2774                if (get_oid("HEAD", &head))
2775                        return error(_("cannot amend non-existing commit"));
2776                if (!read_oneliner(&rev, rebase_path_amend(), 0))
2777                        return error(_("invalid file: '%s'"), rebase_path_amend());
2778                if (get_oid_hex(rev.buf, &to_amend))
2779                        return error(_("invalid contents: '%s'"),
2780                                rebase_path_amend());
2781                if (oidcmp(&head, &to_amend))
2782                        return error(_("\nYou have uncommitted changes in your "
2783                                       "working tree. Please, commit them\n"
2784                                       "first and then run 'git rebase "
2785                                       "--continue' again."));
2786
2787                strbuf_release(&rev);
2788                flags |= AMEND_MSG;
2789        }
2790
2791        if (run_git_commit(rebase_path_message(), opts, flags))
2792                return error(_("could not commit staged changes."));
2793        unlink(rebase_path_amend());
2794        return 0;
2795}
2796
2797int sequencer_continue(struct replay_opts *opts)
2798{
2799        struct todo_list todo_list = TODO_LIST_INIT;
2800        int res;
2801
2802        if (read_and_refresh_cache(opts))
2803                return -1;
2804
2805        if (is_rebase_i(opts)) {
2806                if (commit_staged_changes(opts))
2807                        return -1;
2808        } else if (!file_exists(get_todo_path(opts)))
2809                return continue_single_pick();
2810        if (read_populate_opts(opts))
2811                return -1;
2812        if ((res = read_populate_todo(&todo_list, opts)))
2813                goto release_todo_list;
2814
2815        if (!is_rebase_i(opts)) {
2816                /* Verify that the conflict has been resolved */
2817                if (file_exists(git_path_cherry_pick_head()) ||
2818                    file_exists(git_path_revert_head())) {
2819                        res = continue_single_pick();
2820                        if (res)
2821                                goto release_todo_list;
2822                }
2823                if (index_differs_from("HEAD", NULL, 0)) {
2824                        res = error_dirty_index(opts);
2825                        goto release_todo_list;
2826                }
2827                todo_list.current++;
2828        } else if (file_exists(rebase_path_stopped_sha())) {
2829                struct strbuf buf = STRBUF_INIT;
2830                struct object_id oid;
2831
2832                if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
2833                    !get_oid_committish(buf.buf, &oid))
2834                        record_in_rewritten(&oid, peek_command(&todo_list, 0));
2835                strbuf_release(&buf);
2836        }
2837
2838        res = pick_commits(&todo_list, opts);
2839release_todo_list:
2840        todo_list_release(&todo_list);
2841        return res;
2842}
2843
2844static int single_pick(struct commit *cmit, struct replay_opts *opts)
2845{
2846        setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
2847        return do_pick_commit(opts->action == REPLAY_PICK ?
2848                TODO_PICK : TODO_REVERT, cmit, opts, 0);
2849}
2850
2851int sequencer_pick_revisions(struct replay_opts *opts)
2852{
2853        struct todo_list todo_list = TODO_LIST_INIT;
2854        struct object_id oid;
2855        int i, res;
2856
2857        assert(opts->revs);
2858        if (read_and_refresh_cache(opts))
2859                return -1;
2860
2861        for (i = 0; i < opts->revs->pending.nr; i++) {
2862                struct object_id oid;
2863                const char *name = opts->revs->pending.objects[i].name;
2864
2865                /* This happens when using --stdin. */
2866                if (!strlen(name))
2867                        continue;
2868
2869                if (!get_oid(name, &oid)) {
2870                        if (!lookup_commit_reference_gently(&oid, 1)) {
2871                                enum object_type type = sha1_object_info(oid.hash, NULL);
2872                                return error(_("%s: can't cherry-pick a %s"),
2873                                        name, typename(type));
2874                        }
2875                } else
2876                        return error(_("%s: bad revision"), name);
2877        }
2878
2879        /*
2880         * If we were called as "git cherry-pick <commit>", just
2881         * cherry-pick/revert it, set CHERRY_PICK_HEAD /
2882         * REVERT_HEAD, and don't touch the sequencer state.
2883         * This means it is possible to cherry-pick in the middle
2884         * of a cherry-pick sequence.
2885         */
2886        if (opts->revs->cmdline.nr == 1 &&
2887            opts->revs->cmdline.rev->whence == REV_CMD_REV &&
2888            opts->revs->no_walk &&
2889            !opts->revs->cmdline.rev->flags) {
2890                struct commit *cmit;
2891                if (prepare_revision_walk(opts->revs))
2892                        return error(_("revision walk setup failed"));
2893                cmit = get_revision(opts->revs);
2894                if (!cmit || get_revision(opts->revs))
2895                        return error("BUG: expected exactly one commit from walk");
2896                return single_pick(cmit, opts);
2897        }
2898
2899        /*
2900         * Start a new cherry-pick/ revert sequence; but
2901         * first, make sure that an existing one isn't in
2902         * progress
2903         */
2904
2905        if (walk_revs_populate_todo(&todo_list, opts) ||
2906                        create_seq_dir() < 0)
2907                return -1;
2908        if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
2909                return error(_("can't revert as initial commit"));
2910        if (save_head(oid_to_hex(&oid)))
2911                return -1;
2912        if (save_opts(opts))
2913                return -1;
2914        update_abort_safety_file();
2915        res = pick_commits(&todo_list, opts);
2916        todo_list_release(&todo_list);
2917        return res;
2918}
2919
2920void append_signoff(struct strbuf *msgbuf, int ignore_footer, unsigned flag)
2921{
2922        unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
2923        struct strbuf sob = STRBUF_INIT;
2924        int has_footer;
2925
2926        strbuf_addstr(&sob, sign_off_header);
2927        strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
2928                                getenv("GIT_COMMITTER_EMAIL")));
2929        strbuf_addch(&sob, '\n');
2930
2931        if (!ignore_footer)
2932                strbuf_complete_line(msgbuf);
2933
2934        /*
2935         * If the whole message buffer is equal to the sob, pretend that we
2936         * found a conforming footer with a matching sob
2937         */
2938        if (msgbuf->len - ignore_footer == sob.len &&
2939            !strncmp(msgbuf->buf, sob.buf, sob.len))
2940                has_footer = 3;
2941        else
2942                has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
2943
2944        if (!has_footer) {
2945                const char *append_newlines = NULL;
2946                size_t len = msgbuf->len - ignore_footer;
2947
2948                if (!len) {
2949                        /*
2950                         * The buffer is completely empty.  Leave foom for
2951                         * the title and body to be filled in by the user.
2952                         */
2953                        append_newlines = "\n\n";
2954                } else if (len == 1) {
2955                        /*
2956                         * Buffer contains a single newline.  Add another
2957                         * so that we leave room for the title and body.
2958                         */
2959                        append_newlines = "\n";
2960                } else if (msgbuf->buf[len - 2] != '\n') {
2961                        /*
2962                         * Buffer ends with a single newline.  Add another
2963                         * so that there is an empty line between the message
2964                         * body and the sob.
2965                         */
2966                        append_newlines = "\n";
2967                } /* else, the buffer already ends with two newlines. */
2968
2969                if (append_newlines)
2970                        strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
2971                                append_newlines, strlen(append_newlines));
2972        }
2973
2974        if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
2975                strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
2976                                sob.buf, sob.len);
2977
2978        strbuf_release(&sob);
2979}
2980
2981int sequencer_make_script(FILE *out, int argc, const char **argv,
2982                          unsigned flags)
2983{
2984        char *format = NULL;
2985        struct pretty_print_context pp = {0};
2986        struct strbuf buf = STRBUF_INIT;
2987        struct rev_info revs;
2988        struct commit *commit;
2989        int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
2990        const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
2991
2992        init_revisions(&revs, NULL);
2993        revs.verbose_header = 1;
2994        revs.max_parents = 1;
2995        revs.cherry_pick = 1;
2996        revs.limited = 1;
2997        revs.reverse = 1;
2998        revs.right_only = 1;
2999        revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
3000        revs.topo_order = 1;
3001
3002        revs.pretty_given = 1;
3003        git_config_get_string("rebase.instructionFormat", &format);
3004        if (!format || !*format) {
3005                free(format);
3006                format = xstrdup("%s");
3007        }
3008        get_commit_format(format, &revs);
3009        free(format);
3010        pp.fmt = revs.commit_format;
3011        pp.output_encoding = get_log_output_encoding();
3012
3013        if (setup_revisions(argc, argv, &revs, NULL) > 1)
3014                return error(_("make_script: unhandled options"));
3015
3016        if (prepare_revision_walk(&revs) < 0)
3017                return error(_("make_script: error preparing revisions"));
3018
3019        while ((commit = get_revision(&revs))) {
3020                strbuf_reset(&buf);
3021                if (!keep_empty && is_original_commit_empty(commit))
3022                        strbuf_addf(&buf, "%c ", comment_line_char);
3023                strbuf_addf(&buf, "%s %s ", insn,
3024                            oid_to_hex(&commit->object.oid));
3025                pretty_print_commit(&pp, commit, &buf);
3026                strbuf_addch(&buf, '\n');
3027                fputs(buf.buf, out);
3028        }
3029        strbuf_release(&buf);
3030        return 0;
3031}
3032
3033/*
3034 * Add commands after pick and (series of) squash/fixup commands
3035 * in the todo list.
3036 */
3037int sequencer_add_exec_commands(const char *commands)
3038{
3039        const char *todo_file = rebase_path_todo();
3040        struct todo_list todo_list = TODO_LIST_INIT;
3041        struct todo_item *item;
3042        struct strbuf *buf = &todo_list.buf;
3043        size_t offset = 0, commands_len = strlen(commands);
3044        int i, first;
3045
3046        if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
3047                return error(_("could not read '%s'."), todo_file);
3048
3049        if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
3050                todo_list_release(&todo_list);
3051                return error(_("unusable todo list: '%s'"), todo_file);
3052        }
3053
3054        first = 1;
3055        /* insert <commands> before every pick except the first one */
3056        for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
3057                if (item->command == TODO_PICK && !first) {
3058                        strbuf_insert(buf, item->offset_in_buf + offset,
3059                                      commands, commands_len);
3060                        offset += commands_len;
3061                }
3062                first = 0;
3063        }
3064
3065        /* append final <commands> */
3066        strbuf_add(buf, commands, commands_len);
3067
3068        i = write_message(buf->buf, buf->len, todo_file, 0);
3069        todo_list_release(&todo_list);
3070        return i;
3071}
3072
3073int transform_todos(unsigned flags)
3074{
3075        const char *todo_file = rebase_path_todo();
3076        struct todo_list todo_list = TODO_LIST_INIT;
3077        struct strbuf buf = STRBUF_INIT;
3078        struct todo_item *item;
3079        int i;
3080
3081        if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
3082                return error(_("could not read '%s'."), todo_file);
3083
3084        if (parse_insn_buffer(todo_list.buf.buf, &todo_list)) {
3085                todo_list_release(&todo_list);
3086                return error(_("unusable todo list: '%s'"), todo_file);
3087        }
3088
3089        for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
3090                /* if the item is not a command write it and continue */
3091                if (item->command >= TODO_COMMENT) {
3092                        strbuf_addf(&buf, "%.*s\n", item->arg_len, item->arg);
3093                        continue;
3094                }
3095
3096                /* add command to the buffer */
3097                if (flags & TODO_LIST_ABBREVIATE_CMDS)
3098                        strbuf_addch(&buf, command_to_char(item->command));
3099                else
3100                        strbuf_addstr(&buf, command_to_string(item->command));
3101
3102                /* add commit id */
3103                if (item->commit) {
3104                        const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
3105                                          short_commit_name(item->commit) :
3106                                          oid_to_hex(&item->commit->object.oid);
3107
3108                        strbuf_addf(&buf, " %s", oid);
3109                }
3110                /* add all the rest */
3111                if (!item->arg_len)
3112                        strbuf_addch(&buf, '\n');
3113                else
3114                        strbuf_addf(&buf, " %.*s\n", item->arg_len, item->arg);
3115        }
3116
3117        i = write_message(buf.buf, buf.len, todo_file, 0);
3118        todo_list_release(&todo_list);
3119        return i;
3120}
3121
3122enum check_level {
3123        CHECK_IGNORE = 0, CHECK_WARN, CHECK_ERROR
3124};
3125
3126static enum check_level get_missing_commit_check_level(void)
3127{
3128        const char *value;
3129
3130        if (git_config_get_value("rebase.missingcommitscheck", &value) ||
3131                        !strcasecmp("ignore", value))
3132                return CHECK_IGNORE;
3133        if (!strcasecmp("warn", value))
3134                return CHECK_WARN;
3135        if (!strcasecmp("error", value))
3136                return CHECK_ERROR;
3137        warning(_("unrecognized setting %s for option "
3138                  "rebase.missingCommitsCheck. Ignoring."), value);
3139        return CHECK_IGNORE;
3140}
3141
3142/*
3143 * Check if the user dropped some commits by mistake
3144 * Behaviour determined by rebase.missingCommitsCheck.
3145 * Check if there is an unrecognized command or a
3146 * bad SHA-1 in a command.
3147 */
3148int check_todo_list(void)
3149{
3150        enum check_level check_level = get_missing_commit_check_level();
3151        struct strbuf todo_file = STRBUF_INIT;
3152        struct todo_list todo_list = TODO_LIST_INIT;
3153        struct strbuf missing = STRBUF_INIT;
3154        int advise_to_edit_todo = 0, res = 0, fd, i;
3155
3156        strbuf_addstr(&todo_file, rebase_path_todo());
3157        fd = open(todo_file.buf, O_RDONLY);
3158        if (fd < 0) {
3159                res = error_errno(_("could not open '%s'"), todo_file.buf);
3160                goto leave_check;
3161        }
3162        if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
3163                close(fd);
3164                res = error(_("could not read '%s'."), todo_file.buf);
3165                goto leave_check;
3166        }
3167        close(fd);
3168        advise_to_edit_todo = res =
3169                parse_insn_buffer(todo_list.buf.buf, &todo_list);
3170
3171        if (res || check_level == CHECK_IGNORE)
3172                goto leave_check;
3173
3174        /* Mark the commits in git-rebase-todo as seen */
3175        for (i = 0; i < todo_list.nr; i++) {
3176                struct commit *commit = todo_list.items[i].commit;
3177                if (commit)
3178                        commit->util = (void *)1;
3179        }
3180
3181        todo_list_release(&todo_list);
3182        strbuf_addstr(&todo_file, ".backup");
3183        fd = open(todo_file.buf, O_RDONLY);
3184        if (fd < 0) {
3185                res = error_errno(_("could not open '%s'"), todo_file.buf);
3186                goto leave_check;
3187        }
3188        if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
3189                close(fd);
3190                res = error(_("could not read '%s'."), todo_file.buf);
3191                goto leave_check;
3192        }
3193        close(fd);
3194        strbuf_release(&todo_file);
3195        res = !!parse_insn_buffer(todo_list.buf.buf, &todo_list);
3196
3197        /* Find commits in git-rebase-todo.backup yet unseen */
3198        for (i = todo_list.nr - 1; i >= 0; i--) {
3199                struct todo_item *item = todo_list.items + i;
3200                struct commit *commit = item->commit;
3201                if (commit && !commit->util) {
3202                        strbuf_addf(&missing, " - %s %.*s\n",
3203                                    short_commit_name(commit),
3204                                    item->arg_len, item->arg);
3205                        commit->util = (void *)1;
3206                }
3207        }
3208
3209        /* Warn about missing commits */
3210        if (!missing.len)
3211                goto leave_check;
3212
3213        if (check_level == CHECK_ERROR)
3214                advise_to_edit_todo = res = 1;
3215
3216        fprintf(stderr,
3217                _("Warning: some commits may have been dropped accidentally.\n"
3218                "Dropped commits (newer to older):\n"));
3219
3220        /* Make the list user-friendly and display */
3221        fputs(missing.buf, stderr);
3222        strbuf_release(&missing);
3223
3224        fprintf(stderr, _("To avoid this message, use \"drop\" to "
3225                "explicitly remove a commit.\n\n"
3226                "Use 'git config rebase.missingCommitsCheck' to change "
3227                "the level of warnings.\n"
3228                "The possible behaviours are: ignore, warn, error.\n\n"));
3229
3230leave_check:
3231        strbuf_release(&todo_file);
3232        todo_list_release(&todo_list);
3233
3234        if (advise_to_edit_todo)
3235                fprintf(stderr,
3236                        _("You can fix this with 'git rebase --edit-todo' "
3237                          "and then run 'git rebase --continue'.\n"
3238                          "Or you can abort the rebase with 'git rebase"
3239                          " --abort'.\n"));
3240
3241        return res;
3242}
3243
3244static int rewrite_file(const char *path, const char *buf, size_t len)
3245{
3246        int rc = 0;
3247        int fd = open(path, O_WRONLY | O_TRUNC);
3248        if (fd < 0)
3249                return error_errno(_("could not open '%s' for writing"), path);
3250        if (write_in_full(fd, buf, len) < 0)
3251                rc = error_errno(_("could not write to '%s'"), path);
3252        if (close(fd) && !rc)
3253                rc = error_errno(_("could not close '%s'"), path);
3254        return rc;
3255}
3256
3257/* skip picking commits whose parents are unchanged */
3258int skip_unnecessary_picks(void)
3259{
3260        const char *todo_file = rebase_path_todo();
3261        struct strbuf buf = STRBUF_INIT;
3262        struct todo_list todo_list = TODO_LIST_INIT;
3263        struct object_id onto_oid, *oid = &onto_oid, *parent_oid;
3264        int fd, i;
3265
3266        if (!read_oneliner(&buf, rebase_path_onto(), 0))
3267                return error(_("could not read 'onto'"));
3268        if (get_oid(buf.buf, &onto_oid)) {
3269                strbuf_release(&buf);
3270                return error(_("need a HEAD to fixup"));
3271        }
3272        strbuf_release(&buf);
3273
3274        fd = open(todo_file, O_RDONLY);
3275        if (fd < 0) {
3276                return error_errno(_("could not open '%s'"), todo_file);
3277        }
3278        if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
3279                close(fd);
3280                return error(_("could not read '%s'."), todo_file);
3281        }
3282        close(fd);
3283        if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
3284                todo_list_release(&todo_list);
3285                return -1;
3286        }
3287
3288        for (i = 0; i < todo_list.nr; i++) {
3289                struct todo_item *item = todo_list.items + i;
3290
3291                if (item->command >= TODO_NOOP)
3292                        continue;
3293                if (item->command != TODO_PICK)
3294                        break;
3295                if (parse_commit(item->commit)) {
3296                        todo_list_release(&todo_list);
3297                        return error(_("could not parse commit '%s'"),
3298                                oid_to_hex(&item->commit->object.oid));
3299                }
3300                if (!item->commit->parents)
3301                        break; /* root commit */
3302                if (item->commit->parents->next)
3303                        break; /* merge commit */
3304                parent_oid = &item->commit->parents->item->object.oid;
3305                if (hashcmp(parent_oid->hash, oid->hash))
3306                        break;
3307                oid = &item->commit->object.oid;
3308        }
3309        if (i > 0) {
3310                int offset = i < todo_list.nr ?
3311                        todo_list.items[i].offset_in_buf : todo_list.buf.len;
3312                const char *done_path = rebase_path_done();
3313
3314                fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
3315                if (fd < 0) {
3316                        error_errno(_("could not open '%s' for writing"),
3317                                    done_path);
3318                        todo_list_release(&todo_list);
3319                        return -1;
3320                }
3321                if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
3322                        error_errno(_("could not write to '%s'"), done_path);
3323                        todo_list_release(&todo_list);
3324                        close(fd);
3325                        return -1;
3326                }
3327                close(fd);
3328
3329                if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
3330                                 todo_list.buf.len - offset) < 0) {
3331                        todo_list_release(&todo_list);
3332                        return -1;
3333                }
3334
3335                todo_list.current = i;
3336                if (is_fixup(peek_command(&todo_list, 0)))
3337                        record_in_rewritten(oid, peek_command(&todo_list, 0));
3338        }
3339
3340        todo_list_release(&todo_list);
3341        printf("%s\n", oid_to_hex(oid));
3342
3343        return 0;
3344}
3345
3346struct subject2item_entry {
3347        struct hashmap_entry entry;
3348        int i;
3349        char subject[FLEX_ARRAY];
3350};
3351
3352static int subject2item_cmp(const void *fndata,
3353                            const struct subject2item_entry *a,
3354                            const struct subject2item_entry *b, const void *key)
3355{
3356        return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
3357}
3358
3359/*
3360 * Rearrange the todo list that has both "pick commit-id msg" and "pick
3361 * commit-id fixup!/squash! msg" in it so that the latter is put immediately
3362 * after the former, and change "pick" to "fixup"/"squash".
3363 *
3364 * Note that if the config has specified a custom instruction format, each log
3365 * message will have to be retrieved from the commit (as the oneline in the
3366 * script cannot be trusted) in order to normalize the autosquash arrangement.
3367 */
3368int rearrange_squash(void)
3369{
3370        const char *todo_file = rebase_path_todo();
3371        struct todo_list todo_list = TODO_LIST_INIT;
3372        struct hashmap subject2item;
3373        int res = 0, rearranged = 0, *next, *tail, fd, i;
3374        char **subjects;
3375
3376        fd = open(todo_file, O_RDONLY);
3377        if (fd < 0)
3378                return error_errno(_("could not open '%s'"), todo_file);
3379        if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
3380                close(fd);
3381                return error(_("could not read '%s'."), todo_file);
3382        }
3383        close(fd);
3384        if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
3385                todo_list_release(&todo_list);
3386                return -1;
3387        }
3388
3389        /*
3390         * The hashmap maps onelines to the respective todo list index.
3391         *
3392         * If any items need to be rearranged, the next[i] value will indicate
3393         * which item was moved directly after the i'th.
3394         *
3395         * In that case, last[i] will indicate the index of the latest item to
3396         * be moved to appear after the i'th.
3397         */
3398        hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
3399                     NULL, todo_list.nr);
3400        ALLOC_ARRAY(next, todo_list.nr);
3401        ALLOC_ARRAY(tail, todo_list.nr);
3402        ALLOC_ARRAY(subjects, todo_list.nr);
3403        for (i = 0; i < todo_list.nr; i++) {
3404                struct strbuf buf = STRBUF_INIT;
3405                struct todo_item *item = todo_list.items + i;
3406                const char *commit_buffer, *subject, *p;
3407                size_t subject_len;
3408                int i2 = -1;
3409                struct subject2item_entry *entry;
3410
3411                next[i] = tail[i] = -1;
3412                if (item->command >= TODO_EXEC) {
3413                        subjects[i] = NULL;
3414                        continue;
3415                }
3416
3417                if (is_fixup(item->command)) {
3418                        todo_list_release(&todo_list);
3419                        return error(_("the script was already rearranged."));
3420                }
3421
3422                item->commit->util = item;
3423
3424                parse_commit(item->commit);
3425                commit_buffer = get_commit_buffer(item->commit, NULL);
3426                find_commit_subject(commit_buffer, &subject);
3427                format_subject(&buf, subject, " ");
3428                subject = subjects[i] = strbuf_detach(&buf, &subject_len);
3429                unuse_commit_buffer(item->commit, commit_buffer);
3430                if ((skip_prefix(subject, "fixup! ", &p) ||
3431                     skip_prefix(subject, "squash! ", &p))) {
3432                        struct commit *commit2;
3433
3434                        for (;;) {
3435                                while (isspace(*p))
3436                                        p++;
3437                                if (!skip_prefix(p, "fixup! ", &p) &&
3438                                    !skip_prefix(p, "squash! ", &p))
3439                                        break;
3440                        }
3441
3442                        if ((entry = hashmap_get_from_hash(&subject2item,
3443                                                           strhash(p), p)))
3444                                /* found by title */
3445                                i2 = entry->i;
3446                        else if (!strchr(p, ' ') &&
3447                                 (commit2 =
3448                                  lookup_commit_reference_by_name(p)) &&
3449                                 commit2->util)
3450                                /* found by commit name */
3451                                i2 = (struct todo_item *)commit2->util
3452                                        - todo_list.items;
3453                        else {
3454                                /* copy can be a prefix of the commit subject */
3455                                for (i2 = 0; i2 < i; i2++)
3456                                        if (subjects[i2] &&
3457                                            starts_with(subjects[i2], p))
3458                                                break;
3459                                if (i2 == i)
3460                                        i2 = -1;
3461                        }
3462                }
3463                if (i2 >= 0) {
3464                        rearranged = 1;
3465                        todo_list.items[i].command =
3466                                starts_with(subject, "fixup!") ?
3467                                TODO_FIXUP : TODO_SQUASH;
3468                        if (next[i2] < 0)
3469                                next[i2] = i;
3470                        else
3471                                next[tail[i2]] = i;
3472                        tail[i2] = i;
3473                } else if (!hashmap_get_from_hash(&subject2item,
3474                                                strhash(subject), subject)) {
3475                        FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
3476                        entry->i = i;
3477                        hashmap_entry_init(entry, strhash(entry->subject));
3478                        hashmap_put(&subject2item, entry);
3479                }
3480        }
3481
3482        if (rearranged) {
3483                struct strbuf buf = STRBUF_INIT;
3484
3485                for (i = 0; i < todo_list.nr; i++) {
3486                        enum todo_command command = todo_list.items[i].command;
3487                        int cur = i;
3488
3489                        /*
3490                         * Initially, all commands are 'pick's. If it is a
3491                         * fixup or a squash now, we have rearranged it.
3492                         */
3493                        if (is_fixup(command))
3494                                continue;
3495
3496                        while (cur >= 0) {
3497                                int offset = todo_list.items[cur].offset_in_buf;
3498                                int end_offset = cur + 1 < todo_list.nr ?
3499                                        todo_list.items[cur + 1].offset_in_buf :
3500                                        todo_list.buf.len;
3501                                char *bol = todo_list.buf.buf + offset;
3502                                char *eol = todo_list.buf.buf + end_offset;
3503
3504                                /* replace 'pick', by 'fixup' or 'squash' */
3505                                command = todo_list.items[cur].command;
3506                                if (is_fixup(command)) {
3507                                        strbuf_addstr(&buf,
3508                                                todo_command_info[command].str);
3509                                        bol += strcspn(bol, " \t");
3510                                }
3511
3512                                strbuf_add(&buf, bol, eol - bol);
3513
3514                                cur = next[cur];
3515                        }
3516                }
3517
3518                res = rewrite_file(todo_file, buf.buf, buf.len);
3519                strbuf_release(&buf);
3520        }
3521
3522        free(next);
3523        free(tail);
3524        for (i = 0; i < todo_list.nr; i++)
3525                free(subjects[i]);
3526        free(subjects);
3527        hashmap_free(&subject2item, 1);
3528        todo_list_release(&todo_list);
3529
3530        return res;
3531}