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