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