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