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