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