Merge branch 'js/smart-http-detect-remote-error'
[git] / sequencer.c
1 #include "cache.h"
2 #include "config.h"
3 #include "lockfile.h"
4 #include "dir.h"
5 #include "object-store.h"
6 #include "object.h"
7 #include "commit.h"
8 #include "sequencer.h"
9 #include "tag.h"
10 #include "run-command.h"
11 #include "exec-cmd.h"
12 #include "utf8.h"
13 #include "cache-tree.h"
14 #include "diff.h"
15 #include "revision.h"
16 #include "rerere.h"
17 #include "merge-recursive.h"
18 #include "refs.h"
19 #include "argv-array.h"
20 #include "quote.h"
21 #include "trailer.h"
22 #include "log-tree.h"
23 #include "wt-status.h"
24 #include "hashmap.h"
25 #include "notes-utils.h"
26 #include "sigchain.h"
27 #include "unpack-trees.h"
28 #include "worktree.h"
29 #include "oidmap.h"
30 #include "oidset.h"
31 #include "commit-slab.h"
32 #include "alias.h"
33 #include "commit-reach.h"
34 #include "rebase-interactive.h"
35
36 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
37
38 const char sign_off_header[] = "Signed-off-by: ";
39 static const char cherry_picked_prefix[] = "(cherry picked from commit ";
40
41 GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
42
43 GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
44
45 static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
46 static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
47 static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
48 static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
49
50 static GIT_PATH_FUNC(rebase_path, "rebase-merge")
51 /*
52  * The file containing rebase commands, comments, and empty lines.
53  * This file is created by "git rebase -i" then edited by the user. As
54  * the lines are processed, they are removed from the front of this
55  * file and written to the tail of 'done'.
56  */
57 GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
58 static GIT_PATH_FUNC(rebase_path_todo_backup,
59                      "rebase-merge/git-rebase-todo.backup")
60
61 /*
62  * The rebase command lines that have already been processed. A line
63  * is moved here when it is first handled, before any associated user
64  * actions.
65  */
66 static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
67 /*
68  * The file to keep track of how many commands were already processed (e.g.
69  * for the prompt).
70  */
71 static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum")
72 /*
73  * The file to keep track of how many commands are to be processed in total
74  * (e.g. for the prompt).
75  */
76 static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end")
77 /*
78  * The commit message that is planned to be used for any changes that
79  * need to be committed following a user interaction.
80  */
81 static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
82 /*
83  * The file into which is accumulated the suggested commit message for
84  * squash/fixup commands. When the first of a series of squash/fixups
85  * is seen, the file is created and the commit message from the
86  * previous commit and from the first squash/fixup commit are written
87  * to it. The commit message for each subsequent squash/fixup commit
88  * is appended to the file as it is processed.
89  */
90 static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
91 /*
92  * If the current series of squash/fixups has not yet included a squash
93  * command, then this file exists and holds the commit message of the
94  * original "pick" commit.  (If the series ends without a "squash"
95  * command, then this can be used as the commit message of the combined
96  * commit without opening the editor.)
97  */
98 static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
99 /*
100  * This file contains the list fixup/squash commands that have been
101  * accumulated into message-fixup or message-squash so far.
102  */
103 static GIT_PATH_FUNC(rebase_path_current_fixups, "rebase-merge/current-fixups")
104 /*
105  * A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
106  * GIT_AUTHOR_DATE that will be used for the commit that is currently
107  * being rebased.
108  */
109 static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
110 /*
111  * When an "edit" rebase command is being processed, the SHA1 of the
112  * commit to be edited is recorded in this file.  When "git rebase
113  * --continue" is executed, if there are any staged changes then they
114  * will be amended to the HEAD commit, but only provided the HEAD
115  * commit is still the commit to be edited.  When any other rebase
116  * command is processed, this file is deleted.
117  */
118 static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
119 /*
120  * When we stop at a given patch via the "edit" command, this file contains
121  * the abbreviated commit name of the corresponding patch.
122  */
123 static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
124 /*
125  * For the post-rewrite hook, we make a list of rewritten commits and
126  * their new sha1s.  The rewritten-pending list keeps the sha1s of
127  * commits that have been processed, but not committed yet,
128  * e.g. because they are waiting for a 'squash' command.
129  */
130 static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
131 static GIT_PATH_FUNC(rebase_path_rewritten_pending,
132         "rebase-merge/rewritten-pending")
133
134 /*
135  * The path of the file containig the OID of the "squash onto" commit, i.e.
136  * the dummy commit used for `reset [new root]`.
137  */
138 static GIT_PATH_FUNC(rebase_path_squash_onto, "rebase-merge/squash-onto")
139
140 /*
141  * The path of the file listing refs that need to be deleted after the rebase
142  * finishes. This is used by the `label` command to record the need for cleanup.
143  */
144 static GIT_PATH_FUNC(rebase_path_refs_to_delete, "rebase-merge/refs-to-delete")
145
146 /*
147  * The following files are written by git-rebase just after parsing the
148  * command-line.
149  */
150 static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
151 static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
152 static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
153 static GIT_PATH_FUNC(rebase_path_quiet, "rebase-merge/quiet")
154 static GIT_PATH_FUNC(rebase_path_signoff, "rebase-merge/signoff")
155 static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
156 static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
157 static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
158 static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
159 static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
160 static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
161 static GIT_PATH_FUNC(rebase_path_reschedule_failed_exec, "rebase-merge/reschedule-failed-exec")
162
163 static int git_sequencer_config(const char *k, const char *v, void *cb)
164 {
165         struct replay_opts *opts = cb;
166         int status;
167
168         if (!strcmp(k, "commit.cleanup")) {
169                 const char *s;
170
171                 status = git_config_string(&s, k, v);
172                 if (status)
173                         return status;
174
175                 if (!strcmp(s, "verbatim"))
176                         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
177                 else if (!strcmp(s, "whitespace"))
178                         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
179                 else if (!strcmp(s, "strip"))
180                         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_ALL;
181                 else if (!strcmp(s, "scissors"))
182                         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_SPACE;
183                 else
184                         warning(_("invalid commit message cleanup mode '%s'"),
185                                   s);
186
187                 free((char *)s);
188                 return status;
189         }
190
191         if (!strcmp(k, "commit.gpgsign")) {
192                 opts->gpg_sign = git_config_bool(k, v) ? xstrdup("") : NULL;
193                 return 0;
194         }
195
196         status = git_gpg_config(k, v, NULL);
197         if (status)
198                 return status;
199
200         return git_diff_basic_config(k, v, NULL);
201 }
202
203 void sequencer_init_config(struct replay_opts *opts)
204 {
205         opts->default_msg_cleanup = COMMIT_MSG_CLEANUP_NONE;
206         git_config(git_sequencer_config, opts);
207 }
208
209 static inline int is_rebase_i(const struct replay_opts *opts)
210 {
211         return opts->action == REPLAY_INTERACTIVE_REBASE;
212 }
213
214 static const char *get_dir(const struct replay_opts *opts)
215 {
216         if (is_rebase_i(opts))
217                 return rebase_path();
218         return git_path_seq_dir();
219 }
220
221 static const char *get_todo_path(const struct replay_opts *opts)
222 {
223         if (is_rebase_i(opts))
224                 return rebase_path_todo();
225         return git_path_todo_file();
226 }
227
228 /*
229  * Returns 0 for non-conforming footer
230  * Returns 1 for conforming footer
231  * Returns 2 when sob exists within conforming footer
232  * Returns 3 when sob exists within conforming footer as last entry
233  */
234 static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
235         size_t ignore_footer)
236 {
237         struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
238         struct trailer_info info;
239         size_t i;
240         int found_sob = 0, found_sob_last = 0;
241
242         opts.no_divider = 1;
243
244         trailer_info_get(&info, sb->buf, &opts);
245
246         if (info.trailer_start == info.trailer_end)
247                 return 0;
248
249         for (i = 0; i < info.trailer_nr; i++)
250                 if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
251                         found_sob = 1;
252                         if (i == info.trailer_nr - 1)
253                                 found_sob_last = 1;
254                 }
255
256         trailer_info_release(&info);
257
258         if (found_sob_last)
259                 return 3;
260         if (found_sob)
261                 return 2;
262         return 1;
263 }
264
265 static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
266 {
267         static struct strbuf buf = STRBUF_INIT;
268
269         strbuf_reset(&buf);
270         if (opts->gpg_sign)
271                 sq_quotef(&buf, "-S%s", opts->gpg_sign);
272         return buf.buf;
273 }
274
275 int sequencer_remove_state(struct replay_opts *opts)
276 {
277         struct strbuf buf = STRBUF_INIT;
278         int i;
279
280         if (is_rebase_i(opts) &&
281             strbuf_read_file(&buf, rebase_path_refs_to_delete(), 0) > 0) {
282                 char *p = buf.buf;
283                 while (*p) {
284                         char *eol = strchr(p, '\n');
285                         if (eol)
286                                 *eol = '\0';
287                         if (delete_ref("(rebase -i) cleanup", p, NULL, 0) < 0)
288                                 warning(_("could not delete '%s'"), p);
289                         if (!eol)
290                                 break;
291                         p = eol + 1;
292                 }
293         }
294
295         free(opts->gpg_sign);
296         free(opts->strategy);
297         for (i = 0; i < opts->xopts_nr; i++)
298                 free(opts->xopts[i]);
299         free(opts->xopts);
300         strbuf_release(&opts->current_fixups);
301
302         strbuf_reset(&buf);
303         strbuf_addstr(&buf, get_dir(opts));
304         remove_dir_recursively(&buf, 0);
305         strbuf_release(&buf);
306
307         return 0;
308 }
309
310 static const char *action_name(const struct replay_opts *opts)
311 {
312         switch (opts->action) {
313         case REPLAY_REVERT:
314                 return N_("revert");
315         case REPLAY_PICK:
316                 return N_("cherry-pick");
317         case REPLAY_INTERACTIVE_REBASE:
318                 return N_("rebase -i");
319         }
320         die(_("unknown action: %d"), opts->action);
321 }
322
323 struct commit_message {
324         char *parent_label;
325         char *label;
326         char *subject;
327         const char *message;
328 };
329
330 static const char *short_commit_name(struct commit *commit)
331 {
332         return find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV);
333 }
334
335 static int get_message(struct commit *commit, struct commit_message *out)
336 {
337         const char *abbrev, *subject;
338         int subject_len;
339
340         out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
341         abbrev = short_commit_name(commit);
342
343         subject_len = find_commit_subject(out->message, &subject);
344
345         out->subject = xmemdupz(subject, subject_len);
346         out->label = xstrfmt("%s... %s", abbrev, out->subject);
347         out->parent_label = xstrfmt("parent of %s", out->label);
348
349         return 0;
350 }
351
352 static void free_message(struct commit *commit, struct commit_message *msg)
353 {
354         free(msg->parent_label);
355         free(msg->label);
356         free(msg->subject);
357         unuse_commit_buffer(commit, msg->message);
358 }
359
360 static void print_advice(struct repository *r, int show_hint,
361                          struct replay_opts *opts)
362 {
363         char *msg = getenv("GIT_CHERRY_PICK_HELP");
364
365         if (msg) {
366                 fprintf(stderr, "%s\n", msg);
367                 /*
368                  * A conflict has occurred but the porcelain
369                  * (typically rebase --interactive) wants to take care
370                  * of the commit itself so remove CHERRY_PICK_HEAD
371                  */
372                 unlink(git_path_cherry_pick_head(r));
373                 return;
374         }
375
376         if (show_hint) {
377                 if (opts->no_commit)
378                         advise(_("after resolving the conflicts, mark the corrected paths\n"
379                                  "with 'git add <paths>' or 'git rm <paths>'"));
380                 else
381                         advise(_("after resolving the conflicts, mark the corrected paths\n"
382                                  "with 'git add <paths>' or 'git rm <paths>'\n"
383                                  "and commit the result with 'git commit'"));
384         }
385 }
386
387 int write_message(const void *buf, size_t len, const char *filename,
388                   int append_eol)
389 {
390         struct lock_file msg_file = LOCK_INIT;
391
392         int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
393         if (msg_fd < 0)
394                 return error_errno(_("could not lock '%s'"), filename);
395         if (write_in_full(msg_fd, buf, len) < 0) {
396                 error_errno(_("could not write to '%s'"), filename);
397                 rollback_lock_file(&msg_file);
398                 return -1;
399         }
400         if (append_eol && write(msg_fd, "\n", 1) < 0) {
401                 error_errno(_("could not write eol to '%s'"), filename);
402                 rollback_lock_file(&msg_file);
403                 return -1;
404         }
405         if (commit_lock_file(&msg_file) < 0)
406                 return error(_("failed to finalize '%s'"), filename);
407
408         return 0;
409 }
410
411 /*
412  * Reads a file that was presumably written by a shell script, i.e. with an
413  * end-of-line marker that needs to be stripped.
414  *
415  * Note that only the last end-of-line marker is stripped, consistent with the
416  * behavior of "$(cat path)" in a shell script.
417  *
418  * Returns 1 if the file was read, 0 if it could not be read or does not exist.
419  */
420 static int read_oneliner(struct strbuf *buf,
421         const char *path, int skip_if_empty)
422 {
423         int orig_len = buf->len;
424
425         if (!file_exists(path))
426                 return 0;
427
428         if (strbuf_read_file(buf, path, 0) < 0) {
429                 warning_errno(_("could not read '%s'"), path);
430                 return 0;
431         }
432
433         if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
434                 if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
435                         --buf->len;
436                 buf->buf[buf->len] = '\0';
437         }
438
439         if (skip_if_empty && buf->len == orig_len)
440                 return 0;
441
442         return 1;
443 }
444
445 static struct tree *empty_tree(struct repository *r)
446 {
447         return lookup_tree(r, the_hash_algo->empty_tree);
448 }
449
450 static int error_dirty_index(struct repository *repo, struct replay_opts *opts)
451 {
452         if (repo_read_index_unmerged(repo))
453                 return error_resolve_conflict(_(action_name(opts)));
454
455         error(_("your local changes would be overwritten by %s."),
456                 _(action_name(opts)));
457
458         if (advice_commit_before_merge)
459                 advise(_("commit your changes or stash them to proceed."));
460         return -1;
461 }
462
463 static void update_abort_safety_file(void)
464 {
465         struct object_id head;
466
467         /* Do nothing on a single-pick */
468         if (!file_exists(git_path_seq_dir()))
469                 return;
470
471         if (!get_oid("HEAD", &head))
472                 write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
473         else
474                 write_file(git_path_abort_safety_file(), "%s", "");
475 }
476
477 static int fast_forward_to(struct repository *r,
478                            const struct object_id *to,
479                            const struct object_id *from,
480                            int unborn,
481                            struct replay_opts *opts)
482 {
483         struct ref_transaction *transaction;
484         struct strbuf sb = STRBUF_INIT;
485         struct strbuf err = STRBUF_INIT;
486
487         repo_read_index(r);
488         if (checkout_fast_forward(r, from, to, 1))
489                 return -1; /* the callee should have complained already */
490
491         strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
492
493         transaction = ref_transaction_begin(&err);
494         if (!transaction ||
495             ref_transaction_update(transaction, "HEAD",
496                                    to, unborn && !is_rebase_i(opts) ?
497                                    &null_oid : from,
498                                    0, sb.buf, &err) ||
499             ref_transaction_commit(transaction, &err)) {
500                 ref_transaction_free(transaction);
501                 error("%s", err.buf);
502                 strbuf_release(&sb);
503                 strbuf_release(&err);
504                 return -1;
505         }
506
507         strbuf_release(&sb);
508         strbuf_release(&err);
509         ref_transaction_free(transaction);
510         update_abort_safety_file();
511         return 0;
512 }
513
514 void append_conflicts_hint(struct index_state *istate,
515                            struct strbuf *msgbuf)
516 {
517         int i;
518
519         strbuf_addch(msgbuf, '\n');
520         strbuf_commented_addf(msgbuf, "Conflicts:\n");
521         for (i = 0; i < istate->cache_nr;) {
522                 const struct cache_entry *ce = istate->cache[i++];
523                 if (ce_stage(ce)) {
524                         strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
525                         while (i < istate->cache_nr &&
526                                !strcmp(ce->name, istate->cache[i]->name))
527                                 i++;
528                 }
529         }
530 }
531
532 static int do_recursive_merge(struct repository *r,
533                               struct commit *base, struct commit *next,
534                               const char *base_label, const char *next_label,
535                               struct object_id *head, struct strbuf *msgbuf,
536                               struct replay_opts *opts)
537 {
538         struct merge_options o;
539         struct tree *result, *next_tree, *base_tree, *head_tree;
540         int clean;
541         char **xopt;
542         struct lock_file index_lock = LOCK_INIT;
543
544         if (repo_hold_locked_index(r, &index_lock, LOCK_REPORT_ON_ERROR) < 0)
545                 return -1;
546
547         repo_read_index(r);
548
549         init_merge_options(&o, r);
550         o.ancestor = base ? base_label : "(empty tree)";
551         o.branch1 = "HEAD";
552         o.branch2 = next ? next_label : "(empty tree)";
553         if (is_rebase_i(opts))
554                 o.buffer_output = 2;
555         o.show_rename_progress = 1;
556
557         head_tree = parse_tree_indirect(head);
558         next_tree = next ? get_commit_tree(next) : empty_tree(r);
559         base_tree = base ? get_commit_tree(base) : empty_tree(r);
560
561         for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
562                 parse_merge_opt(&o, *xopt);
563
564         clean = merge_trees(&o,
565                             head_tree,
566                             next_tree, base_tree, &result);
567         if (is_rebase_i(opts) && clean <= 0)
568                 fputs(o.obuf.buf, stdout);
569         strbuf_release(&o.obuf);
570         diff_warn_rename_limit("merge.renamelimit", o.needed_rename_limit, 0);
571         if (clean < 0) {
572                 rollback_lock_file(&index_lock);
573                 return clean;
574         }
575
576         if (write_locked_index(r->index, &index_lock,
577                                COMMIT_LOCK | SKIP_IF_UNCHANGED))
578                 /*
579                  * TRANSLATORS: %s will be "revert", "cherry-pick" or
580                  * "rebase -i".
581                  */
582                 return error(_("%s: Unable to write new index file"),
583                         _(action_name(opts)));
584
585         if (!clean)
586                 append_conflicts_hint(r->index, msgbuf);
587
588         return !clean;
589 }
590
591 static struct object_id *get_cache_tree_oid(struct index_state *istate)
592 {
593         if (!istate->cache_tree)
594                 istate->cache_tree = cache_tree();
595
596         if (!cache_tree_fully_valid(istate->cache_tree))
597                 if (cache_tree_update(istate, 0)) {
598                         error(_("unable to update cache tree"));
599                         return NULL;
600                 }
601
602         return &istate->cache_tree->oid;
603 }
604
605 static int is_index_unchanged(struct repository *r)
606 {
607         struct object_id head_oid, *cache_tree_oid;
608         struct commit *head_commit;
609         struct index_state *istate = r->index;
610
611         if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
612                 return error(_("could not resolve HEAD commit"));
613
614         head_commit = lookup_commit(r, &head_oid);
615
616         /*
617          * If head_commit is NULL, check_commit, called from
618          * lookup_commit, would have indicated that head_commit is not
619          * a commit object already.  parse_commit() will return failure
620          * without further complaints in such a case.  Otherwise, if
621          * the commit is invalid, parse_commit() will complain.  So
622          * there is nothing for us to say here.  Just return failure.
623          */
624         if (parse_commit(head_commit))
625                 return -1;
626
627         if (!(cache_tree_oid = get_cache_tree_oid(istate)))
628                 return -1;
629
630         return oideq(cache_tree_oid, get_commit_tree_oid(head_commit));
631 }
632
633 static int write_author_script(const char *message)
634 {
635         struct strbuf buf = STRBUF_INIT;
636         const char *eol;
637         int res;
638
639         for (;;)
640                 if (!*message || starts_with(message, "\n")) {
641 missing_author:
642                         /* Missing 'author' line? */
643                         unlink(rebase_path_author_script());
644                         return 0;
645                 } else if (skip_prefix(message, "author ", &message))
646                         break;
647                 else if ((eol = strchr(message, '\n')))
648                         message = eol + 1;
649                 else
650                         goto missing_author;
651
652         strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
653         while (*message && *message != '\n' && *message != '\r')
654                 if (skip_prefix(message, " <", &message))
655                         break;
656                 else if (*message != '\'')
657                         strbuf_addch(&buf, *(message++));
658                 else
659                         strbuf_addf(&buf, "'\\%c'", *(message++));
660         strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
661         while (*message && *message != '\n' && *message != '\r')
662                 if (skip_prefix(message, "> ", &message))
663                         break;
664                 else if (*message != '\'')
665                         strbuf_addch(&buf, *(message++));
666                 else
667                         strbuf_addf(&buf, "'\\%c'", *(message++));
668         strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
669         while (*message && *message != '\n' && *message != '\r')
670                 if (*message != '\'')
671                         strbuf_addch(&buf, *(message++));
672                 else
673                         strbuf_addf(&buf, "'\\%c'", *(message++));
674         strbuf_addch(&buf, '\'');
675         res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
676         strbuf_release(&buf);
677         return res;
678 }
679
680 /**
681  * Take a series of KEY='VALUE' lines where VALUE part is
682  * sq-quoted, and append <KEY, VALUE> at the end of the string list
683  */
684 static int parse_key_value_squoted(char *buf, struct string_list *list)
685 {
686         while (*buf) {
687                 struct string_list_item *item;
688                 char *np;
689                 char *cp = strchr(buf, '=');
690                 if (!cp) {
691                         np = strchrnul(buf, '\n');
692                         return error(_("no key present in '%.*s'"),
693                                      (int) (np - buf), buf);
694                 }
695                 np = strchrnul(cp, '\n');
696                 *cp++ = '\0';
697                 item = string_list_append(list, buf);
698
699                 buf = np + (*np == '\n');
700                 *np = '\0';
701                 cp = sq_dequote(cp);
702                 if (!cp)
703                         return error(_("unable to dequote value of '%s'"),
704                                      item->string);
705                 item->util = xstrdup(cp);
706         }
707         return 0;
708 }
709
710 /**
711  * Reads and parses the state directory's "author-script" file, and sets name,
712  * email and date accordingly.
713  * Returns 0 on success, -1 if the file could not be parsed.
714  *
715  * The author script is of the format:
716  *
717  *      GIT_AUTHOR_NAME='$author_name'
718  *      GIT_AUTHOR_EMAIL='$author_email'
719  *      GIT_AUTHOR_DATE='$author_date'
720  *
721  * where $author_name, $author_email and $author_date are quoted. We are strict
722  * with our parsing, as the file was meant to be eval'd in the old
723  * git-am.sh/git-rebase--interactive.sh scripts, and thus if the file differs
724  * from what this function expects, it is better to bail out than to do
725  * something that the user does not expect.
726  */
727 int read_author_script(const char *path, char **name, char **email, char **date,
728                        int allow_missing)
729 {
730         struct strbuf buf = STRBUF_INIT;
731         struct string_list kv = STRING_LIST_INIT_DUP;
732         int retval = -1; /* assume failure */
733         int i, name_i = -2, email_i = -2, date_i = -2, err = 0;
734
735         if (strbuf_read_file(&buf, path, 256) <= 0) {
736                 strbuf_release(&buf);
737                 if (errno == ENOENT && allow_missing)
738                         return 0;
739                 else
740                         return error_errno(_("could not open '%s' for reading"),
741                                            path);
742         }
743
744         if (parse_key_value_squoted(buf.buf, &kv))
745                 goto finish;
746
747         for (i = 0; i < kv.nr; i++) {
748                 if (!strcmp(kv.items[i].string, "GIT_AUTHOR_NAME")) {
749                         if (name_i != -2)
750                                 name_i = error(_("'GIT_AUTHOR_NAME' already given"));
751                         else
752                                 name_i = i;
753                 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_EMAIL")) {
754                         if (email_i != -2)
755                                 email_i = error(_("'GIT_AUTHOR_EMAIL' already given"));
756                         else
757                                 email_i = i;
758                 } else if (!strcmp(kv.items[i].string, "GIT_AUTHOR_DATE")) {
759                         if (date_i != -2)
760                                 date_i = error(_("'GIT_AUTHOR_DATE' already given"));
761                         else
762                                 date_i = i;
763                 } else {
764                         err = error(_("unknown variable '%s'"),
765                                     kv.items[i].string);
766                 }
767         }
768         if (name_i == -2)
769                 error(_("missing 'GIT_AUTHOR_NAME'"));
770         if (email_i == -2)
771                 error(_("missing 'GIT_AUTHOR_EMAIL'"));
772         if (date_i == -2)
773                 error(_("missing 'GIT_AUTHOR_DATE'"));
774         if (date_i < 0 || email_i < 0 || date_i < 0 || err)
775                 goto finish;
776         *name = kv.items[name_i].util;
777         *email = kv.items[email_i].util;
778         *date = kv.items[date_i].util;
779         retval = 0;
780 finish:
781         string_list_clear(&kv, !!retval);
782         strbuf_release(&buf);
783         return retval;
784 }
785
786 /*
787  * Read a GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL AND GIT_AUTHOR_DATE from a
788  * file with shell quoting into struct argv_array. Returns -1 on
789  * error, 0 otherwise.
790  */
791 static int read_env_script(struct argv_array *env)
792 {
793         char *name, *email, *date;
794
795         if (read_author_script(rebase_path_author_script(),
796                                &name, &email, &date, 0))
797                 return -1;
798
799         argv_array_pushf(env, "GIT_AUTHOR_NAME=%s", name);
800         argv_array_pushf(env, "GIT_AUTHOR_EMAIL=%s", email);
801         argv_array_pushf(env, "GIT_AUTHOR_DATE=%s", date);
802         free(name);
803         free(email);
804         free(date);
805
806         return 0;
807 }
808
809 static char *get_author(const char *message)
810 {
811         size_t len;
812         const char *a;
813
814         a = find_commit_header(message, "author", &len);
815         if (a)
816                 return xmemdupz(a, len);
817
818         return NULL;
819 }
820
821 /* Read author-script and return an ident line (author <email> timestamp) */
822 static const char *read_author_ident(struct strbuf *buf)
823 {
824         struct strbuf out = STRBUF_INIT;
825         char *name, *email, *date;
826
827         if (read_author_script(rebase_path_author_script(),
828                                &name, &email, &date, 0))
829                 return NULL;
830
831         /* validate date since fmt_ident() will die() on bad value */
832         if (parse_date(date, &out)){
833                 warning(_("invalid date format '%s' in '%s'"),
834                         date, rebase_path_author_script());
835                 strbuf_release(&out);
836                 return NULL;
837         }
838
839         strbuf_reset(&out);
840         strbuf_addstr(&out, fmt_ident(name, email, date, 0));
841         strbuf_swap(buf, &out);
842         strbuf_release(&out);
843         free(name);
844         free(email);
845         free(date);
846         return buf->buf;
847 }
848
849 static const char staged_changes_advice[] =
850 N_("you have staged changes in your working tree\n"
851 "If these changes are meant to be squashed into the previous commit, run:\n"
852 "\n"
853 "  git commit --amend %s\n"
854 "\n"
855 "If they are meant to go into a new commit, run:\n"
856 "\n"
857 "  git commit %s\n"
858 "\n"
859 "In both cases, once you're done, continue with:\n"
860 "\n"
861 "  git rebase --continue\n");
862
863 #define ALLOW_EMPTY (1<<0)
864 #define EDIT_MSG    (1<<1)
865 #define AMEND_MSG   (1<<2)
866 #define CLEANUP_MSG (1<<3)
867 #define VERIFY_MSG  (1<<4)
868 #define CREATE_ROOT_COMMIT (1<<5)
869
870 static int run_command_silent_on_success(struct child_process *cmd)
871 {
872         struct strbuf buf = STRBUF_INIT;
873         int rc;
874
875         cmd->stdout_to_stderr = 1;
876         rc = pipe_command(cmd,
877                           NULL, 0,
878                           NULL, 0,
879                           &buf, 0);
880
881         if (rc)
882                 fputs(buf.buf, stderr);
883         strbuf_release(&buf);
884         return rc;
885 }
886
887 /*
888  * If we are cherry-pick, and if the merge did not result in
889  * hand-editing, we will hit this commit and inherit the original
890  * author date and name.
891  *
892  * If we are revert, or if our cherry-pick results in a hand merge,
893  * we had better say that the current user is responsible for that.
894  *
895  * An exception is when run_git_commit() is called during an
896  * interactive rebase: in that case, we will want to retain the
897  * author metadata.
898  */
899 static int run_git_commit(struct repository *r,
900                           const char *defmsg,
901                           struct replay_opts *opts,
902                           unsigned int flags)
903 {
904         struct child_process cmd = CHILD_PROCESS_INIT;
905         const char *value;
906
907         if ((flags & CREATE_ROOT_COMMIT) && !(flags & AMEND_MSG)) {
908                 struct strbuf msg = STRBUF_INIT, script = STRBUF_INIT;
909                 const char *author = NULL;
910                 struct object_id root_commit, *cache_tree_oid;
911                 int res = 0;
912
913                 if (is_rebase_i(opts)) {
914                         author = read_author_ident(&script);
915                         if (!author) {
916                                 strbuf_release(&script);
917                                 return -1;
918                         }
919                 }
920
921                 if (!defmsg)
922                         BUG("root commit without message");
923
924                 if (!(cache_tree_oid = get_cache_tree_oid(r->index)))
925                         res = -1;
926
927                 if (!res)
928                         res = strbuf_read_file(&msg, defmsg, 0);
929
930                 if (res <= 0)
931                         res = error_errno(_("could not read '%s'"), defmsg);
932                 else
933                         res = commit_tree(msg.buf, msg.len, cache_tree_oid,
934                                           NULL, &root_commit, author,
935                                           opts->gpg_sign);
936
937                 strbuf_release(&msg);
938                 strbuf_release(&script);
939                 if (!res) {
940                         update_ref(NULL, "CHERRY_PICK_HEAD", &root_commit, NULL,
941                                    REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR);
942                         res = update_ref(NULL, "HEAD", &root_commit, NULL, 0,
943                                          UPDATE_REFS_MSG_ON_ERR);
944                 }
945                 return res < 0 ? error(_("writing root commit")) : 0;
946         }
947
948         cmd.git_cmd = 1;
949
950         if (is_rebase_i(opts) && read_env_script(&cmd.env_array)) {
951                 const char *gpg_opt = gpg_sign_opt_quoted(opts);
952
953                 return error(_(staged_changes_advice),
954                              gpg_opt, gpg_opt);
955         }
956
957         argv_array_push(&cmd.args, "commit");
958
959         if (!(flags & VERIFY_MSG))
960                 argv_array_push(&cmd.args, "-n");
961         if ((flags & AMEND_MSG))
962                 argv_array_push(&cmd.args, "--amend");
963         if (opts->gpg_sign)
964                 argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
965         if (defmsg)
966                 argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
967         else if (!(flags & EDIT_MSG))
968                 argv_array_pushl(&cmd.args, "-C", "HEAD", NULL);
969         if ((flags & CLEANUP_MSG))
970                 argv_array_push(&cmd.args, "--cleanup=strip");
971         if ((flags & EDIT_MSG))
972                 argv_array_push(&cmd.args, "-e");
973         else if (!(flags & CLEANUP_MSG) &&
974                  !opts->signoff && !opts->record_origin &&
975                  git_config_get_value("commit.cleanup", &value))
976                 argv_array_push(&cmd.args, "--cleanup=verbatim");
977
978         if ((flags & ALLOW_EMPTY))
979                 argv_array_push(&cmd.args, "--allow-empty");
980
981         if (!(flags & EDIT_MSG))
982                 argv_array_push(&cmd.args, "--allow-empty-message");
983
984         if (is_rebase_i(opts) && !(flags & EDIT_MSG))
985                 return run_command_silent_on_success(&cmd);
986         else
987                 return run_command(&cmd);
988 }
989
990 static int rest_is_empty(const struct strbuf *sb, int start)
991 {
992         int i, eol;
993         const char *nl;
994
995         /* Check if the rest is just whitespace and Signed-off-by's. */
996         for (i = start; i < sb->len; i++) {
997                 nl = memchr(sb->buf + i, '\n', sb->len - i);
998                 if (nl)
999                         eol = nl - sb->buf;
1000                 else
1001                         eol = sb->len;
1002
1003                 if (strlen(sign_off_header) <= eol - i &&
1004                     starts_with(sb->buf + i, sign_off_header)) {
1005                         i = eol;
1006                         continue;
1007                 }
1008                 while (i < eol)
1009                         if (!isspace(sb->buf[i++]))
1010                                 return 0;
1011         }
1012
1013         return 1;
1014 }
1015
1016 /*
1017  * Find out if the message in the strbuf contains only whitespace and
1018  * Signed-off-by lines.
1019  */
1020 int message_is_empty(const struct strbuf *sb,
1021                      enum commit_msg_cleanup_mode cleanup_mode)
1022 {
1023         if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1024                 return 0;
1025         return rest_is_empty(sb, 0);
1026 }
1027
1028 /*
1029  * See if the user edited the message in the editor or left what
1030  * was in the template intact
1031  */
1032 int template_untouched(const struct strbuf *sb, const char *template_file,
1033                        enum commit_msg_cleanup_mode cleanup_mode)
1034 {
1035         struct strbuf tmpl = STRBUF_INIT;
1036         const char *start;
1037
1038         if (cleanup_mode == COMMIT_MSG_CLEANUP_NONE && sb->len)
1039                 return 0;
1040
1041         if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1042                 return 0;
1043
1044         strbuf_stripspace(&tmpl, cleanup_mode == COMMIT_MSG_CLEANUP_ALL);
1045         if (!skip_prefix(sb->buf, tmpl.buf, &start))
1046                 start = sb->buf;
1047         strbuf_release(&tmpl);
1048         return rest_is_empty(sb, start - sb->buf);
1049 }
1050
1051 int update_head_with_reflog(const struct commit *old_head,
1052                             const struct object_id *new_head,
1053                             const char *action, const struct strbuf *msg,
1054                             struct strbuf *err)
1055 {
1056         struct ref_transaction *transaction;
1057         struct strbuf sb = STRBUF_INIT;
1058         const char *nl;
1059         int ret = 0;
1060
1061         if (action) {
1062                 strbuf_addstr(&sb, action);
1063                 strbuf_addstr(&sb, ": ");
1064         }
1065
1066         nl = strchr(msg->buf, '\n');
1067         if (nl) {
1068                 strbuf_add(&sb, msg->buf, nl + 1 - msg->buf);
1069         } else {
1070                 strbuf_addbuf(&sb, msg);
1071                 strbuf_addch(&sb, '\n');
1072         }
1073
1074         transaction = ref_transaction_begin(err);
1075         if (!transaction ||
1076             ref_transaction_update(transaction, "HEAD", new_head,
1077                                    old_head ? &old_head->object.oid : &null_oid,
1078                                    0, sb.buf, err) ||
1079             ref_transaction_commit(transaction, err)) {
1080                 ret = -1;
1081         }
1082         ref_transaction_free(transaction);
1083         strbuf_release(&sb);
1084
1085         return ret;
1086 }
1087
1088 static int run_rewrite_hook(const struct object_id *oldoid,
1089                             const struct object_id *newoid)
1090 {
1091         struct child_process proc = CHILD_PROCESS_INIT;
1092         const char *argv[3];
1093         int code;
1094         struct strbuf sb = STRBUF_INIT;
1095
1096         argv[0] = find_hook("post-rewrite");
1097         if (!argv[0])
1098                 return 0;
1099
1100         argv[1] = "amend";
1101         argv[2] = NULL;
1102
1103         proc.argv = argv;
1104         proc.in = -1;
1105         proc.stdout_to_stderr = 1;
1106
1107         code = start_command(&proc);
1108         if (code)
1109                 return code;
1110         strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1111         sigchain_push(SIGPIPE, SIG_IGN);
1112         write_in_full(proc.in, sb.buf, sb.len);
1113         close(proc.in);
1114         strbuf_release(&sb);
1115         sigchain_pop(SIGPIPE);
1116         return finish_command(&proc);
1117 }
1118
1119 void commit_post_rewrite(struct repository *r,
1120                          const struct commit *old_head,
1121                          const struct object_id *new_head)
1122 {
1123         struct notes_rewrite_cfg *cfg;
1124
1125         cfg = init_copy_notes_for_rewrite("amend");
1126         if (cfg) {
1127                 /* we are amending, so old_head is not NULL */
1128                 copy_note_for_rewrite(cfg, &old_head->object.oid, new_head);
1129                 finish_copy_notes_for_rewrite(r, cfg, "Notes added by 'git commit --amend'");
1130         }
1131         run_rewrite_hook(&old_head->object.oid, new_head);
1132 }
1133
1134 static int run_prepare_commit_msg_hook(struct repository *r,
1135                                        struct strbuf *msg,
1136                                        const char *commit)
1137 {
1138         struct argv_array hook_env = ARGV_ARRAY_INIT;
1139         int ret;
1140         const char *name;
1141
1142         name = git_path_commit_editmsg();
1143         if (write_message(msg->buf, msg->len, name, 0))
1144                 return -1;
1145
1146         argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", r->index_file);
1147         argv_array_push(&hook_env, "GIT_EDITOR=:");
1148         if (commit)
1149                 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1150                                   "commit", commit, NULL);
1151         else
1152                 ret = run_hook_le(hook_env.argv, "prepare-commit-msg", name,
1153                                   "message", NULL);
1154         if (ret)
1155                 ret = error(_("'prepare-commit-msg' hook failed"));
1156         argv_array_clear(&hook_env);
1157
1158         return ret;
1159 }
1160
1161 static const char implicit_ident_advice_noconfig[] =
1162 N_("Your name and email address were configured automatically based\n"
1163 "on your username and hostname. Please check that they are accurate.\n"
1164 "You can suppress this message by setting them explicitly. Run the\n"
1165 "following command and follow the instructions in your editor to edit\n"
1166 "your configuration file:\n"
1167 "\n"
1168 "    git config --global --edit\n"
1169 "\n"
1170 "After doing this, you may fix the identity used for this commit with:\n"
1171 "\n"
1172 "    git commit --amend --reset-author\n");
1173
1174 static const char implicit_ident_advice_config[] =
1175 N_("Your name and email address were configured automatically based\n"
1176 "on your username and hostname. Please check that they are accurate.\n"
1177 "You can suppress this message by setting them explicitly:\n"
1178 "\n"
1179 "    git config --global user.name \"Your Name\"\n"
1180 "    git config --global user.email you@example.com\n"
1181 "\n"
1182 "After doing this, you may fix the identity used for this commit with:\n"
1183 "\n"
1184 "    git commit --amend --reset-author\n");
1185
1186 static const char *implicit_ident_advice(void)
1187 {
1188         char *user_config = expand_user_path("~/.gitconfig", 0);
1189         char *xdg_config = xdg_config_home("config");
1190         int config_exists = file_exists(user_config) || file_exists(xdg_config);
1191
1192         free(user_config);
1193         free(xdg_config);
1194
1195         if (config_exists)
1196                 return _(implicit_ident_advice_config);
1197         else
1198                 return _(implicit_ident_advice_noconfig);
1199
1200 }
1201
1202 void print_commit_summary(struct repository *r,
1203                           const char *prefix,
1204                           const struct object_id *oid,
1205                           unsigned int flags)
1206 {
1207         struct rev_info rev;
1208         struct commit *commit;
1209         struct strbuf format = STRBUF_INIT;
1210         const char *head;
1211         struct pretty_print_context pctx = {0};
1212         struct strbuf author_ident = STRBUF_INIT;
1213         struct strbuf committer_ident = STRBUF_INIT;
1214
1215         commit = lookup_commit(r, oid);
1216         if (!commit)
1217                 die(_("couldn't look up newly created commit"));
1218         if (parse_commit(commit))
1219                 die(_("could not parse newly created commit"));
1220
1221         strbuf_addstr(&format, "format:%h] %s");
1222
1223         format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1224         format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1225         if (strbuf_cmp(&author_ident, &committer_ident)) {
1226                 strbuf_addstr(&format, "\n Author: ");
1227                 strbuf_addbuf_percentquote(&format, &author_ident);
1228         }
1229         if (flags & SUMMARY_SHOW_AUTHOR_DATE) {
1230                 struct strbuf date = STRBUF_INIT;
1231
1232                 format_commit_message(commit, "%ad", &date, &pctx);
1233                 strbuf_addstr(&format, "\n Date: ");
1234                 strbuf_addbuf_percentquote(&format, &date);
1235                 strbuf_release(&date);
1236         }
1237         if (!committer_ident_sufficiently_given()) {
1238                 strbuf_addstr(&format, "\n Committer: ");
1239                 strbuf_addbuf_percentquote(&format, &committer_ident);
1240                 if (advice_implicit_identity) {
1241                         strbuf_addch(&format, '\n');
1242                         strbuf_addstr(&format, implicit_ident_advice());
1243                 }
1244         }
1245         strbuf_release(&author_ident);
1246         strbuf_release(&committer_ident);
1247
1248         repo_init_revisions(r, &rev, prefix);
1249         setup_revisions(0, NULL, &rev, NULL);
1250
1251         rev.diff = 1;
1252         rev.diffopt.output_format =
1253                 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1254
1255         rev.verbose_header = 1;
1256         rev.show_root_diff = 1;
1257         get_commit_format(format.buf, &rev);
1258         rev.always_show_header = 0;
1259         rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1260         rev.diffopt.break_opt = 0;
1261         diff_setup_done(&rev.diffopt);
1262
1263         head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1264         if (!head)
1265                 die_errno(_("unable to resolve HEAD after creating commit"));
1266         if (!strcmp(head, "HEAD"))
1267                 head = _("detached HEAD");
1268         else
1269                 skip_prefix(head, "refs/heads/", &head);
1270         printf("[%s%s ", head, (flags & SUMMARY_INITIAL_COMMIT) ?
1271                                                 _(" (root-commit)") : "");
1272
1273         if (!log_tree_commit(&rev, commit)) {
1274                 rev.always_show_header = 1;
1275                 rev.use_terminator = 1;
1276                 log_tree_commit(&rev, commit);
1277         }
1278
1279         strbuf_release(&format);
1280 }
1281
1282 static int parse_head(struct repository *r, struct commit **head)
1283 {
1284         struct commit *current_head;
1285         struct object_id oid;
1286
1287         if (get_oid("HEAD", &oid)) {
1288                 current_head = NULL;
1289         } else {
1290                 current_head = lookup_commit_reference(r, &oid);
1291                 if (!current_head)
1292                         return error(_("could not parse HEAD"));
1293                 if (!oideq(&oid, &current_head->object.oid)) {
1294                         warning(_("HEAD %s is not a commit!"),
1295                                 oid_to_hex(&oid));
1296                 }
1297                 if (parse_commit(current_head))
1298                         return error(_("could not parse HEAD commit"));
1299         }
1300         *head = current_head;
1301
1302         return 0;
1303 }
1304
1305 /*
1306  * Try to commit without forking 'git commit'. In some cases we need
1307  * to run 'git commit' to display an error message
1308  *
1309  * Returns:
1310  *  -1 - error unable to commit
1311  *   0 - success
1312  *   1 - run 'git commit'
1313  */
1314 static int try_to_commit(struct repository *r,
1315                          struct strbuf *msg, const char *author,
1316                          struct replay_opts *opts, unsigned int flags,
1317                          struct object_id *oid)
1318 {
1319         struct object_id tree;
1320         struct commit *current_head;
1321         struct commit_list *parents = NULL;
1322         struct commit_extra_header *extra = NULL;
1323         struct strbuf err = STRBUF_INIT;
1324         struct strbuf commit_msg = STRBUF_INIT;
1325         char *amend_author = NULL;
1326         const char *hook_commit = NULL;
1327         enum commit_msg_cleanup_mode cleanup;
1328         int res = 0;
1329
1330         if (parse_head(r, &current_head))
1331                 return -1;
1332
1333         if (flags & AMEND_MSG) {
1334                 const char *exclude_gpgsig[] = { "gpgsig", NULL };
1335                 const char *out_enc = get_commit_output_encoding();
1336                 const char *message = logmsg_reencode(current_head, NULL,
1337                                                       out_enc);
1338
1339                 if (!msg) {
1340                         const char *orig_message = NULL;
1341
1342                         find_commit_subject(message, &orig_message);
1343                         msg = &commit_msg;
1344                         strbuf_addstr(msg, orig_message);
1345                         hook_commit = "HEAD";
1346                 }
1347                 author = amend_author = get_author(message);
1348                 unuse_commit_buffer(current_head, message);
1349                 if (!author) {
1350                         res = error(_("unable to parse commit author"));
1351                         goto out;
1352                 }
1353                 parents = copy_commit_list(current_head->parents);
1354                 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1355         } else if (current_head) {
1356                 commit_list_insert(current_head, &parents);
1357         }
1358
1359         if (write_index_as_tree(&tree, r->index, r->index_file, 0, NULL)) {
1360                 res = error(_("git write-tree failed to write a tree"));
1361                 goto out;
1362         }
1363
1364         if (!(flags & ALLOW_EMPTY) && oideq(current_head ?
1365                                             get_commit_tree_oid(current_head) :
1366                                             the_hash_algo->empty_tree, &tree)) {
1367                 res = 1; /* run 'git commit' to display error message */
1368                 goto out;
1369         }
1370
1371         if (find_hook("prepare-commit-msg")) {
1372                 res = run_prepare_commit_msg_hook(r, msg, hook_commit);
1373                 if (res)
1374                         goto out;
1375                 if (strbuf_read_file(&commit_msg, git_path_commit_editmsg(),
1376                                      2048) < 0) {
1377                         res = error_errno(_("unable to read commit message "
1378                                               "from '%s'"),
1379                                             git_path_commit_editmsg());
1380                         goto out;
1381                 }
1382                 msg = &commit_msg;
1383         }
1384
1385         cleanup = (flags & CLEANUP_MSG) ? COMMIT_MSG_CLEANUP_ALL :
1386                                           opts->default_msg_cleanup;
1387
1388         if (cleanup != COMMIT_MSG_CLEANUP_NONE)
1389                 strbuf_stripspace(msg, cleanup == COMMIT_MSG_CLEANUP_ALL);
1390         if ((flags & EDIT_MSG) && message_is_empty(msg, cleanup)) {
1391                 res = 1; /* run 'git commit' to display error message */
1392                 goto out;
1393         }
1394
1395         reset_ident_date();
1396
1397         if (commit_tree_extended(msg->buf, msg->len, &tree, parents,
1398                                  oid, author, opts->gpg_sign, extra)) {
1399                 res = error(_("failed to write commit object"));
1400                 goto out;
1401         }
1402
1403         if (update_head_with_reflog(current_head, oid,
1404                                     getenv("GIT_REFLOG_ACTION"), msg, &err)) {
1405                 res = error("%s", err.buf);
1406                 goto out;
1407         }
1408
1409         if (flags & AMEND_MSG)
1410                 commit_post_rewrite(r, current_head, oid);
1411
1412 out:
1413         free_commit_extra_headers(extra);
1414         strbuf_release(&err);
1415         strbuf_release(&commit_msg);
1416         free(amend_author);
1417
1418         return res;
1419 }
1420
1421 static int do_commit(struct repository *r,
1422                      const char *msg_file, const char *author,
1423                      struct replay_opts *opts, unsigned int flags)
1424 {
1425         int res = 1;
1426
1427         if (!(flags & EDIT_MSG) && !(flags & VERIFY_MSG) &&
1428             !(flags & CREATE_ROOT_COMMIT)) {
1429                 struct object_id oid;
1430                 struct strbuf sb = STRBUF_INIT;
1431
1432                 if (msg_file && strbuf_read_file(&sb, msg_file, 2048) < 0)
1433                         return error_errno(_("unable to read commit message "
1434                                              "from '%s'"),
1435                                            msg_file);
1436
1437                 res = try_to_commit(r, msg_file ? &sb : NULL,
1438                                     author, opts, flags, &oid);
1439                 strbuf_release(&sb);
1440                 if (!res) {
1441                         unlink(git_path_cherry_pick_head(r));
1442                         unlink(git_path_merge_msg(r));
1443                         if (!is_rebase_i(opts))
1444                                 print_commit_summary(r, NULL, &oid,
1445                                                 SUMMARY_SHOW_AUTHOR_DATE);
1446                         return res;
1447                 }
1448         }
1449         if (res == 1)
1450                 return run_git_commit(r, msg_file, opts, flags);
1451
1452         return res;
1453 }
1454
1455 static int is_original_commit_empty(struct commit *commit)
1456 {
1457         const struct object_id *ptree_oid;
1458
1459         if (parse_commit(commit))
1460                 return error(_("could not parse commit %s"),
1461                              oid_to_hex(&commit->object.oid));
1462         if (commit->parents) {
1463                 struct commit *parent = commit->parents->item;
1464                 if (parse_commit(parent))
1465                         return error(_("could not parse parent commit %s"),
1466                                 oid_to_hex(&parent->object.oid));
1467                 ptree_oid = get_commit_tree_oid(parent);
1468         } else {
1469                 ptree_oid = the_hash_algo->empty_tree; /* commit is root */
1470         }
1471
1472         return oideq(ptree_oid, get_commit_tree_oid(commit));
1473 }
1474
1475 /*
1476  * Do we run "git commit" with "--allow-empty"?
1477  */
1478 static int allow_empty(struct repository *r,
1479                        struct replay_opts *opts,
1480                        struct commit *commit)
1481 {
1482         int index_unchanged, empty_commit;
1483
1484         /*
1485          * Three cases:
1486          *
1487          * (1) we do not allow empty at all and error out.
1488          *
1489          * (2) we allow ones that were initially empty, but
1490          * forbid the ones that become empty;
1491          *
1492          * (3) we allow both.
1493          */
1494         if (!opts->allow_empty)
1495                 return 0; /* let "git commit" barf as necessary */
1496
1497         index_unchanged = is_index_unchanged(r);
1498         if (index_unchanged < 0)
1499                 return index_unchanged;
1500         if (!index_unchanged)
1501                 return 0; /* we do not have to say --allow-empty */
1502
1503         if (opts->keep_redundant_commits)
1504                 return 1;
1505
1506         empty_commit = is_original_commit_empty(commit);
1507         if (empty_commit < 0)
1508                 return empty_commit;
1509         if (!empty_commit)
1510                 return 0;
1511         else
1512                 return 1;
1513 }
1514
1515 /*
1516  * Note that ordering matters in this enum. Not only must it match the mapping
1517  * below, it is also divided into several sections that matter.  When adding
1518  * new commands, make sure you add it in the right section.
1519  */
1520 enum todo_command {
1521         /* commands that handle commits */
1522         TODO_PICK = 0,
1523         TODO_REVERT,
1524         TODO_EDIT,
1525         TODO_REWORD,
1526         TODO_FIXUP,
1527         TODO_SQUASH,
1528         /* commands that do something else than handling a single commit */
1529         TODO_EXEC,
1530         TODO_BREAK,
1531         TODO_LABEL,
1532         TODO_RESET,
1533         TODO_MERGE,
1534         /* commands that do nothing but are counted for reporting progress */
1535         TODO_NOOP,
1536         TODO_DROP,
1537         /* comments (not counted for reporting progress) */
1538         TODO_COMMENT
1539 };
1540
1541 static struct {
1542         char c;
1543         const char *str;
1544 } todo_command_info[] = {
1545         { 'p', "pick" },
1546         { 0,   "revert" },
1547         { 'e', "edit" },
1548         { 'r', "reword" },
1549         { 'f', "fixup" },
1550         { 's', "squash" },
1551         { 'x', "exec" },
1552         { 'b', "break" },
1553         { 'l', "label" },
1554         { 't', "reset" },
1555         { 'm', "merge" },
1556         { 0,   "noop" },
1557         { 'd', "drop" },
1558         { 0,   NULL }
1559 };
1560
1561 static const char *command_to_string(const enum todo_command command)
1562 {
1563         if (command < TODO_COMMENT)
1564                 return todo_command_info[command].str;
1565         die(_("unknown command: %d"), command);
1566 }
1567
1568 static char command_to_char(const enum todo_command command)
1569 {
1570         if (command < TODO_COMMENT && todo_command_info[command].c)
1571                 return todo_command_info[command].c;
1572         return comment_line_char;
1573 }
1574
1575 static int is_noop(const enum todo_command command)
1576 {
1577         return TODO_NOOP <= command;
1578 }
1579
1580 static int is_fixup(enum todo_command command)
1581 {
1582         return command == TODO_FIXUP || command == TODO_SQUASH;
1583 }
1584
1585 /* Does this command create a (non-merge) commit? */
1586 static int is_pick_or_similar(enum todo_command command)
1587 {
1588         switch (command) {
1589         case TODO_PICK:
1590         case TODO_REVERT:
1591         case TODO_EDIT:
1592         case TODO_REWORD:
1593         case TODO_FIXUP:
1594         case TODO_SQUASH:
1595                 return 1;
1596         default:
1597                 return 0;
1598         }
1599 }
1600
1601 static int update_squash_messages(struct repository *r,
1602                                   enum todo_command command,
1603                                   struct commit *commit,
1604                                   struct replay_opts *opts)
1605 {
1606         struct strbuf buf = STRBUF_INIT;
1607         int res;
1608         const char *message, *body;
1609
1610         if (opts->current_fixup_count > 0) {
1611                 struct strbuf header = STRBUF_INIT;
1612                 char *eol;
1613
1614                 if (strbuf_read_file(&buf, rebase_path_squash_msg(), 9) <= 0)
1615                         return error(_("could not read '%s'"),
1616                                 rebase_path_squash_msg());
1617
1618                 eol = buf.buf[0] != comment_line_char ?
1619                         buf.buf : strchrnul(buf.buf, '\n');
1620
1621                 strbuf_addf(&header, "%c ", comment_line_char);
1622                 strbuf_addf(&header, _("This is a combination of %d commits."),
1623                             opts->current_fixup_count + 2);
1624                 strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
1625                 strbuf_release(&header);
1626         } else {
1627                 struct object_id head;
1628                 struct commit *head_commit;
1629                 const char *head_message, *body;
1630
1631                 if (get_oid("HEAD", &head))
1632                         return error(_("need a HEAD to fixup"));
1633                 if (!(head_commit = lookup_commit_reference(r, &head)))
1634                         return error(_("could not read HEAD"));
1635                 if (!(head_message = get_commit_buffer(head_commit, NULL)))
1636                         return error(_("could not read HEAD's commit message"));
1637
1638                 find_commit_subject(head_message, &body);
1639                 if (write_message(body, strlen(body),
1640                                   rebase_path_fixup_msg(), 0)) {
1641                         unuse_commit_buffer(head_commit, head_message);
1642                         return error(_("cannot write '%s'"),
1643                                      rebase_path_fixup_msg());
1644                 }
1645
1646                 strbuf_addf(&buf, "%c ", comment_line_char);
1647                 strbuf_addf(&buf, _("This is a combination of %d commits."), 2);
1648                 strbuf_addf(&buf, "\n%c ", comment_line_char);
1649                 strbuf_addstr(&buf, _("This is the 1st commit message:"));
1650                 strbuf_addstr(&buf, "\n\n");
1651                 strbuf_addstr(&buf, body);
1652
1653                 unuse_commit_buffer(head_commit, head_message);
1654         }
1655
1656         if (!(message = get_commit_buffer(commit, NULL)))
1657                 return error(_("could not read commit message of %s"),
1658                              oid_to_hex(&commit->object.oid));
1659         find_commit_subject(message, &body);
1660
1661         if (command == TODO_SQUASH) {
1662                 unlink(rebase_path_fixup_msg());
1663                 strbuf_addf(&buf, "\n%c ", comment_line_char);
1664                 strbuf_addf(&buf, _("This is the commit message #%d:"),
1665                             ++opts->current_fixup_count + 1);
1666                 strbuf_addstr(&buf, "\n\n");
1667                 strbuf_addstr(&buf, body);
1668         } else if (command == TODO_FIXUP) {
1669                 strbuf_addf(&buf, "\n%c ", comment_line_char);
1670                 strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
1671                             ++opts->current_fixup_count + 1);
1672                 strbuf_addstr(&buf, "\n\n");
1673                 strbuf_add_commented_lines(&buf, body, strlen(body));
1674         } else
1675                 return error(_("unknown command: %d"), command);
1676         unuse_commit_buffer(commit, message);
1677
1678         res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
1679         strbuf_release(&buf);
1680
1681         if (!res) {
1682                 strbuf_addf(&opts->current_fixups, "%s%s %s",
1683                             opts->current_fixups.len ? "\n" : "",
1684                             command_to_string(command),
1685                             oid_to_hex(&commit->object.oid));
1686                 res = write_message(opts->current_fixups.buf,
1687                                     opts->current_fixups.len,
1688                                     rebase_path_current_fixups(), 0);
1689         }
1690
1691         return res;
1692 }
1693
1694 static void flush_rewritten_pending(void)
1695 {
1696         struct strbuf buf = STRBUF_INIT;
1697         struct object_id newoid;
1698         FILE *out;
1699
1700         if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
1701             !get_oid("HEAD", &newoid) &&
1702             (out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
1703                 char *bol = buf.buf, *eol;
1704
1705                 while (*bol) {
1706                         eol = strchrnul(bol, '\n');
1707                         fprintf(out, "%.*s %s\n", (int)(eol - bol),
1708                                         bol, oid_to_hex(&newoid));
1709                         if (!*eol)
1710                                 break;
1711                         bol = eol + 1;
1712                 }
1713                 fclose(out);
1714                 unlink(rebase_path_rewritten_pending());
1715         }
1716         strbuf_release(&buf);
1717 }
1718
1719 static void record_in_rewritten(struct object_id *oid,
1720                 enum todo_command next_command)
1721 {
1722         FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
1723
1724         if (!out)
1725                 return;
1726
1727         fprintf(out, "%s\n", oid_to_hex(oid));
1728         fclose(out);
1729
1730         if (!is_fixup(next_command))
1731                 flush_rewritten_pending();
1732 }
1733
1734 static int do_pick_commit(struct repository *r,
1735                           enum todo_command command,
1736                           struct commit *commit,
1737                           struct replay_opts *opts,
1738                           int final_fixup)
1739 {
1740         unsigned int flags = opts->edit ? EDIT_MSG : 0;
1741         const char *msg_file = opts->edit ? NULL : git_path_merge_msg(r);
1742         struct object_id head;
1743         struct commit *base, *next, *parent;
1744         const char *base_label, *next_label;
1745         char *author = NULL;
1746         struct commit_message msg = { NULL, NULL, NULL, NULL };
1747         struct strbuf msgbuf = STRBUF_INIT;
1748         int res, unborn = 0, allow;
1749
1750         if (opts->no_commit) {
1751                 /*
1752                  * We do not intend to commit immediately.  We just want to
1753                  * merge the differences in, so let's compute the tree
1754                  * that represents the "current" state for merge-recursive
1755                  * to work on.
1756                  */
1757                 if (write_index_as_tree(&head, r->index, r->index_file, 0, NULL))
1758                         return error(_("your index file is unmerged."));
1759         } else {
1760                 unborn = get_oid("HEAD", &head);
1761                 /* Do we want to generate a root commit? */
1762                 if (is_pick_or_similar(command) && opts->have_squash_onto &&
1763                     oideq(&head, &opts->squash_onto)) {
1764                         if (is_fixup(command))
1765                                 return error(_("cannot fixup root commit"));
1766                         flags |= CREATE_ROOT_COMMIT;
1767                         unborn = 1;
1768                 } else if (unborn)
1769                         oidcpy(&head, the_hash_algo->empty_tree);
1770                 if (index_differs_from(r, unborn ? empty_tree_oid_hex() : "HEAD",
1771                                        NULL, 0))
1772                         return error_dirty_index(r, opts);
1773         }
1774         discard_index(r->index);
1775
1776         if (!commit->parents)
1777                 parent = NULL;
1778         else if (commit->parents->next) {
1779                 /* Reverting or cherry-picking a merge commit */
1780                 int cnt;
1781                 struct commit_list *p;
1782
1783                 if (!opts->mainline)
1784                         return error(_("commit %s is a merge but no -m option was given."),
1785                                 oid_to_hex(&commit->object.oid));
1786
1787                 for (cnt = 1, p = commit->parents;
1788                      cnt != opts->mainline && p;
1789                      cnt++)
1790                         p = p->next;
1791                 if (cnt != opts->mainline || !p)
1792                         return error(_("commit %s does not have parent %d"),
1793                                 oid_to_hex(&commit->object.oid), opts->mainline);
1794                 parent = p->item;
1795         } else if (1 < opts->mainline)
1796                 /*
1797                  *  Non-first parent explicitly specified as mainline for
1798                  *  non-merge commit
1799                  */
1800                 return error(_("commit %s does not have parent %d"),
1801                              oid_to_hex(&commit->object.oid), opts->mainline);
1802         else
1803                 parent = commit->parents->item;
1804
1805         if (get_message(commit, &msg) != 0)
1806                 return error(_("cannot get commit message for %s"),
1807                         oid_to_hex(&commit->object.oid));
1808
1809         if (opts->allow_ff && !is_fixup(command) &&
1810             ((parent && oideq(&parent->object.oid, &head)) ||
1811              (!parent && unborn))) {
1812                 if (is_rebase_i(opts))
1813                         write_author_script(msg.message);
1814                 res = fast_forward_to(r, &commit->object.oid, &head, unborn,
1815                         opts);
1816                 if (res || command != TODO_REWORD)
1817                         goto leave;
1818                 flags |= EDIT_MSG | AMEND_MSG | VERIFY_MSG;
1819                 msg_file = NULL;
1820                 goto fast_forward_edit;
1821         }
1822         if (parent && parse_commit(parent) < 0)
1823                 /* TRANSLATORS: The first %s will be a "todo" command like
1824                    "revert" or "pick", the second %s a SHA1. */
1825                 return error(_("%s: cannot parse parent commit %s"),
1826                         command_to_string(command),
1827                         oid_to_hex(&parent->object.oid));
1828
1829         /*
1830          * "commit" is an existing commit.  We would want to apply
1831          * the difference it introduces since its first parent "prev"
1832          * on top of the current HEAD if we are cherry-pick.  Or the
1833          * reverse of it if we are revert.
1834          */
1835
1836         if (command == TODO_REVERT) {
1837                 base = commit;
1838                 base_label = msg.label;
1839                 next = parent;
1840                 next_label = msg.parent_label;
1841                 strbuf_addstr(&msgbuf, "Revert \"");
1842                 strbuf_addstr(&msgbuf, msg.subject);
1843                 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
1844                 strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1845
1846                 if (commit->parents && commit->parents->next) {
1847                         strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
1848                         strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
1849                 }
1850                 strbuf_addstr(&msgbuf, ".\n");
1851         } else {
1852                 const char *p;
1853
1854                 base = parent;
1855                 base_label = msg.parent_label;
1856                 next = commit;
1857                 next_label = msg.label;
1858
1859                 /* Append the commit log message to msgbuf. */
1860                 if (find_commit_subject(msg.message, &p))
1861                         strbuf_addstr(&msgbuf, p);
1862
1863                 if (opts->record_origin) {
1864                         strbuf_complete_line(&msgbuf);
1865                         if (!has_conforming_footer(&msgbuf, NULL, 0))
1866                                 strbuf_addch(&msgbuf, '\n');
1867                         strbuf_addstr(&msgbuf, cherry_picked_prefix);
1868                         strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
1869                         strbuf_addstr(&msgbuf, ")\n");
1870                 }
1871                 if (!is_fixup(command))
1872                         author = get_author(msg.message);
1873         }
1874
1875         if (command == TODO_REWORD)
1876                 flags |= EDIT_MSG | VERIFY_MSG;
1877         else if (is_fixup(command)) {
1878                 if (update_squash_messages(r, command, commit, opts))
1879                         return -1;
1880                 flags |= AMEND_MSG;
1881                 if (!final_fixup)
1882                         msg_file = rebase_path_squash_msg();
1883                 else if (file_exists(rebase_path_fixup_msg())) {
1884                         flags |= CLEANUP_MSG;
1885                         msg_file = rebase_path_fixup_msg();
1886                 } else {
1887                         const char *dest = git_path_squash_msg(r);
1888                         unlink(dest);
1889                         if (copy_file(dest, rebase_path_squash_msg(), 0666))
1890                                 return error(_("could not rename '%s' to '%s'"),
1891                                              rebase_path_squash_msg(), dest);
1892                         unlink(git_path_merge_msg(r));
1893                         msg_file = dest;
1894                         flags |= EDIT_MSG;
1895                 }
1896         }
1897
1898         if (opts->signoff && !is_fixup(command))
1899                 append_signoff(&msgbuf, 0, 0);
1900
1901         if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
1902                 res = -1;
1903         else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
1904                 res = do_recursive_merge(r, base, next, base_label, next_label,
1905                                          &head, &msgbuf, opts);
1906                 if (res < 0)
1907                         goto leave;
1908
1909                 res |= write_message(msgbuf.buf, msgbuf.len,
1910                                      git_path_merge_msg(r), 0);
1911         } else {
1912                 struct commit_list *common = NULL;
1913                 struct commit_list *remotes = NULL;
1914
1915                 res = write_message(msgbuf.buf, msgbuf.len,
1916                                     git_path_merge_msg(r), 0);
1917
1918                 commit_list_insert(base, &common);
1919                 commit_list_insert(next, &remotes);
1920                 res |= try_merge_command(r, opts->strategy,
1921                                          opts->xopts_nr, (const char **)opts->xopts,
1922                                         common, oid_to_hex(&head), remotes);
1923                 free_commit_list(common);
1924                 free_commit_list(remotes);
1925         }
1926         strbuf_release(&msgbuf);
1927
1928         /*
1929          * If the merge was clean or if it failed due to conflict, we write
1930          * CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
1931          * However, if the merge did not even start, then we don't want to
1932          * write it at all.
1933          */
1934         if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
1935             update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
1936                        REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1937                 res = -1;
1938         if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
1939             update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
1940                        REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
1941                 res = -1;
1942
1943         if (res) {
1944                 error(command == TODO_REVERT
1945                       ? _("could not revert %s... %s")
1946                       : _("could not apply %s... %s"),
1947                       short_commit_name(commit), msg.subject);
1948                 print_advice(r, res == 1, opts);
1949                 repo_rerere(r, opts->allow_rerere_auto);
1950                 goto leave;
1951         }
1952
1953         allow = allow_empty(r, opts, commit);
1954         if (allow < 0) {
1955                 res = allow;
1956                 goto leave;
1957         } else if (allow)
1958                 flags |= ALLOW_EMPTY;
1959         if (!opts->no_commit) {
1960 fast_forward_edit:
1961                 if (author || command == TODO_REVERT || (flags & AMEND_MSG))
1962                         res = do_commit(r, msg_file, author, opts, flags);
1963                 else
1964                         res = error(_("unable to parse commit author"));
1965         }
1966
1967         if (!res && final_fixup) {
1968                 unlink(rebase_path_fixup_msg());
1969                 unlink(rebase_path_squash_msg());
1970                 unlink(rebase_path_current_fixups());
1971                 strbuf_reset(&opts->current_fixups);
1972                 opts->current_fixup_count = 0;
1973         }
1974
1975 leave:
1976         free_message(commit, &msg);
1977         free(author);
1978         update_abort_safety_file();
1979
1980         return res;
1981 }
1982
1983 static int prepare_revs(struct replay_opts *opts)
1984 {
1985         /*
1986          * picking (but not reverting) ranges (but not individual revisions)
1987          * should be done in reverse
1988          */
1989         if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
1990                 opts->revs->reverse ^= 1;
1991
1992         if (prepare_revision_walk(opts->revs))
1993                 return error(_("revision walk setup failed"));
1994
1995         return 0;
1996 }
1997
1998 static int read_and_refresh_cache(struct repository *r,
1999                                   struct replay_opts *opts)
2000 {
2001         struct lock_file index_lock = LOCK_INIT;
2002         int index_fd = repo_hold_locked_index(r, &index_lock, 0);
2003         if (repo_read_index(r) < 0) {
2004                 rollback_lock_file(&index_lock);
2005                 return error(_("git %s: failed to read the index"),
2006                         _(action_name(opts)));
2007         }
2008         refresh_index(r->index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
2009         if (index_fd >= 0) {
2010                 if (write_locked_index(r->index, &index_lock,
2011                                        COMMIT_LOCK | SKIP_IF_UNCHANGED)) {
2012                         return error(_("git %s: failed to refresh the index"),
2013                                 _(action_name(opts)));
2014                 }
2015         }
2016         return 0;
2017 }
2018
2019 enum todo_item_flags {
2020         TODO_EDIT_MERGE_MSG = 1
2021 };
2022
2023 struct todo_item {
2024         enum todo_command command;
2025         struct commit *commit;
2026         unsigned int flags;
2027         const char *arg;
2028         int arg_len;
2029         size_t offset_in_buf;
2030 };
2031
2032 struct todo_list {
2033         struct strbuf buf;
2034         struct todo_item *items;
2035         int nr, alloc, current;
2036         int done_nr, total_nr;
2037         struct stat_data stat;
2038 };
2039
2040 #define TODO_LIST_INIT { STRBUF_INIT }
2041
2042 static void todo_list_release(struct todo_list *todo_list)
2043 {
2044         strbuf_release(&todo_list->buf);
2045         FREE_AND_NULL(todo_list->items);
2046         todo_list->nr = todo_list->alloc = 0;
2047 }
2048
2049 static struct todo_item *append_new_todo(struct todo_list *todo_list)
2050 {
2051         ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
2052         return todo_list->items + todo_list->nr++;
2053 }
2054
2055 static int parse_insn_line(struct repository *r, struct todo_item *item,
2056                            const char *bol, char *eol)
2057 {
2058         struct object_id commit_oid;
2059         char *end_of_object_name;
2060         int i, saved, status, padding;
2061
2062         item->flags = 0;
2063
2064         /* left-trim */
2065         bol += strspn(bol, " \t");
2066
2067         if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
2068                 item->command = TODO_COMMENT;
2069                 item->commit = NULL;
2070                 item->arg = bol;
2071                 item->arg_len = eol - bol;
2072                 return 0;
2073         }
2074
2075         for (i = 0; i < TODO_COMMENT; i++)
2076                 if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
2077                         item->command = i;
2078                         break;
2079                 } else if ((bol + 1 == eol || bol[1] == ' ') &&
2080                            *bol == todo_command_info[i].c) {
2081                         bol++;
2082                         item->command = i;
2083                         break;
2084                 }
2085         if (i >= TODO_COMMENT)
2086                 return -1;
2087
2088         /* Eat up extra spaces/ tabs before object name */
2089         padding = strspn(bol, " \t");
2090         bol += padding;
2091
2092         if (item->command == TODO_NOOP || item->command == TODO_BREAK) {
2093                 if (bol != eol)
2094                         return error(_("%s does not accept arguments: '%s'"),
2095                                      command_to_string(item->command), bol);
2096                 item->commit = NULL;
2097                 item->arg = bol;
2098                 item->arg_len = eol - bol;
2099                 return 0;
2100         }
2101
2102         if (!padding)
2103                 return error(_("missing arguments for %s"),
2104                              command_to_string(item->command));
2105
2106         if (item->command == TODO_EXEC || item->command == TODO_LABEL ||
2107             item->command == TODO_RESET) {
2108                 item->commit = NULL;
2109                 item->arg = bol;
2110                 item->arg_len = (int)(eol - bol);
2111                 return 0;
2112         }
2113
2114         if (item->command == TODO_MERGE) {
2115                 if (skip_prefix(bol, "-C", &bol))
2116                         bol += strspn(bol, " \t");
2117                 else if (skip_prefix(bol, "-c", &bol)) {
2118                         bol += strspn(bol, " \t");
2119                         item->flags |= TODO_EDIT_MERGE_MSG;
2120                 } else {
2121                         item->flags |= TODO_EDIT_MERGE_MSG;
2122                         item->commit = NULL;
2123                         item->arg = bol;
2124                         item->arg_len = (int)(eol - bol);
2125                         return 0;
2126                 }
2127         }
2128
2129         end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
2130         saved = *end_of_object_name;
2131         *end_of_object_name = '\0';
2132         status = get_oid(bol, &commit_oid);
2133         *end_of_object_name = saved;
2134
2135         item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
2136         item->arg_len = (int)(eol - item->arg);
2137
2138         if (status < 0)
2139                 return -1;
2140
2141         item->commit = lookup_commit_reference(r, &commit_oid);
2142         return !item->commit;
2143 }
2144
2145 static int parse_insn_buffer(struct repository *r, char *buf,
2146                              struct todo_list *todo_list)
2147 {
2148         struct todo_item *item;
2149         char *p = buf, *next_p;
2150         int i, res = 0, fixup_okay = file_exists(rebase_path_done());
2151
2152         for (i = 1; *p; i++, p = next_p) {
2153                 char *eol = strchrnul(p, '\n');
2154
2155                 next_p = *eol ? eol + 1 /* skip LF */ : eol;
2156
2157                 if (p != eol && eol[-1] == '\r')
2158                         eol--; /* strip Carriage Return */
2159
2160                 item = append_new_todo(todo_list);
2161                 item->offset_in_buf = p - todo_list->buf.buf;
2162                 if (parse_insn_line(r, item, p, eol)) {
2163                         res = error(_("invalid line %d: %.*s"),
2164                                 i, (int)(eol - p), p);
2165                         item->command = TODO_NOOP;
2166                 }
2167
2168                 if (fixup_okay)
2169                         ; /* do nothing */
2170                 else if (is_fixup(item->command))
2171                         return error(_("cannot '%s' without a previous commit"),
2172                                 command_to_string(item->command));
2173                 else if (!is_noop(item->command))
2174                         fixup_okay = 1;
2175         }
2176
2177         return res;
2178 }
2179
2180 static int count_commands(struct todo_list *todo_list)
2181 {
2182         int count = 0, i;
2183
2184         for (i = 0; i < todo_list->nr; i++)
2185                 if (todo_list->items[i].command != TODO_COMMENT)
2186                         count++;
2187
2188         return count;
2189 }
2190
2191 static int get_item_line_offset(struct todo_list *todo_list, int index)
2192 {
2193         return index < todo_list->nr ?
2194                 todo_list->items[index].offset_in_buf : todo_list->buf.len;
2195 }
2196
2197 static const char *get_item_line(struct todo_list *todo_list, int index)
2198 {
2199         return todo_list->buf.buf + get_item_line_offset(todo_list, index);
2200 }
2201
2202 static int get_item_line_length(struct todo_list *todo_list, int index)
2203 {
2204         return get_item_line_offset(todo_list, index + 1)
2205                 -  get_item_line_offset(todo_list, index);
2206 }
2207
2208 static ssize_t strbuf_read_file_or_whine(struct strbuf *sb, const char *path)
2209 {
2210         int fd;
2211         ssize_t len;
2212
2213         fd = open(path, O_RDONLY);
2214         if (fd < 0)
2215                 return error_errno(_("could not open '%s'"), path);
2216         len = strbuf_read(sb, fd, 0);
2217         close(fd);
2218         if (len < 0)
2219                 return error(_("could not read '%s'."), path);
2220         return len;
2221 }
2222
2223 static int read_populate_todo(struct repository *r,
2224                               struct todo_list *todo_list,
2225                               struct replay_opts *opts)
2226 {
2227         struct stat st;
2228         const char *todo_file = get_todo_path(opts);
2229         int res;
2230
2231         strbuf_reset(&todo_list->buf);
2232         if (strbuf_read_file_or_whine(&todo_list->buf, todo_file) < 0)
2233                 return -1;
2234
2235         res = stat(todo_file, &st);
2236         if (res)
2237                 return error(_("could not stat '%s'"), todo_file);
2238         fill_stat_data(&todo_list->stat, &st);
2239
2240         res = parse_insn_buffer(r, todo_list->buf.buf, todo_list);
2241         if (res) {
2242                 if (is_rebase_i(opts))
2243                         return error(_("please fix this using "
2244                                        "'git rebase --edit-todo'."));
2245                 return error(_("unusable instruction sheet: '%s'"), todo_file);
2246         }
2247
2248         if (!todo_list->nr &&
2249             (!is_rebase_i(opts) || !file_exists(rebase_path_done())))
2250                 return error(_("no commits parsed."));
2251
2252         if (!is_rebase_i(opts)) {
2253                 enum todo_command valid =
2254                         opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
2255                 int i;
2256
2257                 for (i = 0; i < todo_list->nr; i++)
2258                         if (valid == todo_list->items[i].command)
2259                                 continue;
2260                         else if (valid == TODO_PICK)
2261                                 return error(_("cannot cherry-pick during a revert."));
2262                         else
2263                                 return error(_("cannot revert during a cherry-pick."));
2264         }
2265
2266         if (is_rebase_i(opts)) {
2267                 struct todo_list done = TODO_LIST_INIT;
2268                 FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
2269
2270                 if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
2271                     !parse_insn_buffer(r, done.buf.buf, &done))
2272                         todo_list->done_nr = count_commands(&done);
2273                 else
2274                         todo_list->done_nr = 0;
2275
2276                 todo_list->total_nr = todo_list->done_nr
2277                         + count_commands(todo_list);
2278                 todo_list_release(&done);
2279
2280                 if (f) {
2281                         fprintf(f, "%d\n", todo_list->total_nr);
2282                         fclose(f);
2283                 }
2284         }
2285
2286         return 0;
2287 }
2288
2289 static int git_config_string_dup(char **dest,
2290                                  const char *var, const char *value)
2291 {
2292         if (!value)
2293                 return config_error_nonbool(var);
2294         free(*dest);
2295         *dest = xstrdup(value);
2296         return 0;
2297 }
2298
2299 static int populate_opts_cb(const char *key, const char *value, void *data)
2300 {
2301         struct replay_opts *opts = data;
2302         int error_flag = 1;
2303
2304         if (!value)
2305                 error_flag = 0;
2306         else if (!strcmp(key, "options.no-commit"))
2307                 opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
2308         else if (!strcmp(key, "options.edit"))
2309                 opts->edit = git_config_bool_or_int(key, value, &error_flag);
2310         else if (!strcmp(key, "options.signoff"))
2311                 opts->signoff = git_config_bool_or_int(key, value, &error_flag);
2312         else if (!strcmp(key, "options.record-origin"))
2313                 opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
2314         else if (!strcmp(key, "options.allow-ff"))
2315                 opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
2316         else if (!strcmp(key, "options.mainline"))
2317                 opts->mainline = git_config_int(key, value);
2318         else if (!strcmp(key, "options.strategy"))
2319                 git_config_string_dup(&opts->strategy, key, value);
2320         else if (!strcmp(key, "options.gpg-sign"))
2321                 git_config_string_dup(&opts->gpg_sign, key, value);
2322         else if (!strcmp(key, "options.strategy-option")) {
2323                 ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
2324                 opts->xopts[opts->xopts_nr++] = xstrdup(value);
2325         } else if (!strcmp(key, "options.allow-rerere-auto"))
2326                 opts->allow_rerere_auto =
2327                         git_config_bool_or_int(key, value, &error_flag) ?
2328                                 RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
2329         else
2330                 return error(_("invalid key: %s"), key);
2331
2332         if (!error_flag)
2333                 return error(_("invalid value for %s: %s"), key, value);
2334
2335         return 0;
2336 }
2337
2338 void parse_strategy_opts(struct replay_opts *opts, char *raw_opts)
2339 {
2340         int i;
2341         char *strategy_opts_string = raw_opts;
2342
2343         if (*strategy_opts_string == ' ')
2344                 strategy_opts_string++;
2345
2346         opts->xopts_nr = split_cmdline(strategy_opts_string,
2347                                        (const char ***)&opts->xopts);
2348         for (i = 0; i < opts->xopts_nr; i++) {
2349                 const char *arg = opts->xopts[i];
2350
2351                 skip_prefix(arg, "--", &arg);
2352                 opts->xopts[i] = xstrdup(arg);
2353         }
2354 }
2355
2356 static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
2357 {
2358         strbuf_reset(buf);
2359         if (!read_oneliner(buf, rebase_path_strategy(), 0))
2360                 return;
2361         opts->strategy = strbuf_detach(buf, NULL);
2362         if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
2363                 return;
2364
2365         parse_strategy_opts(opts, buf->buf);
2366 }
2367
2368 static int read_populate_opts(struct replay_opts *opts)
2369 {
2370         if (is_rebase_i(opts)) {
2371                 struct strbuf buf = STRBUF_INIT;
2372
2373                 if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
2374                         if (!starts_with(buf.buf, "-S"))
2375                                 strbuf_reset(&buf);
2376                         else {
2377                                 free(opts->gpg_sign);
2378                                 opts->gpg_sign = xstrdup(buf.buf + 2);
2379                         }
2380                         strbuf_reset(&buf);
2381                 }
2382
2383                 if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
2384                         if (!strcmp(buf.buf, "--rerere-autoupdate"))
2385                                 opts->allow_rerere_auto = RERERE_AUTOUPDATE;
2386                         else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
2387                                 opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
2388                         strbuf_reset(&buf);
2389                 }
2390
2391                 if (file_exists(rebase_path_verbose()))
2392                         opts->verbose = 1;
2393
2394                 if (file_exists(rebase_path_quiet()))
2395                         opts->quiet = 1;
2396
2397                 if (file_exists(rebase_path_signoff())) {
2398                         opts->allow_ff = 0;
2399                         opts->signoff = 1;
2400                 }
2401
2402                 if (file_exists(rebase_path_reschedule_failed_exec()))
2403                         opts->reschedule_failed_exec = 1;
2404
2405                 read_strategy_opts(opts, &buf);
2406                 strbuf_release(&buf);
2407
2408                 if (read_oneliner(&opts->current_fixups,
2409                                   rebase_path_current_fixups(), 1)) {
2410                         const char *p = opts->current_fixups.buf;
2411                         opts->current_fixup_count = 1;
2412                         while ((p = strchr(p, '\n'))) {
2413                                 opts->current_fixup_count++;
2414                                 p++;
2415                         }
2416                 }
2417
2418                 if (read_oneliner(&buf, rebase_path_squash_onto(), 0)) {
2419                         if (get_oid_hex(buf.buf, &opts->squash_onto) < 0)
2420                                 return error(_("unusable squash-onto"));
2421                         opts->have_squash_onto = 1;
2422                 }
2423
2424                 return 0;
2425         }
2426
2427         if (!file_exists(git_path_opts_file()))
2428                 return 0;
2429         /*
2430          * The function git_parse_source(), called from git_config_from_file(),
2431          * may die() in case of a syntactically incorrect file. We do not care
2432          * about this case, though, because we wrote that file ourselves, so we
2433          * are pretty certain that it is syntactically correct.
2434          */
2435         if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
2436                 return error(_("malformed options sheet: '%s'"),
2437                         git_path_opts_file());
2438         return 0;
2439 }
2440
2441 static void write_strategy_opts(struct replay_opts *opts)
2442 {
2443         int i;
2444         struct strbuf buf = STRBUF_INIT;
2445
2446         for (i = 0; i < opts->xopts_nr; ++i)
2447                 strbuf_addf(&buf, " --%s", opts->xopts[i]);
2448
2449         write_file(rebase_path_strategy_opts(), "%s\n", buf.buf);
2450         strbuf_release(&buf);
2451 }
2452
2453 int write_basic_state(struct replay_opts *opts, const char *head_name,
2454                       const char *onto, const char *orig_head)
2455 {
2456         const char *quiet = getenv("GIT_QUIET");
2457
2458         if (head_name)
2459                 write_file(rebase_path_head_name(), "%s\n", head_name);
2460         if (onto)
2461                 write_file(rebase_path_onto(), "%s\n", onto);
2462         if (orig_head)
2463                 write_file(rebase_path_orig_head(), "%s\n", orig_head);
2464
2465         if (quiet)
2466                 write_file(rebase_path_quiet(), "%s\n", quiet);
2467         if (opts->verbose)
2468                 write_file(rebase_path_verbose(), "%s", "");
2469         if (opts->strategy)
2470                 write_file(rebase_path_strategy(), "%s\n", opts->strategy);
2471         if (opts->xopts_nr > 0)
2472                 write_strategy_opts(opts);
2473
2474         if (opts->allow_rerere_auto == RERERE_AUTOUPDATE)
2475                 write_file(rebase_path_allow_rerere_autoupdate(), "--rerere-autoupdate\n");
2476         else if (opts->allow_rerere_auto == RERERE_NOAUTOUPDATE)
2477                 write_file(rebase_path_allow_rerere_autoupdate(), "--no-rerere-autoupdate\n");
2478
2479         if (opts->gpg_sign)
2480                 write_file(rebase_path_gpg_sign_opt(), "-S%s\n", opts->gpg_sign);
2481         if (opts->signoff)
2482                 write_file(rebase_path_signoff(), "--signoff\n");
2483         if (opts->reschedule_failed_exec)
2484                 write_file(rebase_path_reschedule_failed_exec(), "%s", "");
2485
2486         return 0;
2487 }
2488
2489 static int walk_revs_populate_todo(struct todo_list *todo_list,
2490                                 struct replay_opts *opts)
2491 {
2492         enum todo_command command = opts->action == REPLAY_PICK ?
2493                 TODO_PICK : TODO_REVERT;
2494         const char *command_string = todo_command_info[command].str;
2495         struct commit *commit;
2496
2497         if (prepare_revs(opts))
2498                 return -1;
2499
2500         while ((commit = get_revision(opts->revs))) {
2501                 struct todo_item *item = append_new_todo(todo_list);
2502                 const char *commit_buffer = get_commit_buffer(commit, NULL);
2503                 const char *subject;
2504                 int subject_len;
2505
2506                 item->command = command;
2507                 item->commit = commit;
2508                 item->arg = NULL;
2509                 item->arg_len = 0;
2510                 item->offset_in_buf = todo_list->buf.len;
2511                 subject_len = find_commit_subject(commit_buffer, &subject);
2512                 strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
2513                         short_commit_name(commit), subject_len, subject);
2514                 unuse_commit_buffer(commit, commit_buffer);
2515         }
2516
2517         if (!todo_list->nr)
2518                 return error(_("empty commit set passed"));
2519
2520         return 0;
2521 }
2522
2523 static int create_seq_dir(void)
2524 {
2525         if (file_exists(git_path_seq_dir())) {
2526                 error(_("a cherry-pick or revert is already in progress"));
2527                 advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
2528                 return -1;
2529         } else if (mkdir(git_path_seq_dir(), 0777) < 0)
2530                 return error_errno(_("could not create sequencer directory '%s'"),
2531                                    git_path_seq_dir());
2532         return 0;
2533 }
2534
2535 static int save_head(const char *head)
2536 {
2537         struct lock_file head_lock = LOCK_INIT;
2538         struct strbuf buf = STRBUF_INIT;
2539         int fd;
2540         ssize_t written;
2541
2542         fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
2543         if (fd < 0)
2544                 return error_errno(_("could not lock HEAD"));
2545         strbuf_addf(&buf, "%s\n", head);
2546         written = write_in_full(fd, buf.buf, buf.len);
2547         strbuf_release(&buf);
2548         if (written < 0) {
2549                 error_errno(_("could not write to '%s'"), git_path_head_file());
2550                 rollback_lock_file(&head_lock);
2551                 return -1;
2552         }
2553         if (commit_lock_file(&head_lock) < 0)
2554                 return error(_("failed to finalize '%s'"), git_path_head_file());
2555         return 0;
2556 }
2557
2558 static int rollback_is_safe(void)
2559 {
2560         struct strbuf sb = STRBUF_INIT;
2561         struct object_id expected_head, actual_head;
2562
2563         if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
2564                 strbuf_trim(&sb);
2565                 if (get_oid_hex(sb.buf, &expected_head)) {
2566                         strbuf_release(&sb);
2567                         die(_("could not parse %s"), git_path_abort_safety_file());
2568                 }
2569                 strbuf_release(&sb);
2570         }
2571         else if (errno == ENOENT)
2572                 oidclr(&expected_head);
2573         else
2574                 die_errno(_("could not read '%s'"), git_path_abort_safety_file());
2575
2576         if (get_oid("HEAD", &actual_head))
2577                 oidclr(&actual_head);
2578
2579         return oideq(&actual_head, &expected_head);
2580 }
2581
2582 static int reset_for_rollback(const struct object_id *oid)
2583 {
2584         const char *argv[4];    /* reset --merge <arg> + NULL */
2585
2586         argv[0] = "reset";
2587         argv[1] = "--merge";
2588         argv[2] = oid_to_hex(oid);
2589         argv[3] = NULL;
2590         return run_command_v_opt(argv, RUN_GIT_CMD);
2591 }
2592
2593 static int rollback_single_pick(struct repository *r)
2594 {
2595         struct object_id head_oid;
2596
2597         if (!file_exists(git_path_cherry_pick_head(r)) &&
2598             !file_exists(git_path_revert_head(r)))
2599                 return error(_("no cherry-pick or revert in progress"));
2600         if (read_ref_full("HEAD", 0, &head_oid, NULL))
2601                 return error(_("cannot resolve HEAD"));
2602         if (is_null_oid(&head_oid))
2603                 return error(_("cannot abort from a branch yet to be born"));
2604         return reset_for_rollback(&head_oid);
2605 }
2606
2607 int sequencer_rollback(struct repository *r, struct replay_opts *opts)
2608 {
2609         FILE *f;
2610         struct object_id oid;
2611         struct strbuf buf = STRBUF_INIT;
2612         const char *p;
2613
2614         f = fopen(git_path_head_file(), "r");
2615         if (!f && errno == ENOENT) {
2616                 /*
2617                  * There is no multiple-cherry-pick in progress.
2618                  * If CHERRY_PICK_HEAD or REVERT_HEAD indicates
2619                  * a single-cherry-pick in progress, abort that.
2620                  */
2621                 return rollback_single_pick(r);
2622         }
2623         if (!f)
2624                 return error_errno(_("cannot open '%s'"), git_path_head_file());
2625         if (strbuf_getline_lf(&buf, f)) {
2626                 error(_("cannot read '%s': %s"), git_path_head_file(),
2627                       ferror(f) ?  strerror(errno) : _("unexpected end of file"));
2628                 fclose(f);
2629                 goto fail;
2630         }
2631         fclose(f);
2632         if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
2633                 error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
2634                         git_path_head_file());
2635                 goto fail;
2636         }
2637         if (is_null_oid(&oid)) {
2638                 error(_("cannot abort from a branch yet to be born"));
2639                 goto fail;
2640         }
2641
2642         if (!rollback_is_safe()) {
2643                 /* Do not error, just do not rollback */
2644                 warning(_("You seem to have moved HEAD. "
2645                           "Not rewinding, check your HEAD!"));
2646         } else
2647         if (reset_for_rollback(&oid))
2648                 goto fail;
2649         strbuf_release(&buf);
2650         return sequencer_remove_state(opts);
2651 fail:
2652         strbuf_release(&buf);
2653         return -1;
2654 }
2655
2656 static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
2657 {
2658         struct lock_file todo_lock = LOCK_INIT;
2659         const char *todo_path = get_todo_path(opts);
2660         int next = todo_list->current, offset, fd;
2661
2662         /*
2663          * rebase -i writes "git-rebase-todo" without the currently executing
2664          * command, appending it to "done" instead.
2665          */
2666         if (is_rebase_i(opts))
2667                 next++;
2668
2669         fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
2670         if (fd < 0)
2671                 return error_errno(_("could not lock '%s'"), todo_path);
2672         offset = get_item_line_offset(todo_list, next);
2673         if (write_in_full(fd, todo_list->buf.buf + offset,
2674                         todo_list->buf.len - offset) < 0)
2675                 return error_errno(_("could not write to '%s'"), todo_path);
2676         if (commit_lock_file(&todo_lock) < 0)
2677                 return error(_("failed to finalize '%s'"), todo_path);
2678
2679         if (is_rebase_i(opts) && next > 0) {
2680                 const char *done = rebase_path_done();
2681                 int fd = open(done, O_CREAT | O_WRONLY | O_APPEND, 0666);
2682                 int ret = 0;
2683
2684                 if (fd < 0)
2685                         return 0;
2686                 if (write_in_full(fd, get_item_line(todo_list, next - 1),
2687                                   get_item_line_length(todo_list, next - 1))
2688                     < 0)
2689                         ret = error_errno(_("could not write to '%s'"), done);
2690                 if (close(fd) < 0)
2691                         ret = error_errno(_("failed to finalize '%s'"), done);
2692                 return ret;
2693         }
2694         return 0;
2695 }
2696
2697 static int save_opts(struct replay_opts *opts)
2698 {
2699         const char *opts_file = git_path_opts_file();
2700         int res = 0;
2701
2702         if (opts->no_commit)
2703                 res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
2704         if (opts->edit)
2705                 res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
2706         if (opts->signoff)
2707                 res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
2708         if (opts->record_origin)
2709                 res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
2710         if (opts->allow_ff)
2711                 res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
2712         if (opts->mainline) {
2713                 struct strbuf buf = STRBUF_INIT;
2714                 strbuf_addf(&buf, "%d", opts->mainline);
2715                 res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
2716                 strbuf_release(&buf);
2717         }
2718         if (opts->strategy)
2719                 res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
2720         if (opts->gpg_sign)
2721                 res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
2722         if (opts->xopts) {
2723                 int i;
2724                 for (i = 0; i < opts->xopts_nr; i++)
2725                         res |= git_config_set_multivar_in_file_gently(opts_file,
2726                                                         "options.strategy-option",
2727                                                         opts->xopts[i], "^$", 0);
2728         }
2729         if (opts->allow_rerere_auto)
2730                 res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
2731                                                      opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
2732                                                      "true" : "false");
2733         return res;
2734 }
2735
2736 static int make_patch(struct repository *r,
2737                       struct commit *commit,
2738                       struct replay_opts *opts)
2739 {
2740         struct strbuf buf = STRBUF_INIT;
2741         struct rev_info log_tree_opt;
2742         const char *subject, *p;
2743         int res = 0;
2744
2745         p = short_commit_name(commit);
2746         if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
2747                 return -1;
2748         if (update_ref("rebase", "REBASE_HEAD", &commit->object.oid,
2749                        NULL, REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR))
2750                 res |= error(_("could not update %s"), "REBASE_HEAD");
2751
2752         strbuf_addf(&buf, "%s/patch", get_dir(opts));
2753         memset(&log_tree_opt, 0, sizeof(log_tree_opt));
2754         repo_init_revisions(r, &log_tree_opt, NULL);
2755         log_tree_opt.abbrev = 0;
2756         log_tree_opt.diff = 1;
2757         log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
2758         log_tree_opt.disable_stdin = 1;
2759         log_tree_opt.no_commit_id = 1;
2760         log_tree_opt.diffopt.file = fopen(buf.buf, "w");
2761         log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
2762         if (!log_tree_opt.diffopt.file)
2763                 res |= error_errno(_("could not open '%s'"), buf.buf);
2764         else {
2765                 res |= log_tree_commit(&log_tree_opt, commit);
2766                 fclose(log_tree_opt.diffopt.file);
2767         }
2768         strbuf_reset(&buf);
2769
2770         strbuf_addf(&buf, "%s/message", get_dir(opts));
2771         if (!file_exists(buf.buf)) {
2772                 const char *commit_buffer = get_commit_buffer(commit, NULL);
2773                 find_commit_subject(commit_buffer, &subject);
2774                 res |= write_message(subject, strlen(subject), buf.buf, 1);
2775                 unuse_commit_buffer(commit, commit_buffer);
2776         }
2777         strbuf_release(&buf);
2778
2779         return res;
2780 }
2781
2782 static int intend_to_amend(void)
2783 {
2784         struct object_id head;
2785         char *p;
2786
2787         if (get_oid("HEAD", &head))
2788                 return error(_("cannot read HEAD"));
2789
2790         p = oid_to_hex(&head);
2791         return write_message(p, strlen(p), rebase_path_amend(), 1);
2792 }
2793
2794 static int error_with_patch(struct repository *r,
2795                             struct commit *commit,
2796                             const char *subject, int subject_len,
2797                             struct replay_opts *opts,
2798                             int exit_code, int to_amend)
2799 {
2800         if (commit) {
2801                 if (make_patch(r, commit, opts))
2802                         return -1;
2803         } else if (copy_file(rebase_path_message(),
2804                              git_path_merge_msg(r), 0666))
2805                 return error(_("unable to copy '%s' to '%s'"),
2806                              git_path_merge_msg(r), rebase_path_message());
2807
2808         if (to_amend) {
2809                 if (intend_to_amend())
2810                         return -1;
2811
2812                 fprintf(stderr,
2813                         _("You can amend the commit now, with\n"
2814                           "\n"
2815                           "  git commit --amend %s\n"
2816                           "\n"
2817                           "Once you are satisfied with your changes, run\n"
2818                           "\n"
2819                           "  git rebase --continue\n"),
2820                         gpg_sign_opt_quoted(opts));
2821         } else if (exit_code) {
2822                 if (commit)
2823                         fprintf_ln(stderr, _("Could not apply %s... %.*s"),
2824                                    short_commit_name(commit), subject_len, subject);
2825                 else
2826                         /*
2827                          * We don't have the hash of the parent so
2828                          * just print the line from the todo file.
2829                          */
2830                         fprintf_ln(stderr, _("Could not merge %.*s"),
2831                                    subject_len, subject);
2832         }
2833
2834         return exit_code;
2835 }
2836
2837 static int error_failed_squash(struct repository *r,
2838                                struct commit *commit,
2839                                struct replay_opts *opts,
2840                                int subject_len,
2841                                const char *subject)
2842 {
2843         if (copy_file(rebase_path_message(), rebase_path_squash_msg(), 0666))
2844                 return error(_("could not copy '%s' to '%s'"),
2845                         rebase_path_squash_msg(), rebase_path_message());
2846         unlink(git_path_merge_msg(r));
2847         if (copy_file(git_path_merge_msg(r), rebase_path_message(), 0666))
2848                 return error(_("could not copy '%s' to '%s'"),
2849                              rebase_path_message(),
2850                              git_path_merge_msg(r));
2851         return error_with_patch(r, commit, subject, subject_len, opts, 1, 0);
2852 }
2853
2854 static int do_exec(struct repository *r, const char *command_line)
2855 {
2856         struct argv_array child_env = ARGV_ARRAY_INIT;
2857         const char *child_argv[] = { NULL, NULL };
2858         int dirty, status;
2859
2860         fprintf(stderr, "Executing: %s\n", command_line);
2861         child_argv[0] = command_line;
2862         argv_array_pushf(&child_env, "GIT_DIR=%s", absolute_path(get_git_dir()));
2863         argv_array_pushf(&child_env, "GIT_WORK_TREE=%s",
2864                          absolute_path(get_git_work_tree()));
2865         status = run_command_v_opt_cd_env(child_argv, RUN_USING_SHELL, NULL,
2866                                           child_env.argv);
2867
2868         /* force re-reading of the cache */
2869         if (discard_index(r->index) < 0 || repo_read_index(r) < 0)
2870                 return error(_("could not read index"));
2871
2872         dirty = require_clean_work_tree(r, "rebase", NULL, 1, 1);
2873
2874         if (status) {
2875                 warning(_("execution failed: %s\n%s"
2876                           "You can fix the problem, and then run\n"
2877                           "\n"
2878                           "  git rebase --continue\n"
2879                           "\n"),
2880                         command_line,
2881                         dirty ? N_("and made changes to the index and/or the "
2882                                 "working tree\n") : "");
2883                 if (status == 127)
2884                         /* command not found */
2885                         status = 1;
2886         } else if (dirty) {
2887                 warning(_("execution succeeded: %s\nbut "
2888                           "left changes to the index and/or the working tree\n"
2889                           "Commit or stash your changes, and then run\n"
2890                           "\n"
2891                           "  git rebase --continue\n"
2892                           "\n"), command_line);
2893                 status = 1;
2894         }
2895
2896         argv_array_clear(&child_env);
2897
2898         return status;
2899 }
2900
2901 static int safe_append(const char *filename, const char *fmt, ...)
2902 {
2903         va_list ap;
2904         struct lock_file lock = LOCK_INIT;
2905         int fd = hold_lock_file_for_update(&lock, filename,
2906                                            LOCK_REPORT_ON_ERROR);
2907         struct strbuf buf = STRBUF_INIT;
2908
2909         if (fd < 0)
2910                 return -1;
2911
2912         if (strbuf_read_file(&buf, filename, 0) < 0 && errno != ENOENT) {
2913                 error_errno(_("could not read '%s'"), filename);
2914                 rollback_lock_file(&lock);
2915                 return -1;
2916         }
2917         strbuf_complete(&buf, '\n');
2918         va_start(ap, fmt);
2919         strbuf_vaddf(&buf, fmt, ap);
2920         va_end(ap);
2921
2922         if (write_in_full(fd, buf.buf, buf.len) < 0) {
2923                 error_errno(_("could not write to '%s'"), filename);
2924                 strbuf_release(&buf);
2925                 rollback_lock_file(&lock);
2926                 return -1;
2927         }
2928         if (commit_lock_file(&lock) < 0) {
2929                 strbuf_release(&buf);
2930                 rollback_lock_file(&lock);
2931                 return error(_("failed to finalize '%s'"), filename);
2932         }
2933
2934         strbuf_release(&buf);
2935         return 0;
2936 }
2937
2938 static int do_label(struct repository *r, const char *name, int len)
2939 {
2940         struct ref_store *refs = get_main_ref_store(r);
2941         struct ref_transaction *transaction;
2942         struct strbuf ref_name = STRBUF_INIT, err = STRBUF_INIT;
2943         struct strbuf msg = STRBUF_INIT;
2944         int ret = 0;
2945         struct object_id head_oid;
2946
2947         if (len == 1 && *name == '#')
2948                 return error(_("illegal label name: '%.*s'"), len, name);
2949
2950         strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
2951         strbuf_addf(&msg, "rebase -i (label) '%.*s'", len, name);
2952
2953         transaction = ref_store_transaction_begin(refs, &err);
2954         if (!transaction) {
2955                 error("%s", err.buf);
2956                 ret = -1;
2957         } else if (get_oid("HEAD", &head_oid)) {
2958                 error(_("could not read HEAD"));
2959                 ret = -1;
2960         } else if (ref_transaction_update(transaction, ref_name.buf, &head_oid,
2961                                           NULL, 0, msg.buf, &err) < 0 ||
2962                    ref_transaction_commit(transaction, &err)) {
2963                 error("%s", err.buf);
2964                 ret = -1;
2965         }
2966         ref_transaction_free(transaction);
2967         strbuf_release(&err);
2968         strbuf_release(&msg);
2969
2970         if (!ret)
2971                 ret = safe_append(rebase_path_refs_to_delete(),
2972                                   "%s\n", ref_name.buf);
2973         strbuf_release(&ref_name);
2974
2975         return ret;
2976 }
2977
2978 static const char *reflog_message(struct replay_opts *opts,
2979         const char *sub_action, const char *fmt, ...);
2980
2981 static int do_reset(struct repository *r,
2982                     const char *name, int len,
2983                     struct replay_opts *opts)
2984 {
2985         struct strbuf ref_name = STRBUF_INIT;
2986         struct object_id oid;
2987         struct lock_file lock = LOCK_INIT;
2988         struct tree_desc desc;
2989         struct tree *tree;
2990         struct unpack_trees_options unpack_tree_opts;
2991         int ret = 0;
2992
2993         if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0)
2994                 return -1;
2995
2996         if (len == 10 && !strncmp("[new root]", name, len)) {
2997                 if (!opts->have_squash_onto) {
2998                         const char *hex;
2999                         if (commit_tree("", 0, the_hash_algo->empty_tree,
3000                                         NULL, &opts->squash_onto,
3001                                         NULL, NULL))
3002                                 return error(_("writing fake root commit"));
3003                         opts->have_squash_onto = 1;
3004                         hex = oid_to_hex(&opts->squash_onto);
3005                         if (write_message(hex, strlen(hex),
3006                                           rebase_path_squash_onto(), 0))
3007                                 return error(_("writing squash-onto"));
3008                 }
3009                 oidcpy(&oid, &opts->squash_onto);
3010         } else {
3011                 int i;
3012
3013                 /* Determine the length of the label */
3014                 for (i = 0; i < len; i++)
3015                         if (isspace(name[i]))
3016                                 break;
3017                 len = i;
3018
3019                 strbuf_addf(&ref_name, "refs/rewritten/%.*s", len, name);
3020                 if (get_oid(ref_name.buf, &oid) &&
3021                     get_oid(ref_name.buf + strlen("refs/rewritten/"), &oid)) {
3022                         error(_("could not read '%s'"), ref_name.buf);
3023                         rollback_lock_file(&lock);
3024                         strbuf_release(&ref_name);
3025                         return -1;
3026                 }
3027         }
3028
3029         memset(&unpack_tree_opts, 0, sizeof(unpack_tree_opts));
3030         setup_unpack_trees_porcelain(&unpack_tree_opts, "reset");
3031         unpack_tree_opts.head_idx = 1;
3032         unpack_tree_opts.src_index = r->index;
3033         unpack_tree_opts.dst_index = r->index;
3034         unpack_tree_opts.fn = oneway_merge;
3035         unpack_tree_opts.merge = 1;
3036         unpack_tree_opts.update = 1;
3037
3038         if (repo_read_index_unmerged(r)) {
3039                 rollback_lock_file(&lock);
3040                 strbuf_release(&ref_name);
3041                 return error_resolve_conflict(_(action_name(opts)));
3042         }
3043
3044         if (!fill_tree_descriptor(&desc, &oid)) {
3045                 error(_("failed to find tree of %s"), oid_to_hex(&oid));
3046                 rollback_lock_file(&lock);
3047                 free((void *)desc.buffer);
3048                 strbuf_release(&ref_name);
3049                 return -1;
3050         }
3051
3052         if (unpack_trees(1, &desc, &unpack_tree_opts)) {
3053                 rollback_lock_file(&lock);
3054                 free((void *)desc.buffer);
3055                 strbuf_release(&ref_name);
3056                 return -1;
3057         }
3058
3059         tree = parse_tree_indirect(&oid);
3060         prime_cache_tree(r, r->index, tree);
3061
3062         if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
3063                 ret = error(_("could not write index"));
3064         free((void *)desc.buffer);
3065
3066         if (!ret)
3067                 ret = update_ref(reflog_message(opts, "reset", "'%.*s'",
3068                                                 len, name), "HEAD", &oid,
3069                                  NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3070
3071         strbuf_release(&ref_name);
3072         return ret;
3073 }
3074
3075 static struct commit *lookup_label(const char *label, int len,
3076                                    struct strbuf *buf)
3077 {
3078         struct commit *commit;
3079
3080         strbuf_reset(buf);
3081         strbuf_addf(buf, "refs/rewritten/%.*s", len, label);
3082         commit = lookup_commit_reference_by_name(buf->buf);
3083         if (!commit) {
3084                 /* fall back to non-rewritten ref or commit */
3085                 strbuf_splice(buf, 0, strlen("refs/rewritten/"), "", 0);
3086                 commit = lookup_commit_reference_by_name(buf->buf);
3087         }
3088
3089         if (!commit)
3090                 error(_("could not resolve '%s'"), buf->buf);
3091
3092         return commit;
3093 }
3094
3095 static int do_merge(struct repository *r,
3096                     struct commit *commit,
3097                     const char *arg, int arg_len,
3098                     int flags, struct replay_opts *opts)
3099 {
3100         int run_commit_flags = (flags & TODO_EDIT_MERGE_MSG) ?
3101                 EDIT_MSG | VERIFY_MSG : 0;
3102         struct strbuf ref_name = STRBUF_INIT;
3103         struct commit *head_commit, *merge_commit, *i;
3104         struct commit_list *bases, *j, *reversed = NULL;
3105         struct commit_list *to_merge = NULL, **tail = &to_merge;
3106         struct merge_options o;
3107         int merge_arg_len, oneline_offset, can_fast_forward, ret, k;
3108         static struct lock_file lock;
3109         const char *p;
3110
3111         if (repo_hold_locked_index(r, &lock, LOCK_REPORT_ON_ERROR) < 0) {
3112                 ret = -1;
3113                 goto leave_merge;
3114         }
3115
3116         head_commit = lookup_commit_reference_by_name("HEAD");
3117         if (!head_commit) {
3118                 ret = error(_("cannot merge without a current revision"));
3119                 goto leave_merge;
3120         }
3121
3122         /*
3123          * For octopus merges, the arg starts with the list of revisions to be
3124          * merged. The list is optionally followed by '#' and the oneline.
3125          */
3126         merge_arg_len = oneline_offset = arg_len;
3127         for (p = arg; p - arg < arg_len; p += strspn(p, " \t\n")) {
3128                 if (!*p)
3129                         break;
3130                 if (*p == '#' && (!p[1] || isspace(p[1]))) {
3131                         p += 1 + strspn(p + 1, " \t\n");
3132                         oneline_offset = p - arg;
3133                         break;
3134                 }
3135                 k = strcspn(p, " \t\n");
3136                 if (!k)
3137                         continue;
3138                 merge_commit = lookup_label(p, k, &ref_name);
3139                 if (!merge_commit) {
3140                         ret = error(_("unable to parse '%.*s'"), k, p);
3141                         goto leave_merge;
3142                 }
3143                 tail = &commit_list_insert(merge_commit, tail)->next;
3144                 p += k;
3145                 merge_arg_len = p - arg;
3146         }
3147
3148         if (!to_merge) {
3149                 ret = error(_("nothing to merge: '%.*s'"), arg_len, arg);
3150                 goto leave_merge;
3151         }
3152
3153         if (opts->have_squash_onto &&
3154             oideq(&head_commit->object.oid, &opts->squash_onto)) {
3155                 /*
3156                  * When the user tells us to "merge" something into a
3157                  * "[new root]", let's simply fast-forward to the merge head.
3158                  */
3159                 rollback_lock_file(&lock);
3160                 if (to_merge->next)
3161                         ret = error(_("octopus merge cannot be executed on "
3162                                       "top of a [new root]"));
3163                 else
3164                         ret = fast_forward_to(r, &to_merge->item->object.oid,
3165                                               &head_commit->object.oid, 0,
3166                                               opts);
3167                 goto leave_merge;
3168         }
3169
3170         if (commit) {
3171                 const char *message = get_commit_buffer(commit, NULL);
3172                 const char *body;
3173                 int len;
3174
3175                 if (!message) {
3176                         ret = error(_("could not get commit message of '%s'"),
3177                                     oid_to_hex(&commit->object.oid));
3178                         goto leave_merge;
3179                 }
3180                 write_author_script(message);
3181                 find_commit_subject(message, &body);
3182                 len = strlen(body);
3183                 ret = write_message(body, len, git_path_merge_msg(r), 0);
3184                 unuse_commit_buffer(commit, message);
3185                 if (ret) {
3186                         error_errno(_("could not write '%s'"),
3187                                     git_path_merge_msg(r));
3188                         goto leave_merge;
3189                 }
3190         } else {
3191                 struct strbuf buf = STRBUF_INIT;
3192                 int len;
3193
3194                 strbuf_addf(&buf, "author %s", git_author_info(0));
3195                 write_author_script(buf.buf);
3196                 strbuf_reset(&buf);
3197
3198                 if (oneline_offset < arg_len) {
3199                         p = arg + oneline_offset;
3200                         len = arg_len - oneline_offset;
3201                 } else {
3202                         strbuf_addf(&buf, "Merge %s '%.*s'",
3203                                     to_merge->next ? "branches" : "branch",
3204                                     merge_arg_len, arg);
3205                         p = buf.buf;
3206                         len = buf.len;
3207                 }
3208
3209                 ret = write_message(p, len, git_path_merge_msg(r), 0);
3210                 strbuf_release(&buf);
3211                 if (ret) {
3212                         error_errno(_("could not write '%s'"),
3213                                     git_path_merge_msg(r));
3214                         goto leave_merge;
3215                 }
3216         }
3217
3218         /*
3219          * If HEAD is not identical to the first parent of the original merge
3220          * commit, we cannot fast-forward.
3221          */
3222         can_fast_forward = opts->allow_ff && commit && commit->parents &&
3223                 oideq(&commit->parents->item->object.oid,
3224                       &head_commit->object.oid);
3225
3226         /*
3227          * If any merge head is different from the original one, we cannot
3228          * fast-forward.
3229          */
3230         if (can_fast_forward) {
3231                 struct commit_list *p = commit->parents->next;
3232
3233                 for (j = to_merge; j && p; j = j->next, p = p->next)
3234                         if (!oideq(&j->item->object.oid,
3235                                    &p->item->object.oid)) {
3236                                 can_fast_forward = 0;
3237                                 break;
3238                         }
3239                 /*
3240                  * If the number of merge heads differs from the original merge
3241                  * commit, we cannot fast-forward.
3242                  */
3243                 if (j || p)
3244                         can_fast_forward = 0;
3245         }
3246
3247         if (can_fast_forward) {
3248                 rollback_lock_file(&lock);
3249                 ret = fast_forward_to(r, &commit->object.oid,
3250                                       &head_commit->object.oid, 0, opts);
3251                 goto leave_merge;
3252         }
3253
3254         if (to_merge->next) {
3255                 /* Octopus merge */
3256                 struct child_process cmd = CHILD_PROCESS_INIT;
3257
3258                 if (read_env_script(&cmd.env_array)) {
3259                         const char *gpg_opt = gpg_sign_opt_quoted(opts);
3260
3261                         ret = error(_(staged_changes_advice), gpg_opt, gpg_opt);
3262                         goto leave_merge;
3263                 }
3264
3265                 cmd.git_cmd = 1;
3266                 argv_array_push(&cmd.args, "merge");
3267                 argv_array_push(&cmd.args, "-s");
3268                 argv_array_push(&cmd.args, "octopus");
3269                 argv_array_push(&cmd.args, "--no-edit");
3270                 argv_array_push(&cmd.args, "--no-ff");
3271                 argv_array_push(&cmd.args, "--no-log");
3272                 argv_array_push(&cmd.args, "--no-stat");
3273                 argv_array_push(&cmd.args, "-F");
3274                 argv_array_push(&cmd.args, git_path_merge_msg(r));
3275                 if (opts->gpg_sign)
3276                         argv_array_push(&cmd.args, opts->gpg_sign);
3277
3278                 /* Add the tips to be merged */
3279                 for (j = to_merge; j; j = j->next)
3280                         argv_array_push(&cmd.args,
3281                                         oid_to_hex(&j->item->object.oid));
3282
3283                 strbuf_release(&ref_name);
3284                 unlink(git_path_cherry_pick_head(r));
3285                 rollback_lock_file(&lock);
3286
3287                 rollback_lock_file(&lock);
3288                 ret = run_command(&cmd);
3289
3290                 /* force re-reading of the cache */
3291                 if (!ret && (discard_index(r->index) < 0 ||
3292                              repo_read_index(r) < 0))
3293                         ret = error(_("could not read index"));
3294                 goto leave_merge;
3295         }
3296
3297         merge_commit = to_merge->item;
3298         bases = get_merge_bases(head_commit, merge_commit);
3299         if (bases && oideq(&merge_commit->object.oid,
3300                            &bases->item->object.oid)) {
3301                 ret = 0;
3302                 /* skip merging an ancestor of HEAD */
3303                 goto leave_merge;
3304         }
3305
3306         write_message(oid_to_hex(&merge_commit->object.oid), GIT_SHA1_HEXSZ,
3307                       git_path_merge_head(r), 0);
3308         write_message("no-ff", 5, git_path_merge_mode(r), 0);
3309
3310         for (j = bases; j; j = j->next)
3311                 commit_list_insert(j->item, &reversed);
3312         free_commit_list(bases);
3313
3314         repo_read_index(r);
3315         init_merge_options(&o, r);
3316         o.branch1 = "HEAD";
3317         o.branch2 = ref_name.buf;
3318         o.buffer_output = 2;
3319
3320         ret = merge_recursive(&o, head_commit, merge_commit, reversed, &i);
3321         if (ret <= 0)
3322                 fputs(o.obuf.buf, stdout);
3323         strbuf_release(&o.obuf);
3324         if (ret < 0) {
3325                 error(_("could not even attempt to merge '%.*s'"),
3326                       merge_arg_len, arg);
3327                 goto leave_merge;
3328         }
3329         /*
3330          * The return value of merge_recursive() is 1 on clean, and 0 on
3331          * unclean merge.
3332          *
3333          * Let's reverse that, so that do_merge() returns 0 upon success and
3334          * 1 upon failed merge (keeping the return value -1 for the cases where
3335          * we will want to reschedule the `merge` command).
3336          */
3337         ret = !ret;
3338
3339         if (r->index->cache_changed &&
3340             write_locked_index(r->index, &lock, COMMIT_LOCK)) {
3341                 ret = error(_("merge: Unable to write new index file"));
3342                 goto leave_merge;
3343         }
3344
3345         rollback_lock_file(&lock);
3346         if (ret)
3347                 repo_rerere(r, opts->allow_rerere_auto);
3348         else
3349                 /*
3350                  * In case of problems, we now want to return a positive
3351                  * value (a negative one would indicate that the `merge`
3352                  * command needs to be rescheduled).
3353                  */
3354                 ret = !!run_git_commit(r, git_path_merge_msg(r), opts,
3355                                        run_commit_flags);
3356
3357 leave_merge:
3358         strbuf_release(&ref_name);
3359         rollback_lock_file(&lock);
3360         free_commit_list(to_merge);
3361         return ret;
3362 }
3363
3364 static int is_final_fixup(struct todo_list *todo_list)
3365 {
3366         int i = todo_list->current;
3367
3368         if (!is_fixup(todo_list->items[i].command))
3369                 return 0;
3370
3371         while (++i < todo_list->nr)
3372                 if (is_fixup(todo_list->items[i].command))
3373                         return 0;
3374                 else if (!is_noop(todo_list->items[i].command))
3375                         break;
3376         return 1;
3377 }
3378
3379 static enum todo_command peek_command(struct todo_list *todo_list, int offset)
3380 {
3381         int i;
3382
3383         for (i = todo_list->current + offset; i < todo_list->nr; i++)
3384                 if (!is_noop(todo_list->items[i].command))
3385                         return todo_list->items[i].command;
3386
3387         return -1;
3388 }
3389
3390 static int apply_autostash(struct replay_opts *opts)
3391 {
3392         struct strbuf stash_sha1 = STRBUF_INIT;
3393         struct child_process child = CHILD_PROCESS_INIT;
3394         int ret = 0;
3395
3396         if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
3397                 strbuf_release(&stash_sha1);
3398                 return 0;
3399         }
3400         strbuf_trim(&stash_sha1);
3401
3402         child.git_cmd = 1;
3403         child.no_stdout = 1;
3404         child.no_stderr = 1;
3405         argv_array_push(&child.args, "stash");
3406         argv_array_push(&child.args, "apply");
3407         argv_array_push(&child.args, stash_sha1.buf);
3408         if (!run_command(&child))
3409                 fprintf(stderr, _("Applied autostash.\n"));
3410         else {
3411                 struct child_process store = CHILD_PROCESS_INIT;
3412
3413                 store.git_cmd = 1;
3414                 argv_array_push(&store.args, "stash");
3415                 argv_array_push(&store.args, "store");
3416                 argv_array_push(&store.args, "-m");
3417                 argv_array_push(&store.args, "autostash");
3418                 argv_array_push(&store.args, "-q");
3419                 argv_array_push(&store.args, stash_sha1.buf);
3420                 if (run_command(&store))
3421                         ret = error(_("cannot store %s"), stash_sha1.buf);
3422                 else
3423                         fprintf(stderr,
3424                                 _("Applying autostash resulted in conflicts.\n"
3425                                   "Your changes are safe in the stash.\n"
3426                                   "You can run \"git stash pop\" or"
3427                                   " \"git stash drop\" at any time.\n"));
3428         }
3429
3430         strbuf_release(&stash_sha1);
3431         return ret;
3432 }
3433
3434 static const char *reflog_message(struct replay_opts *opts,
3435         const char *sub_action, const char *fmt, ...)
3436 {
3437         va_list ap;
3438         static struct strbuf buf = STRBUF_INIT;
3439
3440         va_start(ap, fmt);
3441         strbuf_reset(&buf);
3442         strbuf_addstr(&buf, action_name(opts));
3443         if (sub_action)
3444                 strbuf_addf(&buf, " (%s)", sub_action);
3445         if (fmt) {
3446                 strbuf_addstr(&buf, ": ");
3447                 strbuf_vaddf(&buf, fmt, ap);
3448         }
3449         va_end(ap);
3450
3451         return buf.buf;
3452 }
3453
3454 static int run_git_checkout(struct replay_opts *opts, const char *commit,
3455                             const char *action)
3456 {
3457         struct child_process cmd = CHILD_PROCESS_INIT;
3458
3459         cmd.git_cmd = 1;
3460
3461         argv_array_push(&cmd.args, "checkout");
3462         argv_array_push(&cmd.args, commit);
3463         argv_array_pushf(&cmd.env_array, GIT_REFLOG_ACTION "=%s", action);
3464
3465         if (opts->verbose)
3466                 return run_command(&cmd);
3467         else
3468                 return run_command_silent_on_success(&cmd);
3469 }
3470
3471 int prepare_branch_to_be_rebased(struct replay_opts *opts, const char *commit)
3472 {
3473         const char *action;
3474
3475         if (commit && *commit) {
3476                 action = reflog_message(opts, "start", "checkout %s", commit);
3477                 if (run_git_checkout(opts, commit, action))
3478                         return error(_("could not checkout %s"), commit);
3479         }
3480
3481         return 0;
3482 }
3483
3484 static int checkout_onto(struct replay_opts *opts,
3485                          const char *onto_name, const char *onto,
3486                          const char *orig_head)
3487 {
3488         struct object_id oid;
3489         const char *action = reflog_message(opts, "start", "checkout %s", onto_name);
3490
3491         if (get_oid(orig_head, &oid))
3492                 return error(_("%s: not a valid OID"), orig_head);
3493
3494         if (run_git_checkout(opts, onto, action)) {
3495                 apply_autostash(opts);
3496                 sequencer_remove_state(opts);
3497                 return error(_("could not detach HEAD"));
3498         }
3499
3500         return update_ref(NULL, "ORIG_HEAD", &oid, NULL, 0, UPDATE_REFS_MSG_ON_ERR);
3501 }
3502
3503 static int stopped_at_head(struct repository *r)
3504 {
3505         struct object_id head;
3506         struct commit *commit;
3507         struct commit_message message;
3508
3509         if (get_oid("HEAD", &head) ||
3510             !(commit = lookup_commit(r, &head)) ||
3511             parse_commit(commit) || get_message(commit, &message))
3512                 fprintf(stderr, _("Stopped at HEAD\n"));
3513         else {
3514                 fprintf(stderr, _("Stopped at %s\n"), message.label);
3515                 free_message(commit, &message);
3516         }
3517         return 0;
3518
3519 }
3520
3521 static const char rescheduled_advice[] =
3522 N_("Could not execute the todo command\n"
3523 "\n"
3524 "    %.*s"
3525 "\n"
3526 "It has been rescheduled; To edit the command before continuing, please\n"
3527 "edit the todo list first:\n"
3528 "\n"
3529 "    git rebase --edit-todo\n"
3530 "    git rebase --continue\n");
3531
3532 static int pick_commits(struct repository *r,
3533                         struct todo_list *todo_list,
3534                         struct replay_opts *opts)
3535 {
3536         int res = 0, reschedule = 0;
3537
3538         setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
3539         if (opts->allow_ff)
3540                 assert(!(opts->signoff || opts->no_commit ||
3541                                 opts->record_origin || opts->edit));
3542         if (read_and_refresh_cache(r, opts))
3543                 return -1;
3544
3545         while (todo_list->current < todo_list->nr) {
3546                 struct todo_item *item = todo_list->items + todo_list->current;
3547                 if (save_todo(todo_list, opts))
3548                         return -1;
3549                 if (is_rebase_i(opts)) {
3550                         if (item->command != TODO_COMMENT) {
3551                                 FILE *f = fopen(rebase_path_msgnum(), "w");
3552
3553                                 todo_list->done_nr++;
3554
3555                                 if (f) {
3556                                         fprintf(f, "%d\n", todo_list->done_nr);
3557                                         fclose(f);
3558                                 }
3559                                 if (!opts->quiet)
3560                                         fprintf(stderr, "Rebasing (%d/%d)%s",
3561                                                 todo_list->done_nr,
3562                                                 todo_list->total_nr,
3563                                                 opts->verbose ? "\n" : "\r");
3564                         }
3565                         unlink(rebase_path_message());
3566                         unlink(rebase_path_author_script());
3567                         unlink(rebase_path_stopped_sha());
3568                         unlink(rebase_path_amend());
3569                         unlink(git_path_merge_head(the_repository));
3570                         delete_ref(NULL, "REBASE_HEAD", NULL, REF_NO_DEREF);
3571
3572                         if (item->command == TODO_BREAK)
3573                                 return stopped_at_head(r);
3574                 }
3575                 if (item->command <= TODO_SQUASH) {
3576                         if (is_rebase_i(opts))
3577                                 setenv("GIT_REFLOG_ACTION", reflog_message(opts,
3578                                         command_to_string(item->command), NULL),
3579                                         1);
3580                         res = do_pick_commit(r, item->command, item->commit,
3581                                         opts, is_final_fixup(todo_list));
3582                         if (is_rebase_i(opts) && res < 0) {
3583                                 /* Reschedule */
3584                                 advise(_(rescheduled_advice),
3585                                        get_item_line_length(todo_list,
3586                                                             todo_list->current),
3587                                        get_item_line(todo_list,
3588                                                      todo_list->current));
3589                                 todo_list->current--;
3590                                 if (save_todo(todo_list, opts))
3591                                         return -1;
3592                         }
3593                         if (item->command == TODO_EDIT) {
3594                                 struct commit *commit = item->commit;
3595                                 if (!res)
3596                                         fprintf(stderr,
3597                                                 _("Stopped at %s...  %.*s\n"),
3598                                                 short_commit_name(commit),
3599                                                 item->arg_len, item->arg);
3600                                 return error_with_patch(r, commit,
3601                                         item->arg, item->arg_len, opts, res,
3602                                         !res);
3603                         }
3604                         if (is_rebase_i(opts) && !res)
3605                                 record_in_rewritten(&item->commit->object.oid,
3606                                         peek_command(todo_list, 1));
3607                         if (res && is_fixup(item->command)) {
3608                                 if (res == 1)
3609                                         intend_to_amend();
3610                                 return error_failed_squash(r, item->commit, opts,
3611                                         item->arg_len, item->arg);
3612                         } else if (res && is_rebase_i(opts) && item->commit) {
3613                                 int to_amend = 0;
3614                                 struct object_id oid;
3615
3616                                 /*
3617                                  * If we are rewording and have either
3618                                  * fast-forwarded already, or are about to
3619                                  * create a new root commit, we want to amend,
3620                                  * otherwise we do not.
3621                                  */
3622                                 if (item->command == TODO_REWORD &&
3623                                     !get_oid("HEAD", &oid) &&
3624                                     (oideq(&item->commit->object.oid, &oid) ||
3625                                      (opts->have_squash_onto &&
3626                                       oideq(&opts->squash_onto, &oid))))
3627                                         to_amend = 1;
3628
3629                                 return res | error_with_patch(r, item->commit,
3630                                                 item->arg, item->arg_len, opts,
3631                                                 res, to_amend);
3632                         }
3633                 } else if (item->command == TODO_EXEC) {
3634                         char *end_of_arg = (char *)(item->arg + item->arg_len);
3635                         int saved = *end_of_arg;
3636                         struct stat st;
3637
3638                         *end_of_arg = '\0';
3639                         res = do_exec(r, item->arg);
3640                         *end_of_arg = saved;
3641
3642                         /* Reread the todo file if it has changed. */
3643                         if (res) {
3644                                 if (opts->reschedule_failed_exec)
3645                                         reschedule = 1;
3646                         } else if (stat(get_todo_path(opts), &st))
3647                                 res = error_errno(_("could not stat '%s'"),
3648                                                   get_todo_path(opts));
3649                         else if (match_stat_data(&todo_list->stat, &st)) {
3650                                 todo_list_release(todo_list);
3651                                 if (read_populate_todo(r, todo_list, opts))
3652                                         res = -1; /* message was printed */
3653                                 /* `current` will be incremented below */
3654                                 todo_list->current = -1;
3655                         }
3656                 } else if (item->command == TODO_LABEL) {
3657                         if ((res = do_label(r, item->arg, item->arg_len)))
3658                                 reschedule = 1;
3659                 } else if (item->command == TODO_RESET) {
3660                         if ((res = do_reset(r, item->arg, item->arg_len, opts)))
3661                                 reschedule = 1;
3662                 } else if (item->command == TODO_MERGE) {
3663                         if ((res = do_merge(r, item->commit,
3664                                             item->arg, item->arg_len,
3665                                             item->flags, opts)) < 0)
3666                                 reschedule = 1;
3667                         else if (item->commit)
3668                                 record_in_rewritten(&item->commit->object.oid,
3669                                                     peek_command(todo_list, 1));
3670                         if (res > 0)
3671                                 /* failed with merge conflicts */
3672                                 return error_with_patch(r, item->commit,
3673                                                         item->arg,
3674                                                         item->arg_len, opts,
3675                                                         res, 0);
3676                 } else if (!is_noop(item->command))
3677                         return error(_("unknown command %d"), item->command);
3678
3679                 if (reschedule) {
3680                         advise(_(rescheduled_advice),
3681                                get_item_line_length(todo_list,
3682                                                     todo_list->current),
3683                                get_item_line(todo_list, todo_list->current));
3684                         todo_list->current--;
3685                         if (save_todo(todo_list, opts))
3686                                 return -1;
3687                         if (item->commit)
3688                                 return error_with_patch(r,
3689                                                         item->commit,
3690                                                         item->arg,
3691                                                         item->arg_len, opts,
3692                                                         res, 0);
3693                 }
3694
3695                 todo_list->current++;
3696                 if (res)
3697                         return res;
3698         }
3699
3700         if (is_rebase_i(opts)) {
3701                 struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
3702                 struct stat st;
3703
3704                 /* Stopped in the middle, as planned? */
3705                 if (todo_list->current < todo_list->nr)
3706                         return 0;
3707
3708                 if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
3709                                 starts_with(head_ref.buf, "refs/")) {
3710                         const char *msg;
3711                         struct object_id head, orig;
3712                         int res;
3713
3714                         if (get_oid("HEAD", &head)) {
3715                                 res = error(_("cannot read HEAD"));
3716 cleanup_head_ref:
3717                                 strbuf_release(&head_ref);
3718                                 strbuf_release(&buf);
3719                                 return res;
3720                         }
3721                         if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
3722                                         get_oid_hex(buf.buf, &orig)) {
3723                                 res = error(_("could not read orig-head"));
3724                                 goto cleanup_head_ref;
3725                         }
3726                         strbuf_reset(&buf);
3727                         if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
3728                                 res = error(_("could not read 'onto'"));
3729                                 goto cleanup_head_ref;
3730                         }
3731                         msg = reflog_message(opts, "finish", "%s onto %s",
3732                                 head_ref.buf, buf.buf);
3733                         if (update_ref(msg, head_ref.buf, &head, &orig,
3734                                        REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
3735                                 res = error(_("could not update %s"),
3736                                         head_ref.buf);
3737                                 goto cleanup_head_ref;
3738                         }
3739                         msg = reflog_message(opts, "finish", "returning to %s",
3740                                 head_ref.buf);
3741                         if (create_symref("HEAD", head_ref.buf, msg)) {
3742                                 res = error(_("could not update HEAD to %s"),
3743                                         head_ref.buf);
3744                                 goto cleanup_head_ref;
3745                         }
3746                         strbuf_reset(&buf);
3747                 }
3748
3749                 if (opts->verbose) {
3750                         struct rev_info log_tree_opt;
3751                         struct object_id orig, head;
3752
3753                         memset(&log_tree_opt, 0, sizeof(log_tree_opt));
3754                         repo_init_revisions(r, &log_tree_opt, NULL);
3755                         log_tree_opt.diff = 1;
3756                         log_tree_opt.diffopt.output_format =
3757                                 DIFF_FORMAT_DIFFSTAT;
3758                         log_tree_opt.disable_stdin = 1;
3759
3760                         if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
3761                             !get_oid(buf.buf, &orig) &&
3762                             !get_oid("HEAD", &head)) {
3763                                 diff_tree_oid(&orig, &head, "",
3764                                               &log_tree_opt.diffopt);
3765                                 log_tree_diff_flush(&log_tree_opt);
3766                         }
3767                 }
3768                 flush_rewritten_pending();
3769                 if (!stat(rebase_path_rewritten_list(), &st) &&
3770                                 st.st_size > 0) {
3771                         struct child_process child = CHILD_PROCESS_INIT;
3772                         const char *post_rewrite_hook =
3773                                 find_hook("post-rewrite");
3774
3775                         child.in = open(rebase_path_rewritten_list(), O_RDONLY);
3776                         child.git_cmd = 1;
3777                         argv_array_push(&child.args, "notes");
3778                         argv_array_push(&child.args, "copy");
3779                         argv_array_push(&child.args, "--for-rewrite=rebase");
3780                         /* we don't care if this copying failed */
3781                         run_command(&child);
3782
3783                         if (post_rewrite_hook) {
3784                                 struct child_process hook = CHILD_PROCESS_INIT;
3785
3786                                 hook.in = open(rebase_path_rewritten_list(),
3787                                         O_RDONLY);
3788                                 hook.stdout_to_stderr = 1;
3789                                 argv_array_push(&hook.args, post_rewrite_hook);
3790                                 argv_array_push(&hook.args, "rebase");
3791                                 /* we don't care if this hook failed */
3792                                 run_command(&hook);
3793                         }
3794                 }
3795                 apply_autostash(opts);
3796
3797                 if (!opts->quiet)
3798                         fprintf(stderr,
3799                                 "Successfully rebased and updated %s.\n",
3800                                 head_ref.buf);
3801
3802                 strbuf_release(&buf);
3803                 strbuf_release(&head_ref);
3804         }
3805
3806         /*
3807          * Sequence of picks finished successfully; cleanup by
3808          * removing the .git/sequencer directory
3809          */
3810         return sequencer_remove_state(opts);
3811 }
3812
3813 static int continue_single_pick(struct repository *r)
3814 {
3815         const char *argv[] = { "commit", NULL };
3816
3817         if (!file_exists(git_path_cherry_pick_head(r)) &&
3818             !file_exists(git_path_revert_head(r)))
3819                 return error(_("no cherry-pick or revert in progress"));
3820         return run_command_v_opt(argv, RUN_GIT_CMD);
3821 }
3822
3823 static int commit_staged_changes(struct repository *r,
3824                                  struct replay_opts *opts,
3825                                  struct todo_list *todo_list)
3826 {
3827         unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
3828         unsigned int final_fixup = 0, is_clean;
3829
3830         if (has_unstaged_changes(r, 1))
3831                 return error(_("cannot rebase: You have unstaged changes."));
3832
3833         is_clean = !has_uncommitted_changes(r, 0);
3834
3835         if (file_exists(rebase_path_amend())) {
3836                 struct strbuf rev = STRBUF_INIT;
3837                 struct object_id head, to_amend;
3838
3839                 if (get_oid("HEAD", &head))
3840                         return error(_("cannot amend non-existing commit"));
3841                 if (!read_oneliner(&rev, rebase_path_amend(), 0))
3842                         return error(_("invalid file: '%s'"), rebase_path_amend());
3843                 if (get_oid_hex(rev.buf, &to_amend))
3844                         return error(_("invalid contents: '%s'"),
3845                                 rebase_path_amend());
3846                 if (!is_clean && !oideq(&head, &to_amend))
3847                         return error(_("\nYou have uncommitted changes in your "
3848                                        "working tree. Please, commit them\n"
3849                                        "first and then run 'git rebase "
3850                                        "--continue' again."));
3851                 /*
3852                  * When skipping a failed fixup/squash, we need to edit the
3853                  * commit message, the current fixup list and count, and if it
3854                  * was the last fixup/squash in the chain, we need to clean up
3855                  * the commit message and if there was a squash, let the user
3856                  * edit it.
3857                  */
3858                 if (!is_clean || !opts->current_fixup_count)
3859                         ; /* this is not the final fixup */
3860                 else if (!oideq(&head, &to_amend) ||
3861                          !file_exists(rebase_path_stopped_sha())) {
3862                         /* was a final fixup or squash done manually? */
3863                         if (!is_fixup(peek_command(todo_list, 0))) {
3864                                 unlink(rebase_path_fixup_msg());
3865                                 unlink(rebase_path_squash_msg());
3866                                 unlink(rebase_path_current_fixups());
3867                                 strbuf_reset(&opts->current_fixups);
3868                                 opts->current_fixup_count = 0;
3869                         }
3870                 } else {
3871                         /* we are in a fixup/squash chain */
3872                         const char *p = opts->current_fixups.buf;
3873                         int len = opts->current_fixups.len;
3874
3875                         opts->current_fixup_count--;
3876                         if (!len)
3877                                 BUG("Incorrect current_fixups:\n%s", p);
3878                         while (len && p[len - 1] != '\n')
3879                                 len--;
3880                         strbuf_setlen(&opts->current_fixups, len);
3881                         if (write_message(p, len, rebase_path_current_fixups(),
3882                                           0) < 0)
3883                                 return error(_("could not write file: '%s'"),
3884                                              rebase_path_current_fixups());
3885
3886                         /*
3887                          * If a fixup/squash in a fixup/squash chain failed, the
3888                          * commit message is already correct, no need to commit
3889                          * it again.
3890                          *
3891                          * Only if it is the final command in the fixup/squash
3892                          * chain, and only if the chain is longer than a single
3893                          * fixup/squash command (which was just skipped), do we
3894                          * actually need to re-commit with a cleaned up commit
3895                          * message.
3896                          */
3897                         if (opts->current_fixup_count > 0 &&
3898                             !is_fixup(peek_command(todo_list, 0))) {
3899                                 final_fixup = 1;
3900                                 /*
3901                                  * If there was not a single "squash" in the
3902                                  * chain, we only need to clean up the commit
3903                                  * message, no need to bother the user with
3904                                  * opening the commit message in the editor.
3905                                  */
3906                                 if (!starts_with(p, "squash ") &&
3907                                     !strstr(p, "\nsquash "))
3908                                         flags = (flags & ~EDIT_MSG) | CLEANUP_MSG;
3909                         } else if (is_fixup(peek_command(todo_list, 0))) {
3910                                 /*
3911                                  * We need to update the squash message to skip
3912                                  * the latest commit message.
3913                                  */
3914                                 struct commit *commit;
3915                                 const char *path = rebase_path_squash_msg();
3916
3917                                 if (parse_head(r, &commit) ||
3918                                     !(p = get_commit_buffer(commit, NULL)) ||
3919                                     write_message(p, strlen(p), path, 0)) {
3920                                         unuse_commit_buffer(commit, p);
3921                                         return error(_("could not write file: "
3922                                                        "'%s'"), path);
3923                                 }
3924                                 unuse_commit_buffer(commit, p);
3925                         }
3926                 }
3927
3928                 strbuf_release(&rev);
3929                 flags |= AMEND_MSG;
3930         }
3931
3932         if (is_clean) {
3933                 const char *cherry_pick_head = git_path_cherry_pick_head(r);
3934
3935                 if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
3936                         return error(_("could not remove CHERRY_PICK_HEAD"));
3937                 if (!final_fixup)
3938                         return 0;
3939         }
3940
3941         if (run_git_commit(r, final_fixup ? NULL : rebase_path_message(),
3942                            opts, flags))
3943                 return error(_("could not commit staged changes."));
3944         unlink(rebase_path_amend());
3945         unlink(git_path_merge_head(the_repository));
3946         if (final_fixup) {
3947                 unlink(rebase_path_fixup_msg());
3948                 unlink(rebase_path_squash_msg());
3949         }
3950         if (opts->current_fixup_count > 0) {
3951                 /*
3952                  * Whether final fixup or not, we just cleaned up the commit
3953                  * message...
3954                  */
3955                 unlink(rebase_path_current_fixups());
3956                 strbuf_reset(&opts->current_fixups);
3957                 opts->current_fixup_count = 0;
3958         }
3959         return 0;
3960 }
3961
3962 int sequencer_continue(struct repository *r, struct replay_opts *opts)
3963 {
3964         struct todo_list todo_list = TODO_LIST_INIT;
3965         int res;
3966
3967         if (read_and_refresh_cache(r, opts))
3968                 return -1;
3969
3970         if (read_populate_opts(opts))
3971                 return -1;
3972         if (is_rebase_i(opts)) {
3973                 if ((res = read_populate_todo(r, &todo_list, opts)))
3974                         goto release_todo_list;
3975                 if (commit_staged_changes(r, opts, &todo_list))
3976                         return -1;
3977         } else if (!file_exists(get_todo_path(opts)))
3978                 return continue_single_pick(r);
3979         else if ((res = read_populate_todo(r, &todo_list, opts)))
3980                 goto release_todo_list;
3981
3982         if (!is_rebase_i(opts)) {
3983                 /* Verify that the conflict has been resolved */
3984                 if (file_exists(git_path_cherry_pick_head(r)) ||
3985                     file_exists(git_path_revert_head(r))) {
3986                         res = continue_single_pick(r);
3987                         if (res)
3988                                 goto release_todo_list;
3989                 }
3990                 if (index_differs_from(r, "HEAD", NULL, 0)) {
3991                         res = error_dirty_index(r, opts);
3992                         goto release_todo_list;
3993                 }
3994                 todo_list.current++;
3995         } else if (file_exists(rebase_path_stopped_sha())) {
3996                 struct strbuf buf = STRBUF_INIT;
3997                 struct object_id oid;
3998
3999                 if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
4000                     !get_oid_committish(buf.buf, &oid))
4001                         record_in_rewritten(&oid, peek_command(&todo_list, 0));
4002                 strbuf_release(&buf);
4003         }
4004
4005         res = pick_commits(r, &todo_list, opts);
4006 release_todo_list:
4007         todo_list_release(&todo_list);
4008         return res;
4009 }
4010
4011 static int single_pick(struct repository *r,
4012                        struct commit *cmit,
4013                        struct replay_opts *opts)
4014 {
4015         setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
4016         return do_pick_commit(r, opts->action == REPLAY_PICK ?
4017                 TODO_PICK : TODO_REVERT, cmit, opts, 0);
4018 }
4019
4020 int sequencer_pick_revisions(struct repository *r,
4021                              struct replay_opts *opts)
4022 {
4023         struct todo_list todo_list = TODO_LIST_INIT;
4024         struct object_id oid;
4025         int i, res;
4026
4027         assert(opts->revs);
4028         if (read_and_refresh_cache(r, opts))
4029                 return -1;
4030
4031         for (i = 0; i < opts->revs->pending.nr; i++) {
4032                 struct object_id oid;
4033                 const char *name = opts->revs->pending.objects[i].name;
4034
4035                 /* This happens when using --stdin. */
4036                 if (!strlen(name))
4037                         continue;
4038
4039                 if (!get_oid(name, &oid)) {
4040                         if (!lookup_commit_reference_gently(r, &oid, 1)) {
4041                                 enum object_type type = oid_object_info(r,
4042                                                                         &oid,
4043                                                                         NULL);
4044                                 return error(_("%s: can't cherry-pick a %s"),
4045                                         name, type_name(type));
4046                         }
4047                 } else
4048                         return error(_("%s: bad revision"), name);
4049         }
4050
4051         /*
4052          * If we were called as "git cherry-pick <commit>", just
4053          * cherry-pick/revert it, set CHERRY_PICK_HEAD /
4054          * REVERT_HEAD, and don't touch the sequencer state.
4055          * This means it is possible to cherry-pick in the middle
4056          * of a cherry-pick sequence.
4057          */
4058         if (opts->revs->cmdline.nr == 1 &&
4059             opts->revs->cmdline.rev->whence == REV_CMD_REV &&
4060             opts->revs->no_walk &&
4061             !opts->revs->cmdline.rev->flags) {
4062                 struct commit *cmit;
4063                 if (prepare_revision_walk(opts->revs))
4064                         return error(_("revision walk setup failed"));
4065                 cmit = get_revision(opts->revs);
4066                 if (!cmit)
4067                         return error(_("empty commit set passed"));
4068                 if (get_revision(opts->revs))
4069                         BUG("unexpected extra commit from walk");
4070                 return single_pick(r, cmit, opts);
4071         }
4072
4073         /*
4074          * Start a new cherry-pick/ revert sequence; but
4075          * first, make sure that an existing one isn't in
4076          * progress
4077          */
4078
4079         if (walk_revs_populate_todo(&todo_list, opts) ||
4080                         create_seq_dir() < 0)
4081                 return -1;
4082         if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
4083                 return error(_("can't revert as initial commit"));
4084         if (save_head(oid_to_hex(&oid)))
4085                 return -1;
4086         if (save_opts(opts))
4087                 return -1;
4088         update_abort_safety_file();
4089         res = pick_commits(r, &todo_list, opts);
4090         todo_list_release(&todo_list);
4091         return res;
4092 }
4093
4094 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
4095 {
4096         unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
4097         struct strbuf sob = STRBUF_INIT;
4098         int has_footer;
4099
4100         strbuf_addstr(&sob, sign_off_header);
4101         strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
4102                                 getenv("GIT_COMMITTER_EMAIL")));
4103         strbuf_addch(&sob, '\n');
4104
4105         if (!ignore_footer)
4106                 strbuf_complete_line(msgbuf);
4107
4108         /*
4109          * If the whole message buffer is equal to the sob, pretend that we
4110          * found a conforming footer with a matching sob
4111          */
4112         if (msgbuf->len - ignore_footer == sob.len &&
4113             !strncmp(msgbuf->buf, sob.buf, sob.len))
4114                 has_footer = 3;
4115         else
4116                 has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
4117
4118         if (!has_footer) {
4119                 const char *append_newlines = NULL;
4120                 size_t len = msgbuf->len - ignore_footer;
4121
4122                 if (!len) {
4123                         /*
4124                          * The buffer is completely empty.  Leave foom for
4125                          * the title and body to be filled in by the user.
4126                          */
4127                         append_newlines = "\n\n";
4128                 } else if (len == 1) {
4129                         /*
4130                          * Buffer contains a single newline.  Add another
4131                          * so that we leave room for the title and body.
4132                          */
4133                         append_newlines = "\n";
4134                 } else if (msgbuf->buf[len - 2] != '\n') {
4135                         /*
4136                          * Buffer ends with a single newline.  Add another
4137                          * so that there is an empty line between the message
4138                          * body and the sob.
4139                          */
4140                         append_newlines = "\n";
4141                 } /* else, the buffer already ends with two newlines. */
4142
4143                 if (append_newlines)
4144                         strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4145                                 append_newlines, strlen(append_newlines));
4146         }
4147
4148         if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
4149                 strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
4150                                 sob.buf, sob.len);
4151
4152         strbuf_release(&sob);
4153 }
4154
4155 struct labels_entry {
4156         struct hashmap_entry entry;
4157         char label[FLEX_ARRAY];
4158 };
4159
4160 static int labels_cmp(const void *fndata, const struct labels_entry *a,
4161                       const struct labels_entry *b, const void *key)
4162 {
4163         return key ? strcmp(a->label, key) : strcmp(a->label, b->label);
4164 }
4165
4166 struct string_entry {
4167         struct oidmap_entry entry;
4168         char string[FLEX_ARRAY];
4169 };
4170
4171 struct label_state {
4172         struct oidmap commit2label;
4173         struct hashmap labels;
4174         struct strbuf buf;
4175 };
4176
4177 static const char *label_oid(struct object_id *oid, const char *label,
4178                              struct label_state *state)
4179 {
4180         struct labels_entry *labels_entry;
4181         struct string_entry *string_entry;
4182         struct object_id dummy;
4183         size_t len;
4184         int i;
4185
4186         string_entry = oidmap_get(&state->commit2label, oid);
4187         if (string_entry)
4188                 return string_entry->string;
4189
4190         /*
4191          * For "uninteresting" commits, i.e. commits that are not to be
4192          * rebased, and which can therefore not be labeled, we use a unique
4193          * abbreviation of the commit name. This is slightly more complicated
4194          * than calling find_unique_abbrev() because we also need to make
4195          * sure that the abbreviation does not conflict with any other
4196          * label.
4197          *
4198          * We disallow "interesting" commits to be labeled by a string that
4199          * is a valid full-length hash, to ensure that we always can find an
4200          * abbreviation for any uninteresting commit's names that does not
4201          * clash with any other label.
4202          */
4203         if (!label) {
4204                 char *p;
4205
4206                 strbuf_reset(&state->buf);
4207                 strbuf_grow(&state->buf, GIT_SHA1_HEXSZ);
4208                 label = p = state->buf.buf;
4209
4210                 find_unique_abbrev_r(p, oid, default_abbrev);
4211
4212                 /*
4213                  * We may need to extend the abbreviated hash so that there is
4214                  * no conflicting label.
4215                  */
4216                 if (hashmap_get_from_hash(&state->labels, strihash(p), p)) {
4217                         size_t i = strlen(p) + 1;
4218
4219                         oid_to_hex_r(p, oid);
4220                         for (; i < GIT_SHA1_HEXSZ; i++) {
4221                                 char save = p[i];
4222                                 p[i] = '\0';
4223                                 if (!hashmap_get_from_hash(&state->labels,
4224                                                            strihash(p), p))
4225                                         break;
4226                                 p[i] = save;
4227                         }
4228                 }
4229         } else if (((len = strlen(label)) == the_hash_algo->hexsz &&
4230                     !get_oid_hex(label, &dummy)) ||
4231                    (len == 1 && *label == '#') ||
4232                    hashmap_get_from_hash(&state->labels,
4233                                          strihash(label), label)) {
4234                 /*
4235                  * If the label already exists, or if the label is a valid full
4236                  * OID, or the label is a '#' (which we use as a separator
4237                  * between merge heads and oneline), we append a dash and a
4238                  * number to make it unique.
4239                  */
4240                 struct strbuf *buf = &state->buf;
4241
4242                 strbuf_reset(buf);
4243                 strbuf_add(buf, label, len);
4244
4245                 for (i = 2; ; i++) {
4246                         strbuf_setlen(buf, len);
4247                         strbuf_addf(buf, "-%d", i);
4248                         if (!hashmap_get_from_hash(&state->labels,
4249                                                    strihash(buf->buf),
4250                                                    buf->buf))
4251                                 break;
4252                 }
4253
4254                 label = buf->buf;
4255         }
4256
4257         FLEX_ALLOC_STR(labels_entry, label, label);
4258         hashmap_entry_init(labels_entry, strihash(label));
4259         hashmap_add(&state->labels, labels_entry);
4260
4261         FLEX_ALLOC_STR(string_entry, string, label);
4262         oidcpy(&string_entry->entry.oid, oid);
4263         oidmap_put(&state->commit2label, string_entry);
4264
4265         return string_entry->string;
4266 }
4267
4268 static int make_script_with_merges(struct pretty_print_context *pp,
4269                                    struct rev_info *revs, FILE *out,
4270                                    unsigned flags)
4271 {
4272         int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4273         int rebase_cousins = flags & TODO_LIST_REBASE_COUSINS;
4274         struct strbuf buf = STRBUF_INIT, oneline = STRBUF_INIT;
4275         struct strbuf label = STRBUF_INIT;
4276         struct commit_list *commits = NULL, **tail = &commits, *iter;
4277         struct commit_list *tips = NULL, **tips_tail = &tips;
4278         struct commit *commit;
4279         struct oidmap commit2todo = OIDMAP_INIT;
4280         struct string_entry *entry;
4281         struct oidset interesting = OIDSET_INIT, child_seen = OIDSET_INIT,
4282                 shown = OIDSET_INIT;
4283         struct label_state state = { OIDMAP_INIT, { NULL }, STRBUF_INIT };
4284
4285         int abbr = flags & TODO_LIST_ABBREVIATE_CMDS;
4286         const char *cmd_pick = abbr ? "p" : "pick",
4287                 *cmd_label = abbr ? "l" : "label",
4288                 *cmd_reset = abbr ? "t" : "reset",
4289                 *cmd_merge = abbr ? "m" : "merge";
4290
4291         oidmap_init(&commit2todo, 0);
4292         oidmap_init(&state.commit2label, 0);
4293         hashmap_init(&state.labels, (hashmap_cmp_fn) labels_cmp, NULL, 0);
4294         strbuf_init(&state.buf, 32);
4295
4296         if (revs->cmdline.nr && (revs->cmdline.rev[0].flags & BOTTOM)) {
4297                 struct object_id *oid = &revs->cmdline.rev[0].item->oid;
4298                 FLEX_ALLOC_STR(entry, string, "onto");
4299                 oidcpy(&entry->entry.oid, oid);
4300                 oidmap_put(&state.commit2label, entry);
4301         }
4302
4303         /*
4304          * First phase:
4305          * - get onelines for all commits
4306          * - gather all branch tips (i.e. 2nd or later parents of merges)
4307          * - label all branch tips
4308          */
4309         while ((commit = get_revision(revs))) {
4310                 struct commit_list *to_merge;
4311                 const char *p1, *p2;
4312                 struct object_id *oid;
4313                 int is_empty;
4314
4315                 tail = &commit_list_insert(commit, tail)->next;
4316                 oidset_insert(&interesting, &commit->object.oid);
4317
4318                 is_empty = is_original_commit_empty(commit);
4319                 if (!is_empty && (commit->object.flags & PATCHSAME))
4320                         continue;
4321
4322                 strbuf_reset(&oneline);
4323                 pretty_print_commit(pp, commit, &oneline);
4324
4325                 to_merge = commit->parents ? commit->parents->next : NULL;
4326                 if (!to_merge) {
4327                         /* non-merge commit: easy case */
4328                         strbuf_reset(&buf);
4329                         if (!keep_empty && is_empty)
4330                                 strbuf_addf(&buf, "%c ", comment_line_char);
4331                         strbuf_addf(&buf, "%s %s %s", cmd_pick,
4332                                     oid_to_hex(&commit->object.oid),
4333                                     oneline.buf);
4334
4335                         FLEX_ALLOC_STR(entry, string, buf.buf);
4336                         oidcpy(&entry->entry.oid, &commit->object.oid);
4337                         oidmap_put(&commit2todo, entry);
4338
4339                         continue;
4340                 }
4341
4342                 /* Create a label */
4343                 strbuf_reset(&label);
4344                 if (skip_prefix(oneline.buf, "Merge ", &p1) &&
4345                     (p1 = strchr(p1, '\'')) &&
4346                     (p2 = strchr(++p1, '\'')))
4347                         strbuf_add(&label, p1, p2 - p1);
4348                 else if (skip_prefix(oneline.buf, "Merge pull request ",
4349                                      &p1) &&
4350                          (p1 = strstr(p1, " from ")))
4351                         strbuf_addstr(&label, p1 + strlen(" from "));
4352                 else
4353                         strbuf_addbuf(&label, &oneline);
4354
4355                 for (p1 = label.buf; *p1; p1++)
4356                         if (isspace(*p1))
4357                                 *(char *)p1 = '-';
4358
4359                 strbuf_reset(&buf);
4360                 strbuf_addf(&buf, "%s -C %s",
4361                             cmd_merge, oid_to_hex(&commit->object.oid));
4362
4363                 /* label the tips of merged branches */
4364                 for (; to_merge; to_merge = to_merge->next) {
4365                         oid = &to_merge->item->object.oid;
4366                         strbuf_addch(&buf, ' ');
4367
4368                         if (!oidset_contains(&interesting, oid)) {
4369                                 strbuf_addstr(&buf, label_oid(oid, NULL,
4370                                                               &state));
4371                                 continue;
4372                         }
4373
4374                         tips_tail = &commit_list_insert(to_merge->item,
4375                                                         tips_tail)->next;
4376
4377                         strbuf_addstr(&buf, label_oid(oid, label.buf, &state));
4378                 }
4379                 strbuf_addf(&buf, " # %s", oneline.buf);
4380
4381                 FLEX_ALLOC_STR(entry, string, buf.buf);
4382                 oidcpy(&entry->entry.oid, &commit->object.oid);
4383                 oidmap_put(&commit2todo, entry);
4384         }
4385
4386         /*
4387          * Second phase:
4388          * - label branch points
4389          * - add HEAD to the branch tips
4390          */
4391         for (iter = commits; iter; iter = iter->next) {
4392                 struct commit_list *parent = iter->item->parents;
4393                 for (; parent; parent = parent->next) {
4394                         struct object_id *oid = &parent->item->object.oid;
4395                         if (!oidset_contains(&interesting, oid))
4396                                 continue;
4397                         if (oidset_insert(&child_seen, oid))
4398                                 label_oid(oid, "branch-point", &state);
4399                 }
4400
4401                 /* Add HEAD as implict "tip of branch" */
4402                 if (!iter->next)
4403                         tips_tail = &commit_list_insert(iter->item,
4404                                                         tips_tail)->next;
4405         }
4406
4407         /*
4408          * Third phase: output the todo list. This is a bit tricky, as we
4409          * want to avoid jumping back and forth between revisions. To
4410          * accomplish that goal, we walk backwards from the branch tips,
4411          * gathering commits not yet shown, reversing the list on the fly,
4412          * then outputting that list (labeling revisions as needed).
4413          */
4414         fprintf(out, "%s onto\n", cmd_label);
4415         for (iter = tips; iter; iter = iter->next) {
4416                 struct commit_list *list = NULL, *iter2;
4417
4418                 commit = iter->item;
4419                 if (oidset_contains(&shown, &commit->object.oid))
4420                         continue;
4421                 entry = oidmap_get(&state.commit2label, &commit->object.oid);
4422
4423                 if (entry)
4424                         fprintf(out, "\n%c Branch %s\n", comment_line_char, entry->string);
4425                 else
4426                         fprintf(out, "\n");
4427
4428                 while (oidset_contains(&interesting, &commit->object.oid) &&
4429                        !oidset_contains(&shown, &commit->object.oid)) {
4430                         commit_list_insert(commit, &list);
4431                         if (!commit->parents) {
4432                                 commit = NULL;
4433                                 break;
4434                         }
4435                         commit = commit->parents->item;
4436                 }
4437
4438                 if (!commit)
4439                         fprintf(out, "%s %s\n", cmd_reset,
4440                                 rebase_cousins ? "onto" : "[new root]");
4441                 else {
4442                         const char *to = NULL;
4443
4444                         entry = oidmap_get(&state.commit2label,
4445                                            &commit->object.oid);
4446                         if (entry)
4447                                 to = entry->string;
4448                         else if (!rebase_cousins)
4449                                 to = label_oid(&commit->object.oid, NULL,
4450                                                &state);
4451
4452                         if (!to || !strcmp(to, "onto"))
4453                                 fprintf(out, "%s onto\n", cmd_reset);
4454                         else {
4455                                 strbuf_reset(&oneline);
4456                                 pretty_print_commit(pp, commit, &oneline);
4457                                 fprintf(out, "%s %s # %s\n",
4458                                         cmd_reset, to, oneline.buf);
4459                         }
4460                 }
4461
4462                 for (iter2 = list; iter2; iter2 = iter2->next) {
4463                         struct object_id *oid = &iter2->item->object.oid;
4464                         entry = oidmap_get(&commit2todo, oid);
4465                         /* only show if not already upstream */
4466                         if (entry)
4467                                 fprintf(out, "%s\n", entry->string);
4468                         entry = oidmap_get(&state.commit2label, oid);
4469                         if (entry)
4470                                 fprintf(out, "%s %s\n",
4471                                         cmd_label, entry->string);
4472                         oidset_insert(&shown, oid);
4473                 }
4474
4475                 free_commit_list(list);
4476         }
4477
4478         free_commit_list(commits);
4479         free_commit_list(tips);
4480
4481         strbuf_release(&label);
4482         strbuf_release(&oneline);
4483         strbuf_release(&buf);
4484
4485         oidmap_free(&commit2todo, 1);
4486         oidmap_free(&state.commit2label, 1);
4487         hashmap_free(&state.labels, 1);
4488         strbuf_release(&state.buf);
4489
4490         return 0;
4491 }
4492
4493 int sequencer_make_script(struct repository *r, FILE *out,
4494                           int argc, const char **argv,
4495                           unsigned flags)
4496 {
4497         char *format = NULL;
4498         struct pretty_print_context pp = {0};
4499         struct strbuf buf = STRBUF_INIT;
4500         struct rev_info revs;
4501         struct commit *commit;
4502         int keep_empty = flags & TODO_LIST_KEEP_EMPTY;
4503         const char *insn = flags & TODO_LIST_ABBREVIATE_CMDS ? "p" : "pick";
4504         int rebase_merges = flags & TODO_LIST_REBASE_MERGES;
4505
4506         repo_init_revisions(r, &revs, NULL);
4507         revs.verbose_header = 1;
4508         if (!rebase_merges)
4509                 revs.max_parents = 1;
4510         revs.cherry_mark = 1;
4511         revs.limited = 1;
4512         revs.reverse = 1;
4513         revs.right_only = 1;
4514         revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
4515         revs.topo_order = 1;
4516
4517         revs.pretty_given = 1;
4518         git_config_get_string("rebase.instructionFormat", &format);
4519         if (!format || !*format) {
4520                 free(format);
4521                 format = xstrdup("%s");
4522         }
4523         get_commit_format(format, &revs);
4524         free(format);
4525         pp.fmt = revs.commit_format;
4526         pp.output_encoding = get_log_output_encoding();
4527
4528         if (setup_revisions(argc, argv, &revs, NULL) > 1)
4529                 return error(_("make_script: unhandled options"));
4530
4531         if (prepare_revision_walk(&revs) < 0)
4532                 return error(_("make_script: error preparing revisions"));
4533
4534         if (rebase_merges)
4535                 return make_script_with_merges(&pp, &revs, out, flags);
4536
4537         while ((commit = get_revision(&revs))) {
4538                 int is_empty  = is_original_commit_empty(commit);
4539
4540                 if (!is_empty && (commit->object.flags & PATCHSAME))
4541                         continue;
4542                 strbuf_reset(&buf);
4543                 if (!keep_empty && is_empty)
4544                         strbuf_addf(&buf, "%c ", comment_line_char);
4545                 strbuf_addf(&buf, "%s %s ", insn,
4546                             oid_to_hex(&commit->object.oid));
4547                 pretty_print_commit(&pp, commit, &buf);
4548                 strbuf_addch(&buf, '\n');
4549                 fputs(buf.buf, out);
4550         }
4551         strbuf_release(&buf);
4552         return 0;
4553 }
4554
4555 /*
4556  * Add commands after pick and (series of) squash/fixup commands
4557  * in the todo list.
4558  */
4559 int sequencer_add_exec_commands(struct repository *r,
4560                                 const char *commands)
4561 {
4562         const char *todo_file = rebase_path_todo();
4563         struct todo_list todo_list = TODO_LIST_INIT;
4564         struct strbuf *buf = &todo_list.buf;
4565         size_t offset = 0, commands_len = strlen(commands);
4566         int i, insert;
4567
4568         if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4569                 return error(_("could not read '%s'."), todo_file);
4570
4571         if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list)) {
4572                 todo_list_release(&todo_list);
4573                 return error(_("unusable todo list: '%s'"), todo_file);
4574         }
4575
4576         /*
4577          * Insert <commands> after every pick. Here, fixup/squash chains
4578          * are considered part of the pick, so we insert the commands *after*
4579          * those chains if there are any.
4580          */
4581         insert = -1;
4582         for (i = 0; i < todo_list.nr; i++) {
4583                 enum todo_command command = todo_list.items[i].command;
4584
4585                 if (insert >= 0) {
4586                         /* skip fixup/squash chains */
4587                         if (command == TODO_COMMENT)
4588                                 continue;
4589                         else if (is_fixup(command)) {
4590                                 insert = i + 1;
4591                                 continue;
4592                         }
4593                         strbuf_insert(buf,
4594                                       todo_list.items[insert].offset_in_buf +
4595                                       offset, commands, commands_len);
4596                         offset += commands_len;
4597                         insert = -1;
4598                 }
4599
4600                 if (command == TODO_PICK || command == TODO_MERGE)
4601                         insert = i + 1;
4602         }
4603
4604         /* insert or append final <commands> */
4605         if (insert >= 0 && insert < todo_list.nr)
4606                 strbuf_insert(buf, todo_list.items[insert].offset_in_buf +
4607                               offset, commands, commands_len);
4608         else if (insert >= 0 || !offset)
4609                 strbuf_add(buf, commands, commands_len);
4610
4611         i = write_message(buf->buf, buf->len, todo_file, 0);
4612         todo_list_release(&todo_list);
4613         return i;
4614 }
4615
4616 int transform_todos(struct repository *r, unsigned flags)
4617 {
4618         const char *todo_file = rebase_path_todo();
4619         struct todo_list todo_list = TODO_LIST_INIT;
4620         struct strbuf buf = STRBUF_INIT;
4621         struct todo_item *item;
4622         int i;
4623
4624         if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)
4625                 return error(_("could not read '%s'."), todo_file);
4626
4627         if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list)) {
4628                 todo_list_release(&todo_list);
4629                 return error(_("unusable todo list: '%s'"), todo_file);
4630         }
4631
4632         for (item = todo_list.items, i = 0; i < todo_list.nr; i++, item++) {
4633                 /* if the item is not a command write it and continue */
4634                 if (item->command >= TODO_COMMENT) {
4635                         strbuf_addf(&buf, "%.*s\n", item->arg_len, item->arg);
4636                         continue;
4637                 }
4638
4639                 /* add command to the buffer */
4640                 if (flags & TODO_LIST_ABBREVIATE_CMDS)
4641                         strbuf_addch(&buf, command_to_char(item->command));
4642                 else
4643                         strbuf_addstr(&buf, command_to_string(item->command));
4644
4645                 /* add commit id */
4646                 if (item->commit) {
4647                         const char *oid = flags & TODO_LIST_SHORTEN_IDS ?
4648                                           short_commit_name(item->commit) :
4649                                           oid_to_hex(&item->commit->object.oid);
4650
4651                         if (item->command == TODO_MERGE) {
4652                                 if (item->flags & TODO_EDIT_MERGE_MSG)
4653                                         strbuf_addstr(&buf, " -c");
4654                                 else
4655                                         strbuf_addstr(&buf, " -C");
4656                         }
4657
4658                         strbuf_addf(&buf, " %s", oid);
4659                 }
4660
4661                 /* add all the rest */
4662                 if (!item->arg_len)
4663                         strbuf_addch(&buf, '\n');
4664                 else
4665                         strbuf_addf(&buf, " %.*s\n", item->arg_len, item->arg);
4666         }
4667
4668         i = write_message(buf.buf, buf.len, todo_file, 0);
4669         todo_list_release(&todo_list);
4670         return i;
4671 }
4672
4673 enum missing_commit_check_level get_missing_commit_check_level(void)
4674 {
4675         const char *value;
4676
4677         if (git_config_get_value("rebase.missingcommitscheck", &value) ||
4678                         !strcasecmp("ignore", value))
4679                 return MISSING_COMMIT_CHECK_IGNORE;
4680         if (!strcasecmp("warn", value))
4681                 return MISSING_COMMIT_CHECK_WARN;
4682         if (!strcasecmp("error", value))
4683                 return MISSING_COMMIT_CHECK_ERROR;
4684         warning(_("unrecognized setting %s for option "
4685                   "rebase.missingCommitsCheck. Ignoring."), value);
4686         return MISSING_COMMIT_CHECK_IGNORE;
4687 }
4688
4689 define_commit_slab(commit_seen, unsigned char);
4690 /*
4691  * Check if the user dropped some commits by mistake
4692  * Behaviour determined by rebase.missingCommitsCheck.
4693  * Check if there is an unrecognized command or a
4694  * bad SHA-1 in a command.
4695  */
4696 int check_todo_list(struct repository *r)
4697 {
4698         enum missing_commit_check_level check_level = get_missing_commit_check_level();
4699         struct strbuf todo_file = STRBUF_INIT;
4700         struct todo_list todo_list = TODO_LIST_INIT;
4701         struct strbuf missing = STRBUF_INIT;
4702         int advise_to_edit_todo = 0, res = 0, i;
4703         struct commit_seen commit_seen;
4704
4705         init_commit_seen(&commit_seen);
4706
4707         strbuf_addstr(&todo_file, rebase_path_todo());
4708         if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4709                 res = -1;
4710                 goto leave_check;
4711         }
4712         advise_to_edit_todo = res =
4713                 parse_insn_buffer(r, todo_list.buf.buf, &todo_list);
4714
4715         if (res || check_level == MISSING_COMMIT_CHECK_IGNORE)
4716                 goto leave_check;
4717
4718         /* Mark the commits in git-rebase-todo as seen */
4719         for (i = 0; i < todo_list.nr; i++) {
4720                 struct commit *commit = todo_list.items[i].commit;
4721                 if (commit)
4722                         *commit_seen_at(&commit_seen, commit) = 1;
4723         }
4724
4725         todo_list_release(&todo_list);
4726         strbuf_addstr(&todo_file, ".backup");
4727         if (strbuf_read_file_or_whine(&todo_list.buf, todo_file.buf) < 0) {
4728                 res = -1;
4729                 goto leave_check;
4730         }
4731         strbuf_release(&todo_file);
4732         res = !!parse_insn_buffer(r, todo_list.buf.buf, &todo_list);
4733
4734         /* Find commits in git-rebase-todo.backup yet unseen */
4735         for (i = todo_list.nr - 1; i >= 0; i--) {
4736                 struct todo_item *item = todo_list.items + i;
4737                 struct commit *commit = item->commit;
4738                 if (commit && !*commit_seen_at(&commit_seen, commit)) {
4739                         strbuf_addf(&missing, " - %s %.*s\n",
4740                                     short_commit_name(commit),
4741                                     item->arg_len, item->arg);
4742                         *commit_seen_at(&commit_seen, commit) = 1;
4743                 }
4744         }
4745
4746         /* Warn about missing commits */
4747         if (!missing.len)
4748                 goto leave_check;
4749
4750         if (check_level == MISSING_COMMIT_CHECK_ERROR)
4751                 advise_to_edit_todo = res = 1;
4752
4753         fprintf(stderr,
4754                 _("Warning: some commits may have been dropped accidentally.\n"
4755                 "Dropped commits (newer to older):\n"));
4756
4757         /* Make the list user-friendly and display */
4758         fputs(missing.buf, stderr);
4759         strbuf_release(&missing);
4760
4761         fprintf(stderr, _("To avoid this message, use \"drop\" to "
4762                 "explicitly remove a commit.\n\n"
4763                 "Use 'git config rebase.missingCommitsCheck' to change "
4764                 "the level of warnings.\n"
4765                 "The possible behaviours are: ignore, warn, error.\n\n"));
4766
4767 leave_check:
4768         clear_commit_seen(&commit_seen);
4769         strbuf_release(&todo_file);
4770         todo_list_release(&todo_list);
4771
4772         if (advise_to_edit_todo)
4773                 fprintf(stderr,
4774                         _("You can fix this with 'git rebase --edit-todo' "
4775                           "and then run 'git rebase --continue'.\n"
4776                           "Or you can abort the rebase with 'git rebase"
4777                           " --abort'.\n"));
4778
4779         return res;
4780 }
4781
4782 static int rewrite_file(const char *path, const char *buf, size_t len)
4783 {
4784         int rc = 0;
4785         int fd = open(path, O_WRONLY | O_TRUNC);
4786         if (fd < 0)
4787                 return error_errno(_("could not open '%s' for writing"), path);
4788         if (write_in_full(fd, buf, len) < 0)
4789                 rc = error_errno(_("could not write to '%s'"), path);
4790         if (close(fd) && !rc)
4791                 rc = error_errno(_("could not close '%s'"), path);
4792         return rc;
4793 }
4794
4795 /* skip picking commits whose parents are unchanged */
4796 static int skip_unnecessary_picks(struct repository *r, struct object_id *output_oid)
4797 {
4798         const char *todo_file = rebase_path_todo();
4799         struct strbuf buf = STRBUF_INIT;
4800         struct todo_list todo_list = TODO_LIST_INIT;
4801         struct object_id *parent_oid;
4802         int fd, i;
4803
4804         if (!read_oneliner(&buf, rebase_path_onto(), 0))
4805                 return error(_("could not read 'onto'"));
4806         if (get_oid(buf.buf, output_oid)) {
4807                 strbuf_release(&buf);
4808                 return error(_("need a HEAD to fixup"));
4809         }
4810         strbuf_release(&buf);
4811
4812         if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
4813                 return -1;
4814         if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list) < 0) {
4815                 todo_list_release(&todo_list);
4816                 return -1;
4817         }
4818
4819         for (i = 0; i < todo_list.nr; i++) {
4820                 struct todo_item *item = todo_list.items + i;
4821
4822                 if (item->command >= TODO_NOOP)
4823                         continue;
4824                 if (item->command != TODO_PICK)
4825                         break;
4826                 if (parse_commit(item->commit)) {
4827                         todo_list_release(&todo_list);
4828                         return error(_("could not parse commit '%s'"),
4829                                 oid_to_hex(&item->commit->object.oid));
4830                 }
4831                 if (!item->commit->parents)
4832                         break; /* root commit */
4833                 if (item->commit->parents->next)
4834                         break; /* merge commit */
4835                 parent_oid = &item->commit->parents->item->object.oid;
4836                 if (!oideq(parent_oid, output_oid))
4837                         break;
4838                 oidcpy(output_oid, &item->commit->object.oid);
4839         }
4840         if (i > 0) {
4841                 int offset = get_item_line_offset(&todo_list, i);
4842                 const char *done_path = rebase_path_done();
4843
4844                 fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
4845                 if (fd < 0) {
4846                         error_errno(_("could not open '%s' for writing"),
4847                                     done_path);
4848                         todo_list_release(&todo_list);
4849                         return -1;
4850                 }
4851                 if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
4852                         error_errno(_("could not write to '%s'"), done_path);
4853                         todo_list_release(&todo_list);
4854                         close(fd);
4855                         return -1;
4856                 }
4857                 close(fd);
4858
4859                 if (rewrite_file(rebase_path_todo(), todo_list.buf.buf + offset,
4860                                  todo_list.buf.len - offset) < 0) {
4861                         todo_list_release(&todo_list);
4862                         return -1;
4863                 }
4864
4865                 todo_list.current = i;
4866                 if (is_fixup(peek_command(&todo_list, 0)))
4867                         record_in_rewritten(output_oid, peek_command(&todo_list, 0));
4868         }
4869
4870         todo_list_release(&todo_list);
4871
4872         return 0;
4873 }
4874
4875 int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
4876                     const char *shortrevisions, const char *onto_name,
4877                     const char *onto, const char *orig_head, const char *cmd,
4878                     unsigned autosquash)
4879 {
4880         const char *shortonto, *todo_file = rebase_path_todo();
4881         struct todo_list todo_list = TODO_LIST_INIT;
4882         struct strbuf *buf = &(todo_list.buf);
4883         struct object_id oid;
4884         struct stat st;
4885
4886         get_oid(onto, &oid);
4887         shortonto = find_unique_abbrev(&oid, DEFAULT_ABBREV);
4888
4889         if (!lstat(todo_file, &st) && st.st_size == 0 &&
4890             write_message("noop\n", 5, todo_file, 0))
4891                 return -1;
4892
4893         if (autosquash && rearrange_squash(r))
4894                 return -1;
4895
4896         if (cmd && *cmd)
4897                 sequencer_add_exec_commands(r, cmd);
4898
4899         if (strbuf_read_file(buf, todo_file, 0) < 0)
4900                 return error_errno(_("could not read '%s'."), todo_file);
4901
4902         if (parse_insn_buffer(r, buf->buf, &todo_list)) {
4903                 todo_list_release(&todo_list);
4904                 return error(_("unusable todo list: '%s'"), todo_file);
4905         }
4906
4907         if (count_commands(&todo_list) == 0) {
4908                 apply_autostash(opts);
4909                 sequencer_remove_state(opts);
4910                 todo_list_release(&todo_list);
4911
4912                 return error(_("nothing to do"));
4913         }
4914
4915         strbuf_addch(buf, '\n');
4916         strbuf_commented_addf(buf, Q_("Rebase %s onto %s (%d command)",
4917                                       "Rebase %s onto %s (%d commands)",
4918                                       count_commands(&todo_list)),
4919                               shortrevisions, shortonto, count_commands(&todo_list));
4920         append_todo_help(0, flags & TODO_LIST_KEEP_EMPTY, buf);
4921
4922         if (write_message(buf->buf, buf->len, todo_file, 0)) {
4923                 todo_list_release(&todo_list);
4924                 return -1;
4925         }
4926
4927         if (copy_file(rebase_path_todo_backup(), todo_file, 0666))
4928                 return error(_("could not copy '%s' to '%s'."), todo_file,
4929                              rebase_path_todo_backup());
4930
4931         if (transform_todos(r, flags | TODO_LIST_SHORTEN_IDS))
4932                 return error(_("could not transform the todo list"));
4933
4934         strbuf_reset(buf);
4935
4936         if (launch_sequence_editor(todo_file, buf, NULL)) {
4937                 apply_autostash(opts);
4938                 sequencer_remove_state(opts);
4939                 todo_list_release(&todo_list);
4940
4941                 return -1;
4942         }
4943
4944         strbuf_stripspace(buf, 1);
4945         if (buf->len == 0) {
4946                 apply_autostash(opts);
4947                 sequencer_remove_state(opts);
4948                 todo_list_release(&todo_list);
4949
4950                 return error(_("nothing to do"));
4951         }
4952
4953         todo_list_release(&todo_list);
4954
4955         if (check_todo_list(r)) {
4956                 checkout_onto(opts, onto_name, onto, orig_head);
4957                 return -1;
4958         }
4959
4960         if (transform_todos(r, flags & ~(TODO_LIST_SHORTEN_IDS)))
4961                 return error(_("could not transform the todo list"));
4962
4963         if (opts->allow_ff && skip_unnecessary_picks(r, &oid))
4964                 return error(_("could not skip unnecessary pick commands"));
4965
4966         if (checkout_onto(opts, onto_name, oid_to_hex(&oid), orig_head))
4967                 return -1;
4968
4969         if (require_clean_work_tree(r, "rebase", "", 1, 1))
4970                 return -1;
4971
4972         return sequencer_continue(r, opts);
4973 }
4974
4975 struct subject2item_entry {
4976         struct hashmap_entry entry;
4977         int i;
4978         char subject[FLEX_ARRAY];
4979 };
4980
4981 static int subject2item_cmp(const void *fndata,
4982                             const struct subject2item_entry *a,
4983                             const struct subject2item_entry *b, const void *key)
4984 {
4985         return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
4986 }
4987
4988 define_commit_slab(commit_todo_item, struct todo_item *);
4989
4990 /*
4991  * Rearrange the todo list that has both "pick commit-id msg" and "pick
4992  * commit-id fixup!/squash! msg" in it so that the latter is put immediately
4993  * after the former, and change "pick" to "fixup"/"squash".
4994  *
4995  * Note that if the config has specified a custom instruction format, each log
4996  * message will have to be retrieved from the commit (as the oneline in the
4997  * script cannot be trusted) in order to normalize the autosquash arrangement.
4998  */
4999 int rearrange_squash(struct repository *r)
5000 {
5001         const char *todo_file = rebase_path_todo();
5002         struct todo_list todo_list = TODO_LIST_INIT;
5003         struct hashmap subject2item;
5004         int res = 0, rearranged = 0, *next, *tail, i;
5005         char **subjects;
5006         struct commit_todo_item commit_todo;
5007
5008         if (strbuf_read_file_or_whine(&todo_list.buf, todo_file) < 0)
5009                 return -1;
5010         if (parse_insn_buffer(r, todo_list.buf.buf, &todo_list) < 0) {
5011                 todo_list_release(&todo_list);
5012                 return -1;
5013         }
5014
5015         init_commit_todo_item(&commit_todo);
5016         /*
5017          * The hashmap maps onelines to the respective todo list index.
5018          *
5019          * If any items need to be rearranged, the next[i] value will indicate
5020          * which item was moved directly after the i'th.
5021          *
5022          * In that case, last[i] will indicate the index of the latest item to
5023          * be moved to appear after the i'th.
5024          */
5025         hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
5026                      NULL, todo_list.nr);
5027         ALLOC_ARRAY(next, todo_list.nr);
5028         ALLOC_ARRAY(tail, todo_list.nr);
5029         ALLOC_ARRAY(subjects, todo_list.nr);
5030         for (i = 0; i < todo_list.nr; i++) {
5031                 struct strbuf buf = STRBUF_INIT;
5032                 struct todo_item *item = todo_list.items + i;
5033                 const char *commit_buffer, *subject, *p;
5034                 size_t subject_len;
5035                 int i2 = -1;
5036                 struct subject2item_entry *entry;
5037
5038                 next[i] = tail[i] = -1;
5039                 if (!item->commit || item->command == TODO_DROP) {
5040                         subjects[i] = NULL;
5041                         continue;
5042                 }
5043
5044                 if (is_fixup(item->command)) {
5045                         todo_list_release(&todo_list);
5046                         clear_commit_todo_item(&commit_todo);
5047                         return error(_("the script was already rearranged."));
5048                 }
5049
5050                 *commit_todo_item_at(&commit_todo, item->commit) = item;
5051
5052                 parse_commit(item->commit);
5053                 commit_buffer = get_commit_buffer(item->commit, NULL);
5054                 find_commit_subject(commit_buffer, &subject);
5055                 format_subject(&buf, subject, " ");
5056                 subject = subjects[i] = strbuf_detach(&buf, &subject_len);
5057                 unuse_commit_buffer(item->commit, commit_buffer);
5058                 if ((skip_prefix(subject, "fixup! ", &p) ||
5059                      skip_prefix(subject, "squash! ", &p))) {
5060                         struct commit *commit2;
5061
5062                         for (;;) {
5063                                 while (isspace(*p))
5064                                         p++;
5065                                 if (!skip_prefix(p, "fixup! ", &p) &&
5066                                     !skip_prefix(p, "squash! ", &p))
5067                                         break;
5068                         }
5069
5070                         if ((entry = hashmap_get_from_hash(&subject2item,
5071                                                            strhash(p), p)))
5072                                 /* found by title */
5073                                 i2 = entry->i;
5074                         else if (!strchr(p, ' ') &&
5075                                  (commit2 =
5076                                   lookup_commit_reference_by_name(p)) &&
5077                                  *commit_todo_item_at(&commit_todo, commit2))
5078                                 /* found by commit name */
5079                                 i2 = *commit_todo_item_at(&commit_todo, commit2)
5080                                         - todo_list.items;
5081                         else {
5082                                 /* copy can be a prefix of the commit subject */
5083                                 for (i2 = 0; i2 < i; i2++)
5084                                         if (subjects[i2] &&
5085                                             starts_with(subjects[i2], p))
5086                                                 break;
5087                                 if (i2 == i)
5088                                         i2 = -1;
5089                         }
5090                 }
5091                 if (i2 >= 0) {
5092                         rearranged = 1;
5093                         todo_list.items[i].command =
5094                                 starts_with(subject, "fixup!") ?
5095                                 TODO_FIXUP : TODO_SQUASH;
5096                         if (next[i2] < 0)
5097                                 next[i2] = i;
5098                         else
5099                                 next[tail[i2]] = i;
5100                         tail[i2] = i;
5101                 } else if (!hashmap_get_from_hash(&subject2item,
5102                                                 strhash(subject), subject)) {
5103                         FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
5104                         entry->i = i;
5105                         hashmap_entry_init(entry, strhash(entry->subject));
5106                         hashmap_put(&subject2item, entry);
5107                 }
5108         }
5109
5110         if (rearranged) {
5111                 struct strbuf buf = STRBUF_INIT;
5112
5113                 for (i = 0; i < todo_list.nr; i++) {
5114                         enum todo_command command = todo_list.items[i].command;
5115                         int cur = i;
5116
5117                         /*
5118                          * Initially, all commands are 'pick's. If it is a
5119                          * fixup or a squash now, we have rearranged it.
5120                          */
5121                         if (is_fixup(command))
5122                                 continue;
5123
5124                         while (cur >= 0) {
5125                                 const char *bol =
5126                                         get_item_line(&todo_list, cur);
5127                                 const char *eol =
5128                                         get_item_line(&todo_list, cur + 1);
5129
5130                                 /* replace 'pick', by 'fixup' or 'squash' */
5131                                 command = todo_list.items[cur].command;
5132                                 if (is_fixup(command)) {
5133                                         strbuf_addstr(&buf,
5134                                                 todo_command_info[command].str);
5135                                         bol += strcspn(bol, " \t");
5136                                 }
5137
5138                                 strbuf_add(&buf, bol, eol - bol);
5139
5140                                 cur = next[cur];
5141                         }
5142                 }
5143
5144                 res = rewrite_file(todo_file, buf.buf, buf.len);
5145                 strbuf_release(&buf);
5146         }
5147
5148         free(next);
5149         free(tail);
5150         for (i = 0; i < todo_list.nr; i++)
5151                 free(subjects[i]);
5152         free(subjects);
5153         hashmap_free(&subject2item, 1);
5154         todo_list_release(&todo_list);
5155
5156         clear_commit_todo_item(&commit_todo);
5157         return res;
5158 }