sequencer.c

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