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