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