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