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