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