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