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