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