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