am: let --signoff override --no-signoff
[git/git.git] / builtin / am.c
CommitLineData
73c2779f
PT
1/*
2 * Builtin "git am"
3 *
4 * Based on git-am.sh by Junio C Hamano.
5 */
6#include "cache.h"
7#include "builtin.h"
8#include "exec_cmd.h"
8c3bd9e2
PT
9#include "parse-options.h"
10#include "dir.h"
11c2177f 11#include "run-command.h"
3e20dcf3 12#include "quote.h"
38a824fe 13#include "lockfile.h"
c9e8d960
PT
14#include "cache-tree.h"
15#include "refs.h"
16#include "commit.h"
32a5fcbf
PT
17#include "diff.h"
18#include "diffcore.h"
9990080c
PT
19#include "unpack-trees.h"
20#include "branch.h"
eb898b83 21#include "sequencer.h"
84f3de28
PT
22#include "revision.h"
23#include "merge-recursive.h"
df2760a5
PT
24#include "revision.h"
25#include "log-tree.h"
88b291fe 26#include "notes-utils.h"
f1cb96d6 27#include "rerere.h"
7ff26832 28#include "prompt.h"
3e20dcf3
PT
29
30/**
31 * Returns 1 if the file is empty or does not exist, 0 otherwise.
32 */
33static int is_empty_file(const char *filename)
34{
35 struct stat st;
36
37 if (stat(filename, &st) < 0) {
38 if (errno == ENOENT)
39 return 1;
40 die_errno(_("could not stat %s"), filename);
41 }
42
43 return !st.st_size;
44}
11c2177f 45
c29807b2
PT
46/**
47 * Like strbuf_getline(), but treats both '\n' and "\r\n" as line terminators.
48 */
49static int strbuf_getline_crlf(struct strbuf *sb, FILE *fp)
50{
51 if (strbuf_getwholeline(sb, fp, '\n'))
52 return EOF;
53 if (sb->buf[sb->len - 1] == '\n') {
54 strbuf_setlen(sb, sb->len - 1);
55 if (sb->len > 0 && sb->buf[sb->len - 1] == '\r')
56 strbuf_setlen(sb, sb->len - 1);
57 }
58 return 0;
59}
60
38a824fe
PT
61/**
62 * Returns the length of the first line of msg.
63 */
64static int linelen(const char *msg)
65{
66 return strchrnul(msg, '\n') - msg;
67}
68
5ae41c79
PT
69/**
70 * Returns true if `str` consists of only whitespace, false otherwise.
71 */
72static int str_isspace(const char *str)
73{
74 for (; *str; str++)
75 if (!isspace(*str))
76 return 0;
77
78 return 1;
79}
80
11c2177f
PT
81enum patch_format {
82 PATCH_FORMAT_UNKNOWN = 0,
5ae41c79 83 PATCH_FORMAT_MBOX,
336108c1 84 PATCH_FORMAT_STGIT,
94cd175c
PT
85 PATCH_FORMAT_STGIT_SERIES,
86 PATCH_FORMAT_HG
11c2177f 87};
8c3bd9e2 88
4f1b6961
PT
89enum keep_type {
90 KEEP_FALSE = 0,
91 KEEP_TRUE, /* pass -k flag to git-mailinfo */
92 KEEP_NON_PATCH /* pass -b flag to git-mailinfo */
93};
94
9b646617
PT
95enum scissors_type {
96 SCISSORS_UNSET = -1,
97 SCISSORS_FALSE = 0, /* pass --no-scissors to git-mailinfo */
98 SCISSORS_TRUE /* pass --scissors to git-mailinfo */
99};
100
b5e82359
PT
101enum signoff_type {
102 SIGNOFF_FALSE = 0,
103 SIGNOFF_TRUE = 1,
104 SIGNOFF_EXPLICIT /* --signoff was set on the command-line */
105};
106
8c3bd9e2
PT
107struct am_state {
108 /* state directory path */
109 char *dir;
110
111 /* current and last patch numbers, 1-indexed */
112 int cur;
113 int last;
11c2177f 114
3e20dcf3
PT
115 /* commit metadata and message */
116 char *author_name;
117 char *author_email;
118 char *author_date;
119 char *msg;
120 size_t msg_len;
121
13b97ea5
PT
122 /* when --rebasing, records the original commit the patch came from */
123 unsigned char orig_commit[GIT_SHA1_RAWSZ];
124
11c2177f
PT
125 /* number of digits in patch filename */
126 int prec;
5d28cf78
PT
127
128 /* various operating modes and command line options */
7ff26832 129 int interactive;
84f3de28 130 int threeway;
5d28cf78 131 int quiet;
b5e82359 132 int signoff; /* enum signoff_type */
ef7ee16d 133 int utf8;
4f1b6961 134 int keep; /* enum keep_type */
702cbaad 135 int message_id;
9b646617 136 int scissors; /* enum scissors_type */
257e8cec 137 struct argv_array git_apply_opts;
2d83109a 138 const char *resolvemsg;
0cd4bcba 139 int committer_date_is_author_date;
f07adb62 140 int ignore_date;
f1cb96d6 141 int allow_rerere_autoupdate;
7e35dacb 142 const char *sign_commit;
35bdcc59 143 int rebasing;
8c3bd9e2
PT
144};
145
146/**
147 * Initializes am_state with the default values. The state directory is set to
148 * dir.
149 */
150static void am_state_init(struct am_state *state, const char *dir)
151{
7e35dacb
PT
152 int gpgsign;
153
8c3bd9e2
PT
154 memset(state, 0, sizeof(*state));
155
156 assert(dir);
157 state->dir = xstrdup(dir);
11c2177f
PT
158
159 state->prec = 4;
ef7ee16d 160
e97a5e76
RL
161 git_config_get_bool("am.threeway", &state->threeway);
162
ef7ee16d 163 state->utf8 = 1;
702cbaad
PT
164
165 git_config_get_bool("am.messageid", &state->message_id);
9b646617
PT
166
167 state->scissors = SCISSORS_UNSET;
257e8cec
PT
168
169 argv_array_init(&state->git_apply_opts);
7e35dacb
PT
170
171 if (!git_config_get_bool("commit.gpgsign", &gpgsign))
172 state->sign_commit = gpgsign ? "" : NULL;
8c3bd9e2
PT
173}
174
175/**
176 * Releases memory allocated by an am_state.
177 */
178static void am_state_release(struct am_state *state)
179{
180 free(state->dir);
3e20dcf3
PT
181 free(state->author_name);
182 free(state->author_email);
183 free(state->author_date);
184 free(state->msg);
257e8cec 185 argv_array_clear(&state->git_apply_opts);
8c3bd9e2
PT
186}
187
188/**
189 * Returns path relative to the am_state directory.
190 */
191static inline const char *am_path(const struct am_state *state, const char *path)
192{
193 return mkpath("%s/%s", state->dir, path);
194}
195
5d28cf78
PT
196/**
197 * If state->quiet is false, calls fprintf(fp, fmt, ...), and appends a newline
198 * at the end.
199 */
200static void say(const struct am_state *state, FILE *fp, const char *fmt, ...)
201{
202 va_list ap;
203
204 va_start(ap, fmt);
205 if (!state->quiet) {
206 vfprintf(fp, fmt, ap);
207 putc('\n', fp);
208 }
209 va_end(ap);
210}
211
8c3bd9e2
PT
212/**
213 * Returns 1 if there is an am session in progress, 0 otherwise.
214 */
215static int am_in_progress(const struct am_state *state)
216{
217 struct stat st;
218
219 if (lstat(state->dir, &st) < 0 || !S_ISDIR(st.st_mode))
220 return 0;
221 if (lstat(am_path(state, "last"), &st) || !S_ISREG(st.st_mode))
222 return 0;
223 if (lstat(am_path(state, "next"), &st) || !S_ISREG(st.st_mode))
224 return 0;
225 return 1;
226}
227
228/**
229 * Reads the contents of `file` in the `state` directory into `sb`. Returns the
230 * number of bytes read on success, -1 if the file does not exist. If `trim` is
231 * set, trailing whitespace will be removed.
232 */
233static int read_state_file(struct strbuf *sb, const struct am_state *state,
234 const char *file, int trim)
235{
236 strbuf_reset(sb);
237
238 if (strbuf_read_file(sb, am_path(state, file), 0) >= 0) {
239 if (trim)
240 strbuf_trim(sb);
241
242 return sb->len;
243 }
244
245 if (errno == ENOENT)
246 return -1;
247
248 die_errno(_("could not read '%s'"), am_path(state, file));
249}
250
3e20dcf3
PT
251/**
252 * Reads a KEY=VALUE shell variable assignment from `fp`, returning the VALUE
253 * as a newly-allocated string. VALUE must be a quoted string, and the KEY must
254 * match `key`. Returns NULL on failure.
255 *
256 * This is used by read_author_script() to read the GIT_AUTHOR_* variables from
257 * the author-script.
258 */
259static char *read_shell_var(FILE *fp, const char *key)
260{
261 struct strbuf sb = STRBUF_INIT;
262 const char *str;
263
264 if (strbuf_getline(&sb, fp, '\n'))
265 goto fail;
266
267 if (!skip_prefix(sb.buf, key, &str))
268 goto fail;
269
270 if (!skip_prefix(str, "=", &str))
271 goto fail;
272
273 strbuf_remove(&sb, 0, str - sb.buf);
274
275 str = sq_dequote(sb.buf);
276 if (!str)
277 goto fail;
278
279 return strbuf_detach(&sb, NULL);
280
281fail:
282 strbuf_release(&sb);
283 return NULL;
284}
285
286/**
287 * Reads and parses the state directory's "author-script" file, and sets
288 * state->author_name, state->author_email and state->author_date accordingly.
289 * Returns 0 on success, -1 if the file could not be parsed.
290 *
291 * The author script is of the format:
292 *
293 * GIT_AUTHOR_NAME='$author_name'
294 * GIT_AUTHOR_EMAIL='$author_email'
295 * GIT_AUTHOR_DATE='$author_date'
296 *
297 * where $author_name, $author_email and $author_date are quoted. We are strict
298 * with our parsing, as the file was meant to be eval'd in the old git-am.sh
299 * script, and thus if the file differs from what this function expects, it is
300 * better to bail out than to do something that the user does not expect.
301 */
302static int read_author_script(struct am_state *state)
303{
304 const char *filename = am_path(state, "author-script");
305 FILE *fp;
306
307 assert(!state->author_name);
308 assert(!state->author_email);
309 assert(!state->author_date);
310
311 fp = fopen(filename, "r");
312 if (!fp) {
313 if (errno == ENOENT)
314 return 0;
315 die_errno(_("could not open '%s' for reading"), filename);
316 }
317
318 state->author_name = read_shell_var(fp, "GIT_AUTHOR_NAME");
319 if (!state->author_name) {
320 fclose(fp);
321 return -1;
322 }
323
324 state->author_email = read_shell_var(fp, "GIT_AUTHOR_EMAIL");
325 if (!state->author_email) {
326 fclose(fp);
327 return -1;
328 }
329
330 state->author_date = read_shell_var(fp, "GIT_AUTHOR_DATE");
331 if (!state->author_date) {
332 fclose(fp);
333 return -1;
334 }
335
336 if (fgetc(fp) != EOF) {
337 fclose(fp);
338 return -1;
339 }
340
341 fclose(fp);
342 return 0;
343}
344
345/**
346 * Saves state->author_name, state->author_email and state->author_date in the
347 * state directory's "author-script" file.
348 */
349static void write_author_script(const struct am_state *state)
350{
351 struct strbuf sb = STRBUF_INIT;
352
353 strbuf_addstr(&sb, "GIT_AUTHOR_NAME=");
354 sq_quote_buf(&sb, state->author_name);
355 strbuf_addch(&sb, '\n');
356
357 strbuf_addstr(&sb, "GIT_AUTHOR_EMAIL=");
358 sq_quote_buf(&sb, state->author_email);
359 strbuf_addch(&sb, '\n');
360
361 strbuf_addstr(&sb, "GIT_AUTHOR_DATE=");
362 sq_quote_buf(&sb, state->author_date);
363 strbuf_addch(&sb, '\n');
364
365 write_file(am_path(state, "author-script"), 1, "%s", sb.buf);
366
367 strbuf_release(&sb);
368}
369
370/**
371 * Reads the commit message from the state directory's "final-commit" file,
372 * setting state->msg to its contents and state->msg_len to the length of its
373 * contents in bytes.
374 *
375 * Returns 0 on success, -1 if the file does not exist.
376 */
377static int read_commit_msg(struct am_state *state)
378{
379 struct strbuf sb = STRBUF_INIT;
380
381 assert(!state->msg);
382
383 if (read_state_file(&sb, state, "final-commit", 0) < 0) {
384 strbuf_release(&sb);
385 return -1;
386 }
387
388 state->msg = strbuf_detach(&sb, &state->msg_len);
389 return 0;
390}
391
392/**
393 * Saves state->msg in the state directory's "final-commit" file.
394 */
395static void write_commit_msg(const struct am_state *state)
396{
397 int fd;
398 const char *filename = am_path(state, "final-commit");
399
400 fd = xopen(filename, O_WRONLY | O_CREAT, 0666);
401 if (write_in_full(fd, state->msg, state->msg_len) < 0)
402 die_errno(_("could not write to %s"), filename);
403 close(fd);
404}
405
8c3bd9e2
PT
406/**
407 * Loads state from disk.
408 */
409static void am_load(struct am_state *state)
410{
411 struct strbuf sb = STRBUF_INIT;
412
413 if (read_state_file(&sb, state, "next", 1) < 0)
414 die("BUG: state file 'next' does not exist");
415 state->cur = strtol(sb.buf, NULL, 10);
416
417 if (read_state_file(&sb, state, "last", 1) < 0)
418 die("BUG: state file 'last' does not exist");
419 state->last = strtol(sb.buf, NULL, 10);
420
3e20dcf3
PT
421 if (read_author_script(state) < 0)
422 die(_("could not parse author script"));
423
424 read_commit_msg(state);
425
13b97ea5
PT
426 if (read_state_file(&sb, state, "original-commit", 1) < 0)
427 hashclr(state->orig_commit);
428 else if (get_sha1_hex(sb.buf, state->orig_commit) < 0)
429 die(_("could not parse %s"), am_path(state, "original-commit"));
430
84f3de28
PT
431 read_state_file(&sb, state, "threeway", 1);
432 state->threeway = !strcmp(sb.buf, "t");
433
5d28cf78
PT
434 read_state_file(&sb, state, "quiet", 1);
435 state->quiet = !strcmp(sb.buf, "t");
436
eb898b83
PT
437 read_state_file(&sb, state, "sign", 1);
438 state->signoff = !strcmp(sb.buf, "t");
439
ef7ee16d
PT
440 read_state_file(&sb, state, "utf8", 1);
441 state->utf8 = !strcmp(sb.buf, "t");
442
4f1b6961
PT
443 read_state_file(&sb, state, "keep", 1);
444 if (!strcmp(sb.buf, "t"))
445 state->keep = KEEP_TRUE;
446 else if (!strcmp(sb.buf, "b"))
447 state->keep = KEEP_NON_PATCH;
448 else
449 state->keep = KEEP_FALSE;
450
702cbaad
PT
451 read_state_file(&sb, state, "messageid", 1);
452 state->message_id = !strcmp(sb.buf, "t");
453
9b646617
PT
454 read_state_file(&sb, state, "scissors", 1);
455 if (!strcmp(sb.buf, "t"))
456 state->scissors = SCISSORS_TRUE;
457 else if (!strcmp(sb.buf, "f"))
458 state->scissors = SCISSORS_FALSE;
459 else
460 state->scissors = SCISSORS_UNSET;
461
257e8cec
PT
462 read_state_file(&sb, state, "apply-opt", 1);
463 argv_array_clear(&state->git_apply_opts);
464 if (sq_dequote_to_argv_array(sb.buf, &state->git_apply_opts) < 0)
465 die(_("could not parse %s"), am_path(state, "apply-opt"));
466
35bdcc59
PT
467 state->rebasing = !!file_exists(am_path(state, "rebasing"));
468
8c3bd9e2
PT
469 strbuf_release(&sb);
470}
471
472/**
473 * Removes the am_state directory, forcefully terminating the current am
474 * session.
475 */
476static void am_destroy(const struct am_state *state)
477{
478 struct strbuf sb = STRBUF_INIT;
479
480 strbuf_addstr(&sb, state->dir);
481 remove_dir_recursively(&sb, 0);
482 strbuf_release(&sb);
483}
484
b8803d8f
PT
485/**
486 * Runs applypatch-msg hook. Returns its exit code.
487 */
488static int run_applypatch_msg_hook(struct am_state *state)
489{
490 int ret;
491
492 assert(state->msg);
493 ret = run_hook_le(NULL, "applypatch-msg", am_path(state, "final-commit"), NULL);
494
495 if (!ret) {
496 free(state->msg);
497 state->msg = NULL;
498 if (read_commit_msg(state) < 0)
499 die(_("'%s' was deleted by the applypatch-msg hook"),
500 am_path(state, "final-commit"));
501 }
502
503 return ret;
504}
505
13b97ea5
PT
506/**
507 * Runs post-rewrite hook. Returns it exit code.
508 */
509static int run_post_rewrite_hook(const struct am_state *state)
510{
511 struct child_process cp = CHILD_PROCESS_INIT;
512 const char *hook = find_hook("post-rewrite");
513 int ret;
514
515 if (!hook)
516 return 0;
517
518 argv_array_push(&cp.args, hook);
519 argv_array_push(&cp.args, "rebase");
520
521 cp.in = xopen(am_path(state, "rewritten"), O_RDONLY);
522 cp.stdout_to_stderr = 1;
523
524 ret = run_command(&cp);
525
526 close(cp.in);
527 return ret;
528}
529
88b291fe
PT
530/**
531 * Reads the state directory's "rewritten" file, and copies notes from the old
532 * commits listed in the file to their rewritten commits.
533 *
534 * Returns 0 on success, -1 on failure.
535 */
536static int copy_notes_for_rebase(const struct am_state *state)
537{
538 struct notes_rewrite_cfg *c;
539 struct strbuf sb = STRBUF_INIT;
540 const char *invalid_line = _("Malformed input line: '%s'.");
541 const char *msg = "Notes added by 'git rebase'";
542 FILE *fp;
543 int ret = 0;
544
545 assert(state->rebasing);
546
547 c = init_copy_notes_for_rewrite("rebase");
548 if (!c)
549 return 0;
550
551 fp = xfopen(am_path(state, "rewritten"), "r");
552
553 while (!strbuf_getline(&sb, fp, '\n')) {
554 unsigned char from_obj[GIT_SHA1_RAWSZ], to_obj[GIT_SHA1_RAWSZ];
555
556 if (sb.len != GIT_SHA1_HEXSZ * 2 + 1) {
557 ret = error(invalid_line, sb.buf);
558 goto finish;
559 }
560
561 if (get_sha1_hex(sb.buf, from_obj)) {
562 ret = error(invalid_line, sb.buf);
563 goto finish;
564 }
565
566 if (sb.buf[GIT_SHA1_HEXSZ] != ' ') {
567 ret = error(invalid_line, sb.buf);
568 goto finish;
569 }
570
571 if (get_sha1_hex(sb.buf + GIT_SHA1_HEXSZ + 1, to_obj)) {
572 ret = error(invalid_line, sb.buf);
573 goto finish;
574 }
575
576 if (copy_note_for_rewrite(c, from_obj, to_obj))
577 ret = error(_("Failed to copy notes from '%s' to '%s'"),
578 sha1_to_hex(from_obj), sha1_to_hex(to_obj));
579 }
580
581finish:
582 finish_copy_notes_for_rewrite(c, msg);
583 fclose(fp);
584 strbuf_release(&sb);
585 return ret;
586}
587
c29807b2
PT
588/**
589 * Determines if the file looks like a piece of RFC2822 mail by grabbing all
590 * non-indented lines and checking if they look like they begin with valid
591 * header field names.
592 *
593 * Returns 1 if the file looks like a piece of mail, 0 otherwise.
594 */
595static int is_mail(FILE *fp)
596{
597 const char *header_regex = "^[!-9;-~]+:";
598 struct strbuf sb = STRBUF_INIT;
599 regex_t regex;
600 int ret = 1;
601
602 if (fseek(fp, 0L, SEEK_SET))
603 die_errno(_("fseek failed"));
604
605 if (regcomp(&regex, header_regex, REG_NOSUB | REG_EXTENDED))
606 die("invalid pattern: %s", header_regex);
607
608 while (!strbuf_getline_crlf(&sb, fp)) {
609 if (!sb.len)
610 break; /* End of header */
611
612 /* Ignore indented folded lines */
613 if (*sb.buf == '\t' || *sb.buf == ' ')
614 continue;
615
616 /* It's a header if it matches header_regex */
617 if (regexec(&regex, sb.buf, 0, NULL, 0)) {
618 ret = 0;
619 goto done;
620 }
621 }
622
623done:
624 regfree(&regex);
625 strbuf_release(&sb);
626 return ret;
627}
628
629/**
630 * Attempts to detect the patch_format of the patches contained in `paths`,
631 * returning the PATCH_FORMAT_* enum value. Returns PATCH_FORMAT_UNKNOWN if
632 * detection fails.
633 */
634static int detect_patch_format(const char **paths)
635{
636 enum patch_format ret = PATCH_FORMAT_UNKNOWN;
637 struct strbuf l1 = STRBUF_INIT;
5ae41c79
PT
638 struct strbuf l2 = STRBUF_INIT;
639 struct strbuf l3 = STRBUF_INIT;
c29807b2
PT
640 FILE *fp;
641
642 /*
643 * We default to mbox format if input is from stdin and for directories
644 */
645 if (!*paths || !strcmp(*paths, "-") || is_directory(*paths))
646 return PATCH_FORMAT_MBOX;
647
648 /*
649 * Otherwise, check the first few lines of the first patch, starting
650 * from the first non-blank line, to try to detect its format.
651 */
652
653 fp = xfopen(*paths, "r");
654
655 while (!strbuf_getline_crlf(&l1, fp)) {
656 if (l1.len)
657 break;
658 }
659
660 if (starts_with(l1.buf, "From ") || starts_with(l1.buf, "From: ")) {
661 ret = PATCH_FORMAT_MBOX;
662 goto done;
663 }
664
336108c1
PT
665 if (starts_with(l1.buf, "# This series applies on GIT commit")) {
666 ret = PATCH_FORMAT_STGIT_SERIES;
667 goto done;
668 }
669
94cd175c
PT
670 if (!strcmp(l1.buf, "# HG changeset patch")) {
671 ret = PATCH_FORMAT_HG;
672 goto done;
673 }
674
5ae41c79
PT
675 strbuf_reset(&l2);
676 strbuf_getline_crlf(&l2, fp);
677 strbuf_reset(&l3);
678 strbuf_getline_crlf(&l3, fp);
679
680 /*
681 * If the second line is empty and the third is a From, Author or Date
682 * entry, this is likely an StGit patch.
683 */
684 if (l1.len && !l2.len &&
685 (starts_with(l3.buf, "From:") ||
686 starts_with(l3.buf, "Author:") ||
687 starts_with(l3.buf, "Date:"))) {
688 ret = PATCH_FORMAT_STGIT;
689 goto done;
690 }
691
c29807b2
PT
692 if (l1.len && is_mail(fp)) {
693 ret = PATCH_FORMAT_MBOX;
694 goto done;
695 }
696
697done:
698 fclose(fp);
699 strbuf_release(&l1);
700 return ret;
701}
702
11c2177f
PT
703/**
704 * Splits out individual email patches from `paths`, where each path is either
705 * a mbox file or a Maildir. Returns 0 on success, -1 on failure.
706 */
5d123a40 707static int split_mail_mbox(struct am_state *state, const char **paths, int keep_cr)
11c2177f
PT
708{
709 struct child_process cp = CHILD_PROCESS_INIT;
710 struct strbuf last = STRBUF_INIT;
711
712 cp.git_cmd = 1;
713 argv_array_push(&cp.args, "mailsplit");
714 argv_array_pushf(&cp.args, "-d%d", state->prec);
715 argv_array_pushf(&cp.args, "-o%s", state->dir);
716 argv_array_push(&cp.args, "-b");
5d123a40
PT
717 if (keep_cr)
718 argv_array_push(&cp.args, "--keep-cr");
11c2177f
PT
719 argv_array_push(&cp.args, "--");
720 argv_array_pushv(&cp.args, paths);
721
722 if (capture_command(&cp, &last, 8))
723 return -1;
724
725 state->cur = 1;
726 state->last = strtol(last.buf, NULL, 10);
727
728 return 0;
729}
730
5ae41c79
PT
731/**
732 * Callback signature for split_mail_conv(). The foreign patch should be
733 * read from `in`, and the converted patch (in RFC2822 mail format) should be
734 * written to `out`. Return 0 on success, or -1 on failure.
735 */
736typedef int (*mail_conv_fn)(FILE *out, FILE *in, int keep_cr);
737
738/**
739 * Calls `fn` for each file in `paths` to convert the foreign patch to the
740 * RFC2822 mail format suitable for parsing with git-mailinfo.
741 *
742 * Returns 0 on success, -1 on failure.
743 */
744static int split_mail_conv(mail_conv_fn fn, struct am_state *state,
745 const char **paths, int keep_cr)
746{
747 static const char *stdin_only[] = {"-", NULL};
748 int i;
749
750 if (!*paths)
751 paths = stdin_only;
752
753 for (i = 0; *paths; paths++, i++) {
754 FILE *in, *out;
755 const char *mail;
756 int ret;
757
758 if (!strcmp(*paths, "-"))
759 in = stdin;
760 else
761 in = fopen(*paths, "r");
762
763 if (!in)
764 return error(_("could not open '%s' for reading: %s"),
765 *paths, strerror(errno));
766
767 mail = mkpath("%s/%0*d", state->dir, state->prec, i + 1);
768
769 out = fopen(mail, "w");
770 if (!out)
771 return error(_("could not open '%s' for writing: %s"),
772 mail, strerror(errno));
773
774 ret = fn(out, in, keep_cr);
775
776 fclose(out);
777 fclose(in);
778
779 if (ret)
780 return error(_("could not parse patch '%s'"), *paths);
781 }
782
783 state->cur = 1;
784 state->last = i;
785 return 0;
786}
787
788/**
789 * A split_mail_conv() callback that converts an StGit patch to an RFC2822
790 * message suitable for parsing with git-mailinfo.
791 */
792static int stgit_patch_to_mail(FILE *out, FILE *in, int keep_cr)
793{
794 struct strbuf sb = STRBUF_INIT;
795 int subject_printed = 0;
796
797 while (!strbuf_getline(&sb, in, '\n')) {
798 const char *str;
799
800 if (str_isspace(sb.buf))
801 continue;
802 else if (skip_prefix(sb.buf, "Author:", &str))
803 fprintf(out, "From:%s\n", str);
804 else if (starts_with(sb.buf, "From") || starts_with(sb.buf, "Date"))
805 fprintf(out, "%s\n", sb.buf);
806 else if (!subject_printed) {
807 fprintf(out, "Subject: %s\n", sb.buf);
808 subject_printed = 1;
809 } else {
810 fprintf(out, "\n%s\n", sb.buf);
811 break;
812 }
813 }
814
815 strbuf_reset(&sb);
816 while (strbuf_fread(&sb, 8192, in) > 0) {
817 fwrite(sb.buf, 1, sb.len, out);
818 strbuf_reset(&sb);
819 }
820
821 strbuf_release(&sb);
822 return 0;
823}
824
336108c1
PT
825/**
826 * This function only supports a single StGit series file in `paths`.
827 *
828 * Given an StGit series file, converts the StGit patches in the series into
829 * RFC2822 messages suitable for parsing with git-mailinfo, and queues them in
830 * the state directory.
831 *
832 * Returns 0 on success, -1 on failure.
833 */
834static int split_mail_stgit_series(struct am_state *state, const char **paths,
835 int keep_cr)
836{
837 const char *series_dir;
838 char *series_dir_buf;
839 FILE *fp;
840 struct argv_array patches = ARGV_ARRAY_INIT;
841 struct strbuf sb = STRBUF_INIT;
842 int ret;
843
844 if (!paths[0] || paths[1])
845 return error(_("Only one StGIT patch series can be applied at once"));
846
847 series_dir_buf = xstrdup(*paths);
848 series_dir = dirname(series_dir_buf);
849
850 fp = fopen(*paths, "r");
851 if (!fp)
852 return error(_("could not open '%s' for reading: %s"), *paths,
853 strerror(errno));
854
855 while (!strbuf_getline(&sb, fp, '\n')) {
856 if (*sb.buf == '#')
857 continue; /* skip comment lines */
858
859 argv_array_push(&patches, mkpath("%s/%s", series_dir, sb.buf));
860 }
861
862 fclose(fp);
863 strbuf_release(&sb);
864 free(series_dir_buf);
865
866 ret = split_mail_conv(stgit_patch_to_mail, state, patches.argv, keep_cr);
867
868 argv_array_clear(&patches);
869 return ret;
870}
871
94cd175c
PT
872/**
873 * A split_patches_conv() callback that converts a mercurial patch to a RFC2822
874 * message suitable for parsing with git-mailinfo.
875 */
876static int hg_patch_to_mail(FILE *out, FILE *in, int keep_cr)
877{
878 struct strbuf sb = STRBUF_INIT;
879
880 while (!strbuf_getline(&sb, in, '\n')) {
881 const char *str;
882
883 if (skip_prefix(sb.buf, "# User ", &str))
884 fprintf(out, "From: %s\n", str);
885 else if (skip_prefix(sb.buf, "# Date ", &str)) {
886 unsigned long timestamp;
887 long tz, tz2;
888 char *end;
889
890 errno = 0;
891 timestamp = strtoul(str, &end, 10);
892 if (errno)
893 return error(_("invalid timestamp"));
894
895 if (!skip_prefix(end, " ", &str))
896 return error(_("invalid Date line"));
897
898 errno = 0;
899 tz = strtol(str, &end, 10);
900 if (errno)
901 return error(_("invalid timezone offset"));
902
903 if (*end)
904 return error(_("invalid Date line"));
905
906 /*
907 * mercurial's timezone is in seconds west of UTC,
908 * however git's timezone is in hours + minutes east of
909 * UTC. Convert it.
910 */
911 tz2 = labs(tz) / 3600 * 100 + labs(tz) % 3600 / 60;
912 if (tz > 0)
913 tz2 = -tz2;
914
915 fprintf(out, "Date: %s\n", show_date(timestamp, tz2, DATE_MODE(RFC2822)));
916 } else if (starts_with(sb.buf, "# ")) {
917 continue;
918 } else {
919 fprintf(out, "\n%s\n", sb.buf);
920 break;
921 }
922 }
923
924 strbuf_reset(&sb);
925 while (strbuf_fread(&sb, 8192, in) > 0) {
926 fwrite(sb.buf, 1, sb.len, out);
927 strbuf_reset(&sb);
928 }
929
930 strbuf_release(&sb);
931 return 0;
932}
933
11c2177f
PT
934/**
935 * Splits a list of files/directories into individual email patches. Each path
936 * in `paths` must be a file/directory that is formatted according to
937 * `patch_format`.
938 *
939 * Once split out, the individual email patches will be stored in the state
940 * directory, with each patch's filename being its index, padded to state->prec
941 * digits.
942 *
943 * state->cur will be set to the index of the first mail, and state->last will
944 * be set to the index of the last mail.
945 *
5d123a40
PT
946 * Set keep_cr to 0 to convert all lines ending with \r\n to end with \n, 1
947 * to disable this behavior, -1 to use the default configured setting.
948 *
11c2177f
PT
949 * Returns 0 on success, -1 on failure.
950 */
951static int split_mail(struct am_state *state, enum patch_format patch_format,
5d123a40 952 const char **paths, int keep_cr)
11c2177f 953{
5d123a40
PT
954 if (keep_cr < 0) {
955 keep_cr = 0;
956 git_config_get_bool("am.keepcr", &keep_cr);
957 }
958
11c2177f
PT
959 switch (patch_format) {
960 case PATCH_FORMAT_MBOX:
5d123a40 961 return split_mail_mbox(state, paths, keep_cr);
5ae41c79
PT
962 case PATCH_FORMAT_STGIT:
963 return split_mail_conv(stgit_patch_to_mail, state, paths, keep_cr);
336108c1
PT
964 case PATCH_FORMAT_STGIT_SERIES:
965 return split_mail_stgit_series(state, paths, keep_cr);
94cd175c
PT
966 case PATCH_FORMAT_HG:
967 return split_mail_conv(hg_patch_to_mail, state, paths, keep_cr);
11c2177f
PT
968 default:
969 die("BUG: invalid patch_format");
970 }
971 return -1;
972}
973
8c3bd9e2
PT
974/**
975 * Setup a new am session for applying patches
976 */
11c2177f 977static void am_setup(struct am_state *state, enum patch_format patch_format,
5d123a40 978 const char **paths, int keep_cr)
8c3bd9e2 979{
33388a71 980 unsigned char curr_head[GIT_SHA1_RAWSZ];
4f1b6961 981 const char *str;
257e8cec 982 struct strbuf sb = STRBUF_INIT;
33388a71 983
c29807b2
PT
984 if (!patch_format)
985 patch_format = detect_patch_format(paths);
986
987 if (!patch_format) {
988 fprintf_ln(stderr, _("Patch format detection failed."));
989 exit(128);
990 }
991
8c3bd9e2
PT
992 if (mkdir(state->dir, 0777) < 0 && errno != EEXIST)
993 die_errno(_("failed to create directory '%s'"), state->dir);
994
5d123a40 995 if (split_mail(state, patch_format, paths, keep_cr) < 0) {
11c2177f
PT
996 am_destroy(state);
997 die(_("Failed to split patches."));
998 }
999
35bdcc59
PT
1000 if (state->rebasing)
1001 state->threeway = 1;
1002
84f3de28
PT
1003 write_file(am_path(state, "threeway"), 1, state->threeway ? "t" : "f");
1004
5d28cf78
PT
1005 write_file(am_path(state, "quiet"), 1, state->quiet ? "t" : "f");
1006
eb898b83
PT
1007 write_file(am_path(state, "sign"), 1, state->signoff ? "t" : "f");
1008
ef7ee16d
PT
1009 write_file(am_path(state, "utf8"), 1, state->utf8 ? "t" : "f");
1010
4f1b6961
PT
1011 switch (state->keep) {
1012 case KEEP_FALSE:
1013 str = "f";
1014 break;
1015 case KEEP_TRUE:
1016 str = "t";
1017 break;
1018 case KEEP_NON_PATCH:
1019 str = "b";
1020 break;
1021 default:
1022 die("BUG: invalid value for state->keep");
1023 }
1024
1025 write_file(am_path(state, "keep"), 1, "%s", str);
1026
702cbaad
PT
1027 write_file(am_path(state, "messageid"), 1, state->message_id ? "t" : "f");
1028
9b646617
PT
1029 switch (state->scissors) {
1030 case SCISSORS_UNSET:
1031 str = "";
1032 break;
1033 case SCISSORS_FALSE:
1034 str = "f";
1035 break;
1036 case SCISSORS_TRUE:
1037 str = "t";
1038 break;
1039 default:
1040 die("BUG: invalid value for state->scissors");
1041 }
1042
1043 write_file(am_path(state, "scissors"), 1, "%s", str);
1044
257e8cec
PT
1045 sq_quote_argv(&sb, state->git_apply_opts.argv, 0);
1046 write_file(am_path(state, "apply-opt"), 1, "%s", sb.buf);
1047
35bdcc59
PT
1048 if (state->rebasing)
1049 write_file(am_path(state, "rebasing"), 1, "%s", "");
1050 else
1051 write_file(am_path(state, "applying"), 1, "%s", "");
1052
33388a71
PT
1053 if (!get_sha1("HEAD", curr_head)) {
1054 write_file(am_path(state, "abort-safety"), 1, "%s", sha1_to_hex(curr_head));
35bdcc59
PT
1055 if (!state->rebasing)
1056 update_ref("am", "ORIG_HEAD", curr_head, NULL, 0,
1057 UPDATE_REFS_DIE_ON_ERR);
33388a71
PT
1058 } else {
1059 write_file(am_path(state, "abort-safety"), 1, "%s", "");
35bdcc59
PT
1060 if (!state->rebasing)
1061 delete_ref("ORIG_HEAD", NULL, 0);
33388a71
PT
1062 }
1063
8c3bd9e2
PT
1064 /*
1065 * NOTE: Since the "next" and "last" files determine if an am_state
1066 * session is in progress, they should be written last.
1067 */
1068
1069 write_file(am_path(state, "next"), 1, "%d", state->cur);
1070
1071 write_file(am_path(state, "last"), 1, "%d", state->last);
257e8cec
PT
1072
1073 strbuf_release(&sb);
8c3bd9e2
PT
1074}
1075
1076/**
1077 * Increments the patch pointer, and cleans am_state for the application of the
1078 * next patch.
1079 */
1080static void am_next(struct am_state *state)
1081{
33388a71
PT
1082 unsigned char head[GIT_SHA1_RAWSZ];
1083
3e20dcf3
PT
1084 free(state->author_name);
1085 state->author_name = NULL;
1086
1087 free(state->author_email);
1088 state->author_email = NULL;
1089
1090 free(state->author_date);
1091 state->author_date = NULL;
1092
1093 free(state->msg);
1094 state->msg = NULL;
1095 state->msg_len = 0;
1096
1097 unlink(am_path(state, "author-script"));
1098 unlink(am_path(state, "final-commit"));
1099
13b97ea5
PT
1100 hashclr(state->orig_commit);
1101 unlink(am_path(state, "original-commit"));
1102
33388a71
PT
1103 if (!get_sha1("HEAD", head))
1104 write_file(am_path(state, "abort-safety"), 1, "%s", sha1_to_hex(head));
1105 else
1106 write_file(am_path(state, "abort-safety"), 1, "%s", "");
1107
8c3bd9e2
PT
1108 state->cur++;
1109 write_file(am_path(state, "next"), 1, "%d", state->cur);
1110}
1111
3e20dcf3
PT
1112/**
1113 * Returns the filename of the current patch email.
1114 */
1115static const char *msgnum(const struct am_state *state)
1116{
1117 static struct strbuf sb = STRBUF_INIT;
1118
1119 strbuf_reset(&sb);
1120 strbuf_addf(&sb, "%0*d", state->prec, state->cur);
1121
1122 return sb.buf;
1123}
1124
38a824fe
PT
1125/**
1126 * Refresh and write index.
1127 */
1128static void refresh_and_write_cache(void)
1129{
1130 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
1131
1132 hold_locked_index(lock_file, 1);
1133 refresh_cache(REFRESH_QUIET);
1134 if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))
1135 die(_("unable to write index file"));
1136}
1137
32a5fcbf
PT
1138/**
1139 * Returns 1 if the index differs from HEAD, 0 otherwise. When on an unborn
1140 * branch, returns 1 if there are entries in the index, 0 otherwise. If an
1141 * strbuf is provided, the space-separated list of files that differ will be
1142 * appended to it.
1143 */
1144static int index_has_changes(struct strbuf *sb)
1145{
1146 unsigned char head[GIT_SHA1_RAWSZ];
1147 int i;
1148
1149 if (!get_sha1_tree("HEAD", head)) {
1150 struct diff_options opt;
1151
1152 diff_setup(&opt);
1153 DIFF_OPT_SET(&opt, EXIT_WITH_STATUS);
1154 if (!sb)
1155 DIFF_OPT_SET(&opt, QUICK);
1156 do_diff_cache(head, &opt);
1157 diffcore_std(&opt);
1158 for (i = 0; sb && i < diff_queued_diff.nr; i++) {
1159 if (i)
1160 strbuf_addch(sb, ' ');
1161 strbuf_addstr(sb, diff_queued_diff.queue[i]->two->path);
1162 }
1163 diff_flush(&opt);
1164 return DIFF_OPT_TST(&opt, HAS_CHANGES) != 0;
1165 } else {
1166 for (i = 0; sb && i < active_nr; i++) {
1167 if (i)
1168 strbuf_addch(sb, ' ');
1169 strbuf_addstr(sb, active_cache[i]->name);
1170 }
1171 return !!active_nr;
1172 }
1173}
1174
2d83109a
PT
1175/**
1176 * Dies with a user-friendly message on how to proceed after resolving the
1177 * problem. This message can be overridden with state->resolvemsg.
1178 */
1179static void NORETURN die_user_resolve(const struct am_state *state)
1180{
1181 if (state->resolvemsg) {
1182 printf_ln("%s", state->resolvemsg);
1183 } else {
7ff26832 1184 const char *cmdline = state->interactive ? "git am -i" : "git am";
2d83109a
PT
1185
1186 printf_ln(_("When you have resolved this problem, run \"%s --continue\"."), cmdline);
1187 printf_ln(_("If you prefer to skip this patch, run \"%s --skip\" instead."), cmdline);
1188 printf_ln(_("To restore the original branch and stop patching, run \"%s --abort\"."), cmdline);
1189 }
1190
1191 exit(128);
1192}
1193
b5e82359
PT
1194/**
1195 * Appends signoff to the "msg" field of the am_state.
1196 */
1197static void am_append_signoff(struct am_state *state)
1198{
1199 struct strbuf sb = STRBUF_INIT;
1200
1201 strbuf_attach(&sb, state->msg, state->msg_len, state->msg_len);
1202 append_signoff(&sb, 0, 0);
1203 state->msg = strbuf_detach(&sb, &state->msg_len);
1204}
1205
3e20dcf3
PT
1206/**
1207 * Parses `mail` using git-mailinfo, extracting its patch and authorship info.
1208 * state->msg will be set to the patch message. state->author_name,
1209 * state->author_email and state->author_date will be set to the patch author's
1210 * name, email and date respectively. The patch body will be written to the
1211 * state directory's "patch" file.
1212 *
1213 * Returns 1 if the patch should be skipped, 0 otherwise.
1214 */
1215static int parse_mail(struct am_state *state, const char *mail)
1216{
1217 FILE *fp;
1218 struct child_process cp = CHILD_PROCESS_INIT;
1219 struct strbuf sb = STRBUF_INIT;
1220 struct strbuf msg = STRBUF_INIT;
1221 struct strbuf author_name = STRBUF_INIT;
1222 struct strbuf author_date = STRBUF_INIT;
1223 struct strbuf author_email = STRBUF_INIT;
1224 int ret = 0;
1225
1226 cp.git_cmd = 1;
1227 cp.in = xopen(mail, O_RDONLY, 0);
1228 cp.out = xopen(am_path(state, "info"), O_WRONLY | O_CREAT, 0777);
1229
1230 argv_array_push(&cp.args, "mailinfo");
ef7ee16d 1231 argv_array_push(&cp.args, state->utf8 ? "-u" : "-n");
4f1b6961
PT
1232
1233 switch (state->keep) {
1234 case KEEP_FALSE:
1235 break;
1236 case KEEP_TRUE:
1237 argv_array_push(&cp.args, "-k");
1238 break;
1239 case KEEP_NON_PATCH:
1240 argv_array_push(&cp.args, "-b");
1241 break;
1242 default:
1243 die("BUG: invalid value for state->keep");
1244 }
1245
702cbaad
PT
1246 if (state->message_id)
1247 argv_array_push(&cp.args, "-m");
1248
9b646617
PT
1249 switch (state->scissors) {
1250 case SCISSORS_UNSET:
1251 break;
1252 case SCISSORS_FALSE:
1253 argv_array_push(&cp.args, "--no-scissors");
1254 break;
1255 case SCISSORS_TRUE:
1256 argv_array_push(&cp.args, "--scissors");
1257 break;
1258 default:
1259 die("BUG: invalid value for state->scissors");
1260 }
1261
3e20dcf3
PT
1262 argv_array_push(&cp.args, am_path(state, "msg"));
1263 argv_array_push(&cp.args, am_path(state, "patch"));
1264
1265 if (run_command(&cp) < 0)
1266 die("could not parse patch");
1267
1268 close(cp.in);
1269 close(cp.out);
1270
1271 /* Extract message and author information */
1272 fp = xfopen(am_path(state, "info"), "r");
1273 while (!strbuf_getline(&sb, fp, '\n')) {
1274 const char *x;
1275
1276 if (skip_prefix(sb.buf, "Subject: ", &x)) {
1277 if (msg.len)
1278 strbuf_addch(&msg, '\n');
1279 strbuf_addstr(&msg, x);
1280 } else if (skip_prefix(sb.buf, "Author: ", &x))
1281 strbuf_addstr(&author_name, x);
1282 else if (skip_prefix(sb.buf, "Email: ", &x))
1283 strbuf_addstr(&author_email, x);
1284 else if (skip_prefix(sb.buf, "Date: ", &x))
1285 strbuf_addstr(&author_date, x);
1286 }
1287 fclose(fp);
1288
1289 /* Skip pine's internal folder data */
1290 if (!strcmp(author_name.buf, "Mail System Internal Data")) {
1291 ret = 1;
1292 goto finish;
1293 }
1294
1295 if (is_empty_file(am_path(state, "patch"))) {
1296 printf_ln(_("Patch is empty. Was it split wrong?"));
2d83109a 1297 die_user_resolve(state);
3e20dcf3
PT
1298 }
1299
1300 strbuf_addstr(&msg, "\n\n");
1301 if (strbuf_read_file(&msg, am_path(state, "msg"), 0) < 0)
1302 die_errno(_("could not read '%s'"), am_path(state, "msg"));
1303 stripspace(&msg, 0);
1304
eb898b83
PT
1305 if (state->signoff)
1306 append_signoff(&msg, 0, 0);
1307
3e20dcf3
PT
1308 assert(!state->author_name);
1309 state->author_name = strbuf_detach(&author_name, NULL);
1310
1311 assert(!state->author_email);
1312 state->author_email = strbuf_detach(&author_email, NULL);
1313
1314 assert(!state->author_date);
1315 state->author_date = strbuf_detach(&author_date, NULL);
1316
1317 assert(!state->msg);
1318 state->msg = strbuf_detach(&msg, &state->msg_len);
1319
1320finish:
1321 strbuf_release(&msg);
1322 strbuf_release(&author_date);
1323 strbuf_release(&author_email);
1324 strbuf_release(&author_name);
1325 strbuf_release(&sb);
1326 return ret;
1327}
1328
df2760a5
PT
1329/**
1330 * Sets commit_id to the commit hash where the mail was generated from.
1331 * Returns 0 on success, -1 on failure.
1332 */
1333static int get_mail_commit_sha1(unsigned char *commit_id, const char *mail)
1334{
1335 struct strbuf sb = STRBUF_INIT;
1336 FILE *fp = xfopen(mail, "r");
1337 const char *x;
1338
1339 if (strbuf_getline(&sb, fp, '\n'))
1340 return -1;
1341
1342 if (!skip_prefix(sb.buf, "From ", &x))
1343 return -1;
1344
1345 if (get_sha1_hex(x, commit_id) < 0)
1346 return -1;
1347
1348 strbuf_release(&sb);
1349 fclose(fp);
1350 return 0;
1351}
1352
1353/**
1354 * Sets state->msg, state->author_name, state->author_email, state->author_date
1355 * to the commit's respective info.
1356 */
1357static void get_commit_info(struct am_state *state, struct commit *commit)
1358{
1359 const char *buffer, *ident_line, *author_date, *msg;
1360 size_t ident_len;
1361 struct ident_split ident_split;
1362 struct strbuf sb = STRBUF_INIT;
1363
1364 buffer = logmsg_reencode(commit, NULL, get_commit_output_encoding());
1365
1366 ident_line = find_commit_header(buffer, "author", &ident_len);
1367
1368 if (split_ident_line(&ident_split, ident_line, ident_len) < 0) {
1369 strbuf_add(&sb, ident_line, ident_len);
1370 die(_("invalid ident line: %s"), sb.buf);
1371 }
1372
1373 assert(!state->author_name);
1374 if (ident_split.name_begin) {
1375 strbuf_add(&sb, ident_split.name_begin,
1376 ident_split.name_end - ident_split.name_begin);
1377 state->author_name = strbuf_detach(&sb, NULL);
1378 } else
1379 state->author_name = xstrdup("");
1380
1381 assert(!state->author_email);
1382 if (ident_split.mail_begin) {
1383 strbuf_add(&sb, ident_split.mail_begin,
1384 ident_split.mail_end - ident_split.mail_begin);
1385 state->author_email = strbuf_detach(&sb, NULL);
1386 } else
1387 state->author_email = xstrdup("");
1388
1389 author_date = show_ident_date(&ident_split, DATE_MODE(NORMAL));
1390 strbuf_addstr(&sb, author_date);
1391 assert(!state->author_date);
1392 state->author_date = strbuf_detach(&sb, NULL);
1393
1394 assert(!state->msg);
1395 msg = strstr(buffer, "\n\n");
1396 if (!msg)
1397 die(_("unable to parse commit %s"), sha1_to_hex(commit->object.sha1));
1398 state->msg = xstrdup(msg + 2);
1399 state->msg_len = strlen(state->msg);
1400}
1401
1402/**
1403 * Writes `commit` as a patch to the state directory's "patch" file.
1404 */
1405static void write_commit_patch(const struct am_state *state, struct commit *commit)
1406{
1407 struct rev_info rev_info;
1408 FILE *fp;
1409
1410 fp = xfopen(am_path(state, "patch"), "w");
1411 init_revisions(&rev_info, NULL);
1412 rev_info.diff = 1;
1413 rev_info.abbrev = 0;
1414 rev_info.disable_stdin = 1;
1415 rev_info.show_root_diff = 1;
1416 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;
1417 rev_info.no_commit_id = 1;
1418 DIFF_OPT_SET(&rev_info.diffopt, BINARY);
1419 DIFF_OPT_SET(&rev_info.diffopt, FULL_INDEX);
1420 rev_info.diffopt.use_color = 0;
1421 rev_info.diffopt.file = fp;
1422 rev_info.diffopt.close_file = 1;
1423 add_pending_object(&rev_info, &commit->object, "");
1424 diff_setup_done(&rev_info.diffopt);
1425 log_tree_commit(&rev_info, commit);
1426}
1427
7ff26832
PT
1428/**
1429 * Writes the diff of the index against HEAD as a patch to the state
1430 * directory's "patch" file.
1431 */
1432static void write_index_patch(const struct am_state *state)
1433{
1434 struct tree *tree;
1435 unsigned char head[GIT_SHA1_RAWSZ];
1436 struct rev_info rev_info;
1437 FILE *fp;
1438
1439 if (!get_sha1_tree("HEAD", head))
1440 tree = lookup_tree(head);
1441 else
1442 tree = lookup_tree(EMPTY_TREE_SHA1_BIN);
1443
1444 fp = xfopen(am_path(state, "patch"), "w");
1445 init_revisions(&rev_info, NULL);
1446 rev_info.diff = 1;
1447 rev_info.disable_stdin = 1;
1448 rev_info.no_commit_id = 1;
1449 rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;
1450 rev_info.diffopt.use_color = 0;
1451 rev_info.diffopt.file = fp;
1452 rev_info.diffopt.close_file = 1;
1453 add_pending_object(&rev_info, &tree->object, "");
1454 diff_setup_done(&rev_info.diffopt);
1455 run_diff_index(&rev_info, 1);
1456}
1457
df2760a5
PT
1458/**
1459 * Like parse_mail(), but parses the mail by looking up its commit ID
1460 * directly. This is used in --rebasing mode to bypass git-mailinfo's munging
1461 * of patches.
1462 *
13b97ea5
PT
1463 * state->orig_commit will be set to the original commit ID.
1464 *
df2760a5
PT
1465 * Will always return 0 as the patch should never be skipped.
1466 */
1467static int parse_mail_rebase(struct am_state *state, const char *mail)
1468{
1469 struct commit *commit;
1470 unsigned char commit_sha1[GIT_SHA1_RAWSZ];
1471
1472 if (get_mail_commit_sha1(commit_sha1, mail) < 0)
1473 die(_("could not parse %s"), mail);
1474
1475 commit = lookup_commit_or_die(commit_sha1, mail);
1476
1477 get_commit_info(state, commit);
1478
1479 write_commit_patch(state, commit);
1480
13b97ea5
PT
1481 hashcpy(state->orig_commit, commit_sha1);
1482 write_file(am_path(state, "original-commit"), 1, "%s",
1483 sha1_to_hex(commit_sha1));
1484
df2760a5
PT
1485 return 0;
1486}
1487
38a824fe 1488/**
84f3de28
PT
1489 * Applies current patch with git-apply. Returns 0 on success, -1 otherwise. If
1490 * `index_file` is not NULL, the patch will be applied to that index.
38a824fe 1491 */
84f3de28 1492static int run_apply(const struct am_state *state, const char *index_file)
38a824fe
PT
1493{
1494 struct child_process cp = CHILD_PROCESS_INIT;
1495
1496 cp.git_cmd = 1;
1497
84f3de28
PT
1498 if (index_file)
1499 argv_array_pushf(&cp.env_array, "GIT_INDEX_FILE=%s", index_file);
1500
1501 /*
1502 * If we are allowed to fall back on 3-way merge, don't give false
1503 * errors during the initial attempt.
1504 */
1505 if (state->threeway && !index_file) {
1506 cp.no_stdout = 1;
1507 cp.no_stderr = 1;
1508 }
1509
38a824fe 1510 argv_array_push(&cp.args, "apply");
84f3de28 1511
257e8cec
PT
1512 argv_array_pushv(&cp.args, state->git_apply_opts.argv);
1513
84f3de28
PT
1514 if (index_file)
1515 argv_array_push(&cp.args, "--cached");
1516 else
1517 argv_array_push(&cp.args, "--index");
1518
38a824fe
PT
1519 argv_array_push(&cp.args, am_path(state, "patch"));
1520
1521 if (run_command(&cp))
1522 return -1;
1523
1524 /* Reload index as git-apply will have modified it. */
84f3de28
PT
1525 discard_cache();
1526 read_cache_from(index_file ? index_file : get_index_file());
1527
1528 return 0;
1529}
1530
1531/**
1532 * Builds an index that contains just the blobs needed for a 3way merge.
1533 */
1534static int build_fake_ancestor(const struct am_state *state, const char *index_file)
1535{
1536 struct child_process cp = CHILD_PROCESS_INIT;
1537
1538 cp.git_cmd = 1;
1539 argv_array_push(&cp.args, "apply");
257e8cec 1540 argv_array_pushv(&cp.args, state->git_apply_opts.argv);
84f3de28
PT
1541 argv_array_pushf(&cp.args, "--build-fake-ancestor=%s", index_file);
1542 argv_array_push(&cp.args, am_path(state, "patch"));
1543
1544 if (run_command(&cp))
1545 return -1;
1546
1547 return 0;
1548}
1549
1550/**
1551 * Attempt a threeway merge, using index_path as the temporary index.
1552 */
1553static int fall_back_threeway(const struct am_state *state, const char *index_path)
1554{
1555 unsigned char orig_tree[GIT_SHA1_RAWSZ], his_tree[GIT_SHA1_RAWSZ],
1556 our_tree[GIT_SHA1_RAWSZ];
1557 const unsigned char *bases[1] = {orig_tree};
1558 struct merge_options o;
1559 struct commit *result;
1560 char *his_tree_name;
1561
1562 if (get_sha1("HEAD", our_tree) < 0)
1563 hashcpy(our_tree, EMPTY_TREE_SHA1_BIN);
1564
1565 if (build_fake_ancestor(state, index_path))
1566 return error("could not build fake ancestor");
1567
1568 discard_cache();
1569 read_cache_from(index_path);
1570
1571 if (write_index_as_tree(orig_tree, &the_index, index_path, 0, NULL))
1572 return error(_("Repository lacks necessary blobs to fall back on 3-way merge."));
1573
1574 say(state, stdout, _("Using index info to reconstruct a base tree..."));
1575
1576 if (!state->quiet) {
1577 /*
1578 * List paths that needed 3-way fallback, so that the user can
1579 * review them with extra care to spot mismerges.
1580 */
1581 struct rev_info rev_info;
1582 const char *diff_filter_str = "--diff-filter=AM";
1583
1584 init_revisions(&rev_info, NULL);
1585 rev_info.diffopt.output_format = DIFF_FORMAT_NAME_STATUS;
1586 diff_opt_parse(&rev_info.diffopt, &diff_filter_str, 1);
1587 add_pending_sha1(&rev_info, "HEAD", our_tree, 0);
1588 diff_setup_done(&rev_info.diffopt);
1589 run_diff_index(&rev_info, 1);
1590 }
1591
1592 if (run_apply(state, index_path))
1593 return error(_("Did you hand edit your patch?\n"
1594 "It does not apply to blobs recorded in its index."));
1595
1596 if (write_index_as_tree(his_tree, &the_index, index_path, 0, NULL))
1597 return error("could not write tree");
1598
1599 say(state, stdout, _("Falling back to patching base and 3-way merge..."));
1600
38a824fe
PT
1601 discard_cache();
1602 read_cache();
1603
84f3de28
PT
1604 /*
1605 * This is not so wrong. Depending on which base we picked, orig_tree
1606 * may be wildly different from ours, but his_tree has the same set of
1607 * wildly different changes in parts the patch did not touch, so
1608 * recursive ends up canceling them, saying that we reverted all those
1609 * changes.
1610 */
1611
1612 init_merge_options(&o);
1613
1614 o.branch1 = "HEAD";
1615 his_tree_name = xstrfmt("%.*s", linelen(state->msg), state->msg);
1616 o.branch2 = his_tree_name;
1617
1618 if (state->quiet)
1619 o.verbosity = 0;
1620
1621 if (merge_recursive_generic(&o, our_tree, his_tree, 1, bases, &result)) {
f1cb96d6 1622 rerere(state->allow_rerere_autoupdate);
84f3de28
PT
1623 free(his_tree_name);
1624 return error(_("Failed to merge in the changes."));
1625 }
1626
1627 free(his_tree_name);
38a824fe
PT
1628 return 0;
1629}
1630
c9e8d960
PT
1631/**
1632 * Commits the current index with state->msg as the commit message and
1633 * state->author_name, state->author_email and state->author_date as the author
1634 * information.
1635 */
1636static void do_commit(const struct am_state *state)
1637{
1638 unsigned char tree[GIT_SHA1_RAWSZ], parent[GIT_SHA1_RAWSZ],
1639 commit[GIT_SHA1_RAWSZ];
1640 unsigned char *ptr;
1641 struct commit_list *parents = NULL;
1642 const char *reflog_msg, *author;
1643 struct strbuf sb = STRBUF_INIT;
1644
6c24c5c0
PT
1645 if (run_hook_le(NULL, "pre-applypatch", NULL))
1646 exit(1);
1647
c9e8d960
PT
1648 if (write_cache_as_tree(tree, 0, NULL))
1649 die(_("git write-tree failed to write a tree"));
1650
1651 if (!get_sha1_commit("HEAD", parent)) {
1652 ptr = parent;
1653 commit_list_insert(lookup_commit(parent), &parents);
1654 } else {
1655 ptr = NULL;
5d28cf78 1656 say(state, stderr, _("applying to an empty history"));
c9e8d960
PT
1657 }
1658
1659 author = fmt_ident(state->author_name, state->author_email,
f07adb62
PT
1660 state->ignore_date ? NULL : state->author_date,
1661 IDENT_STRICT);
c9e8d960 1662
0cd4bcba
PT
1663 if (state->committer_date_is_author_date)
1664 setenv("GIT_COMMITTER_DATE",
1665 state->ignore_date ? "" : state->author_date, 1);
1666
c9e8d960 1667 if (commit_tree(state->msg, state->msg_len, tree, parents, commit,
7e35dacb 1668 author, state->sign_commit))
c9e8d960
PT
1669 die(_("failed to write commit object"));
1670
1671 reflog_msg = getenv("GIT_REFLOG_ACTION");
1672 if (!reflog_msg)
1673 reflog_msg = "am";
1674
1675 strbuf_addf(&sb, "%s: %.*s", reflog_msg, linelen(state->msg),
1676 state->msg);
1677
1678 update_ref(sb.buf, "HEAD", commit, ptr, 0, UPDATE_REFS_DIE_ON_ERR);
1679
13b97ea5
PT
1680 if (state->rebasing) {
1681 FILE *fp = xfopen(am_path(state, "rewritten"), "a");
1682
1683 assert(!is_null_sha1(state->orig_commit));
1684 fprintf(fp, "%s ", sha1_to_hex(state->orig_commit));
1685 fprintf(fp, "%s\n", sha1_to_hex(commit));
1686 fclose(fp);
1687 }
1688
7088f807
PT
1689 run_hook_le(NULL, "post-applypatch", NULL);
1690
c9e8d960
PT
1691 strbuf_release(&sb);
1692}
1693
240bfd2d
PT
1694/**
1695 * Validates the am_state for resuming -- the "msg" and authorship fields must
1696 * be filled up.
1697 */
1698static void validate_resume_state(const struct am_state *state)
1699{
1700 if (!state->msg)
1701 die(_("cannot resume: %s does not exist."),
1702 am_path(state, "final-commit"));
1703
1704 if (!state->author_name || !state->author_email || !state->author_date)
1705 die(_("cannot resume: %s does not exist."),
1706 am_path(state, "author-script"));
1707}
1708
7ff26832
PT
1709/**
1710 * Interactively prompt the user on whether the current patch should be
1711 * applied.
1712 *
1713 * Returns 0 if the user chooses to apply the patch, 1 if the user chooses to
1714 * skip it.
1715 */
1716static int do_interactive(struct am_state *state)
1717{
1718 assert(state->msg);
1719
1720 if (!isatty(0))
1721 die(_("cannot be interactive without stdin connected to a terminal."));
1722
1723 for (;;) {
1724 const char *reply;
1725
1726 puts(_("Commit Body is:"));
1727 puts("--------------------------");
1728 printf("%s", state->msg);
1729 puts("--------------------------");
1730
1731 /*
1732 * TRANSLATORS: Make sure to include [y], [n], [e], [v] and [a]
1733 * in your translation. The program will only accept English
1734 * input at this point.
1735 */
1736 reply = git_prompt(_("Apply? [y]es/[n]o/[e]dit/[v]iew patch/[a]ccept all: "), PROMPT_ECHO);
1737
1738 if (!reply) {
1739 continue;
1740 } else if (*reply == 'y' || *reply == 'Y') {
1741 return 0;
1742 } else if (*reply == 'a' || *reply == 'A') {
1743 state->interactive = 0;
1744 return 0;
1745 } else if (*reply == 'n' || *reply == 'N') {
1746 return 1;
1747 } else if (*reply == 'e' || *reply == 'E') {
1748 struct strbuf msg = STRBUF_INIT;
1749
1750 if (!launch_editor(am_path(state, "final-commit"), &msg, NULL)) {
1751 free(state->msg);
1752 state->msg = strbuf_detach(&msg, &state->msg_len);
1753 }
1754 strbuf_release(&msg);
1755 } else if (*reply == 'v' || *reply == 'V') {
1756 const char *pager = git_pager(1);
1757 struct child_process cp = CHILD_PROCESS_INIT;
1758
1759 if (!pager)
1760 pager = "cat";
1761 argv_array_push(&cp.args, pager);
1762 argv_array_push(&cp.args, am_path(state, "patch"));
1763 run_command(&cp);
1764 }
1765 }
1766}
1767
8c3bd9e2
PT
1768/**
1769 * Applies all queued mail.
8c7b1563
PT
1770 *
1771 * If `resume` is true, we are "resuming". The "msg" and authorship fields, as
1772 * well as the state directory's "patch" file is used as-is for applying the
1773 * patch and committing it.
8c3bd9e2 1774 */
8c7b1563 1775static void am_run(struct am_state *state, int resume)
8c3bd9e2 1776{
c9e8d960 1777 const char *argv_gc_auto[] = {"gc", "--auto", NULL};
32a5fcbf 1778 struct strbuf sb = STRBUF_INIT;
c9e8d960 1779
33388a71
PT
1780 unlink(am_path(state, "dirtyindex"));
1781
38a824fe
PT
1782 refresh_and_write_cache();
1783
33388a71
PT
1784 if (index_has_changes(&sb)) {
1785 write_file(am_path(state, "dirtyindex"), 1, "t");
32a5fcbf 1786 die(_("Dirty index: cannot apply patches (dirty: %s)"), sb.buf);
33388a71 1787 }
32a5fcbf
PT
1788
1789 strbuf_release(&sb);
1790
8c3bd9e2 1791 while (state->cur <= state->last) {
3e20dcf3 1792 const char *mail = am_path(state, msgnum(state));
84f3de28 1793 int apply_status;
3e20dcf3
PT
1794
1795 if (!file_exists(mail))
1796 goto next;
1797
8c7b1563
PT
1798 if (resume) {
1799 validate_resume_state(state);
8c7b1563 1800 } else {
df2760a5
PT
1801 int skip;
1802
1803 if (state->rebasing)
1804 skip = parse_mail_rebase(state, mail);
1805 else
1806 skip = parse_mail(state, mail);
1807
1808 if (skip)
8c7b1563 1809 goto next; /* mail should be skipped */
3e20dcf3 1810
8c7b1563
PT
1811 write_author_script(state);
1812 write_commit_msg(state);
1813 }
8c3bd9e2 1814
7ff26832
PT
1815 if (state->interactive && do_interactive(state))
1816 goto next;
1817
b8803d8f
PT
1818 if (run_applypatch_msg_hook(state))
1819 exit(1);
1820
5d28cf78 1821 say(state, stdout, _("Applying: %.*s"), linelen(state->msg), state->msg);
38a824fe 1822
84f3de28
PT
1823 apply_status = run_apply(state, NULL);
1824
1825 if (apply_status && state->threeway) {
1826 struct strbuf sb = STRBUF_INIT;
1827
1828 strbuf_addstr(&sb, am_path(state, "patch-merge-index"));
1829 apply_status = fall_back_threeway(state, sb.buf);
1830 strbuf_release(&sb);
1831
1832 /*
1833 * Applying the patch to an earlier tree and merging
1834 * the result may have produced the same tree as ours.
1835 */
1836 if (!apply_status && !index_has_changes(NULL)) {
1837 say(state, stdout, _("No changes -- Patch already applied."));
1838 goto next;
1839 }
1840 }
1841
1842 if (apply_status) {
38a824fe
PT
1843 int advice_amworkdir = 1;
1844
1845 printf_ln(_("Patch failed at %s %.*s"), msgnum(state),
1846 linelen(state->msg), state->msg);
1847
1848 git_config_get_bool("advice.amworkdir", &advice_amworkdir);
1849
1850 if (advice_amworkdir)
1851 printf_ln(_("The copy of the patch that failed is found in: %s"),
1852 am_path(state, "patch"));
1853
2d83109a 1854 die_user_resolve(state);
38a824fe
PT
1855 }
1856
c9e8d960 1857 do_commit(state);
8c3bd9e2 1858
3e20dcf3 1859next:
8c3bd9e2 1860 am_next(state);
852a1710
PT
1861
1862 if (resume)
1863 am_load(state);
1864 resume = 0;
8c3bd9e2
PT
1865 }
1866
13b97ea5
PT
1867 if (!is_empty_file(am_path(state, "rewritten"))) {
1868 assert(state->rebasing);
88b291fe 1869 copy_notes_for_rebase(state);
13b97ea5
PT
1870 run_post_rewrite_hook(state);
1871 }
1872
35bdcc59
PT
1873 /*
1874 * In rebasing mode, it's up to the caller to take care of
1875 * housekeeping.
1876 */
1877 if (!state->rebasing) {
1878 am_destroy(state);
1879 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
1880 }
8c3bd9e2 1881}
73c2779f 1882
240bfd2d
PT
1883/**
1884 * Resume the current am session after patch application failure. The user did
1885 * all the hard work, and we do not have to do any patch application. Just
1886 * trust and commit what the user has in the index and working tree.
1887 */
1888static void am_resolve(struct am_state *state)
1889{
1890 validate_resume_state(state);
1891
5d28cf78 1892 say(state, stdout, _("Applying: %.*s"), linelen(state->msg), state->msg);
240bfd2d
PT
1893
1894 if (!index_has_changes(NULL)) {
1895 printf_ln(_("No changes - did you forget to use 'git add'?\n"
1896 "If there is nothing left to stage, chances are that something else\n"
1897 "already introduced the same changes; you might want to skip this patch."));
2d83109a 1898 die_user_resolve(state);
240bfd2d
PT
1899 }
1900
1901 if (unmerged_cache()) {
1902 printf_ln(_("You still have unmerged paths in your index.\n"
1903 "Did you forget to use 'git add'?"));
2d83109a 1904 die_user_resolve(state);
240bfd2d
PT
1905 }
1906
7ff26832
PT
1907 if (state->interactive) {
1908 write_index_patch(state);
1909 if (do_interactive(state))
1910 goto next;
1911 }
1912
f1cb96d6
PT
1913 rerere(0);
1914
240bfd2d
PT
1915 do_commit(state);
1916
7ff26832 1917next:
240bfd2d 1918 am_next(state);
852a1710 1919 am_load(state);
8c7b1563 1920 am_run(state, 0);
240bfd2d
PT
1921}
1922
9990080c
PT
1923/**
1924 * Performs a checkout fast-forward from `head` to `remote`. If `reset` is
1925 * true, any unmerged entries will be discarded. Returns 0 on success, -1 on
1926 * failure.
1927 */
1928static int fast_forward_to(struct tree *head, struct tree *remote, int reset)
1929{
1930 struct lock_file *lock_file;
1931 struct unpack_trees_options opts;
1932 struct tree_desc t[2];
1933
1934 if (parse_tree(head) || parse_tree(remote))
1935 return -1;
1936
1937 lock_file = xcalloc(1, sizeof(struct lock_file));
1938 hold_locked_index(lock_file, 1);
1939
1940 refresh_cache(REFRESH_QUIET);
1941
1942 memset(&opts, 0, sizeof(opts));
1943 opts.head_idx = 1;
1944 opts.src_index = &the_index;
1945 opts.dst_index = &the_index;
1946 opts.update = 1;
1947 opts.merge = 1;
1948 opts.reset = reset;
1949 opts.fn = twoway_merge;
1950 init_tree_desc(&t[0], head->buffer, head->size);
1951 init_tree_desc(&t[1], remote->buffer, remote->size);
1952
1953 if (unpack_trees(2, t, &opts)) {
1954 rollback_lock_file(lock_file);
1955 return -1;
1956 }
1957
1958 if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))
1959 die(_("unable to write new index file"));
1960
1961 return 0;
1962}
1963
1964/**
1965 * Clean the index without touching entries that are not modified between
1966 * `head` and `remote`.
1967 */
1968static int clean_index(const unsigned char *head, const unsigned char *remote)
1969{
1970 struct lock_file *lock_file;
1971 struct tree *head_tree, *remote_tree, *index_tree;
1972 unsigned char index[GIT_SHA1_RAWSZ];
1973 struct pathspec pathspec;
1974
1975 head_tree = parse_tree_indirect(head);
1976 if (!head_tree)
1977 return error(_("Could not parse object '%s'."), sha1_to_hex(head));
1978
1979 remote_tree = parse_tree_indirect(remote);
1980 if (!remote_tree)
1981 return error(_("Could not parse object '%s'."), sha1_to_hex(remote));
1982
1983 read_cache_unmerged();
1984
1985 if (fast_forward_to(head_tree, head_tree, 1))
1986 return -1;
1987
1988 if (write_cache_as_tree(index, 0, NULL))
1989 return -1;
1990
1991 index_tree = parse_tree_indirect(index);
1992 if (!index_tree)
1993 return error(_("Could not parse object '%s'."), sha1_to_hex(index));
1994
1995 if (fast_forward_to(index_tree, remote_tree, 0))
1996 return -1;
1997
1998 memset(&pathspec, 0, sizeof(pathspec));
1999
2000 lock_file = xcalloc(1, sizeof(struct lock_file));
2001 hold_locked_index(lock_file, 1);
2002
2003 if (read_tree(remote_tree, 0, &pathspec)) {
2004 rollback_lock_file(lock_file);
2005 return -1;
2006 }
2007
2008 if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))
2009 die(_("unable to write new index file"));
2010
2011 remove_branch_state();
2012
2013 return 0;
2014}
2015
f1cb96d6
PT
2016/**
2017 * Resets rerere's merge resolution metadata.
2018 */
2019static void am_rerere_clear(void)
2020{
2021 struct string_list merge_rr = STRING_LIST_INIT_DUP;
2022 int fd = setup_rerere(&merge_rr, 0);
2023
2024 if (fd < 0)
2025 return;
2026
2027 rerere_clear(&merge_rr);
2028 string_list_clear(&merge_rr, 1);
2029}
2030
9990080c
PT
2031/**
2032 * Resume the current am session by skipping the current patch.
2033 */
2034static void am_skip(struct am_state *state)
2035{
2036 unsigned char head[GIT_SHA1_RAWSZ];
2037
f1cb96d6
PT
2038 am_rerere_clear();
2039
9990080c
PT
2040 if (get_sha1("HEAD", head))
2041 hashcpy(head, EMPTY_TREE_SHA1_BIN);
2042
2043 if (clean_index(head, head))
2044 die(_("failed to clean index"));
2045
2046 am_next(state);
852a1710 2047 am_load(state);
9990080c
PT
2048 am_run(state, 0);
2049}
2050
33388a71
PT
2051/**
2052 * Returns true if it is safe to reset HEAD to the ORIG_HEAD, false otherwise.
2053 *
2054 * It is not safe to reset HEAD when:
2055 * 1. git-am previously failed because the index was dirty.
2056 * 2. HEAD has moved since git-am previously failed.
2057 */
2058static int safe_to_abort(const struct am_state *state)
2059{
2060 struct strbuf sb = STRBUF_INIT;
2061 unsigned char abort_safety[GIT_SHA1_RAWSZ], head[GIT_SHA1_RAWSZ];
2062
2063 if (file_exists(am_path(state, "dirtyindex")))
2064 return 0;
2065
2066 if (read_state_file(&sb, state, "abort-safety", 1) > 0) {
2067 if (get_sha1_hex(sb.buf, abort_safety))
2068 die(_("could not parse %s"), am_path(state, "abort_safety"));
2069 } else
2070 hashclr(abort_safety);
2071
2072 if (get_sha1("HEAD", head))
2073 hashclr(head);
2074
2075 if (!hashcmp(head, abort_safety))
2076 return 1;
2077
2078 error(_("You seem to have moved HEAD since the last 'am' failure.\n"
2079 "Not rewinding to ORIG_HEAD"));
2080
2081 return 0;
2082}
2083
2084/**
2085 * Aborts the current am session if it is safe to do so.
2086 */
2087static void am_abort(struct am_state *state)
2088{
2089 unsigned char curr_head[GIT_SHA1_RAWSZ], orig_head[GIT_SHA1_RAWSZ];
2090 int has_curr_head, has_orig_head;
2091 char *curr_branch;
2092
2093 if (!safe_to_abort(state)) {
2094 am_destroy(state);
2095 return;
2096 }
2097
f1cb96d6
PT
2098 am_rerere_clear();
2099
33388a71
PT
2100 curr_branch = resolve_refdup("HEAD", 0, curr_head, NULL);
2101 has_curr_head = !is_null_sha1(curr_head);
2102 if (!has_curr_head)
2103 hashcpy(curr_head, EMPTY_TREE_SHA1_BIN);
2104
2105 has_orig_head = !get_sha1("ORIG_HEAD", orig_head);
2106 if (!has_orig_head)
2107 hashcpy(orig_head, EMPTY_TREE_SHA1_BIN);
2108
2109 clean_index(curr_head, orig_head);
2110
2111 if (has_orig_head)
2112 update_ref("am --abort", "HEAD", orig_head,
2113 has_curr_head ? curr_head : NULL, 0,
2114 UPDATE_REFS_DIE_ON_ERR);
2115 else if (curr_branch)
2116 delete_ref(curr_branch, NULL, REF_NODEREF);
2117
2118 free(curr_branch);
2119 am_destroy(state);
2120}
2121
11c2177f
PT
2122/**
2123 * parse_options() callback that validates and sets opt->value to the
2124 * PATCH_FORMAT_* enum value corresponding to `arg`.
2125 */
2126static int parse_opt_patchformat(const struct option *opt, const char *arg, int unset)
2127{
2128 int *opt_value = opt->value;
2129
2130 if (!strcmp(arg, "mbox"))
2131 *opt_value = PATCH_FORMAT_MBOX;
5ae41c79
PT
2132 else if (!strcmp(arg, "stgit"))
2133 *opt_value = PATCH_FORMAT_STGIT;
336108c1
PT
2134 else if (!strcmp(arg, "stgit-series"))
2135 *opt_value = PATCH_FORMAT_STGIT_SERIES;
94cd175c
PT
2136 else if (!strcmp(arg, "hg"))
2137 *opt_value = PATCH_FORMAT_HG;
11c2177f
PT
2138 else
2139 return error(_("Invalid value for --patch-format: %s"), arg);
2140 return 0;
2141}
2142
240bfd2d
PT
2143enum resume_mode {
2144 RESUME_FALSE = 0,
8c7b1563 2145 RESUME_APPLY,
9990080c 2146 RESUME_RESOLVED,
33388a71
PT
2147 RESUME_SKIP,
2148 RESUME_ABORT
240bfd2d
PT
2149};
2150
73c2779f
PT
2151int cmd_am(int argc, const char **argv, const char *prefix)
2152{
8c3bd9e2 2153 struct am_state state;
c2676cde 2154 int binary = -1;
5d123a40 2155 int keep_cr = -1;
11c2177f 2156 int patch_format = PATCH_FORMAT_UNKNOWN;
240bfd2d 2157 enum resume_mode resume = RESUME_FALSE;
852a1710 2158 int in_progress;
8c3bd9e2
PT
2159
2160 const char * const usage[] = {
2161 N_("git am [options] [(<mbox>|<Maildir>)...]"),
33388a71 2162 N_("git am [options] (--continue | --skip | --abort)"),
8c3bd9e2
PT
2163 NULL
2164 };
2165
2166 struct option options[] = {
7ff26832
PT
2167 OPT_BOOL('i', "interactive", &state.interactive,
2168 N_("run interactively")),
c2676cde
PT
2169 OPT_HIDDEN_BOOL('b', "binary", &binary,
2170 N_("(historical option -- no-op")),
84f3de28
PT
2171 OPT_BOOL('3', "3way", &state.threeway,
2172 N_("allow fall back on 3way merging if needed")),
5d28cf78 2173 OPT__QUIET(&state.quiet, N_("be quiet")),
b5e82359
PT
2174 OPT_SET_INT('s', "signoff", &state.signoff,
2175 N_("add a Signed-off-by line to the commit message"),
2176 SIGNOFF_EXPLICIT),
ef7ee16d
PT
2177 OPT_BOOL('u', "utf8", &state.utf8,
2178 N_("recode into utf8 (default)")),
4f1b6961
PT
2179 OPT_SET_INT('k', "keep", &state.keep,
2180 N_("pass -k flag to git-mailinfo"), KEEP_TRUE),
2181 OPT_SET_INT(0, "keep-non-patch", &state.keep,
2182 N_("pass -b flag to git-mailinfo"), KEEP_NON_PATCH),
702cbaad
PT
2183 OPT_BOOL('m', "message-id", &state.message_id,
2184 N_("pass -m flag to git-mailinfo")),
5d123a40
PT
2185 { OPTION_SET_INT, 0, "keep-cr", &keep_cr, NULL,
2186 N_("pass --keep-cr flag to git-mailsplit for mbox format"),
2187 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, 1},
2188 { OPTION_SET_INT, 0, "no-keep-cr", &keep_cr, NULL,
2189 N_("do not pass --keep-cr flag to git-mailsplit independent of am.keepcr"),
2190 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, 0},
9b646617
PT
2191 OPT_BOOL('c', "scissors", &state.scissors,
2192 N_("strip everything before a scissors line")),
257e8cec
PT
2193 OPT_PASSTHRU_ARGV(0, "whitespace", &state.git_apply_opts, N_("action"),
2194 N_("pass it through git-apply"),
2195 0),
2196 OPT_PASSTHRU_ARGV(0, "ignore-space-change", &state.git_apply_opts, NULL,
2197 N_("pass it through git-apply"),
2198 PARSE_OPT_NOARG),
2199 OPT_PASSTHRU_ARGV(0, "ignore-whitespace", &state.git_apply_opts, NULL,
2200 N_("pass it through git-apply"),
2201 PARSE_OPT_NOARG),
2202 OPT_PASSTHRU_ARGV(0, "directory", &state.git_apply_opts, N_("root"),
2203 N_("pass it through git-apply"),
2204 0),
2205 OPT_PASSTHRU_ARGV(0, "exclude", &state.git_apply_opts, N_("path"),
2206 N_("pass it through git-apply"),
2207 0),
2208 OPT_PASSTHRU_ARGV(0, "include", &state.git_apply_opts, N_("path"),
2209 N_("pass it through git-apply"),
2210 0),
2211 OPT_PASSTHRU_ARGV('C', NULL, &state.git_apply_opts, N_("n"),
2212 N_("pass it through git-apply"),
2213 0),
2214 OPT_PASSTHRU_ARGV('p', NULL, &state.git_apply_opts, N_("num"),
2215 N_("pass it through git-apply"),
2216 0),
11c2177f
PT
2217 OPT_CALLBACK(0, "patch-format", &patch_format, N_("format"),
2218 N_("format the patch(es) are in"),
2219 parse_opt_patchformat),
257e8cec
PT
2220 OPT_PASSTHRU_ARGV(0, "reject", &state.git_apply_opts, NULL,
2221 N_("pass it through git-apply"),
2222 PARSE_OPT_NOARG),
2d83109a
PT
2223 OPT_STRING(0, "resolvemsg", &state.resolvemsg, NULL,
2224 N_("override error message when patch failure occurs")),
240bfd2d
PT
2225 OPT_CMDMODE(0, "continue", &resume,
2226 N_("continue applying patches after resolving a conflict"),
2227 RESUME_RESOLVED),
2228 OPT_CMDMODE('r', "resolved", &resume,
2229 N_("synonyms for --continue"),
2230 RESUME_RESOLVED),
9990080c
PT
2231 OPT_CMDMODE(0, "skip", &resume,
2232 N_("skip the current patch"),
2233 RESUME_SKIP),
33388a71
PT
2234 OPT_CMDMODE(0, "abort", &resume,
2235 N_("restore the original branch and abort the patching operation."),
2236 RESUME_ABORT),
0cd4bcba
PT
2237 OPT_BOOL(0, "committer-date-is-author-date",
2238 &state.committer_date_is_author_date,
2239 N_("lie about committer date")),
f07adb62
PT
2240 OPT_BOOL(0, "ignore-date", &state.ignore_date,
2241 N_("use current timestamp for author date")),
f1cb96d6 2242 OPT_RERERE_AUTOUPDATE(&state.allow_rerere_autoupdate),
7e35dacb
PT
2243 { OPTION_STRING, 'S', "gpg-sign", &state.sign_commit, N_("key-id"),
2244 N_("GPG-sign commits"),
2245 PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
35bdcc59
PT
2246 OPT_HIDDEN_BOOL(0, "rebasing", &state.rebasing,
2247 N_("(internal use for git-rebase)")),
8c3bd9e2
PT
2248 OPT_END()
2249 };
73c2779f 2250
8c3bd9e2
PT
2251 git_config(git_default_config, NULL);
2252
2253 am_state_init(&state, git_path("rebase-apply"));
2254
852a1710
PT
2255 in_progress = am_in_progress(&state);
2256 if (in_progress)
2257 am_load(&state);
2258
8c3bd9e2
PT
2259 argc = parse_options(argc, argv, prefix, options, usage, 0);
2260
c2676cde
PT
2261 if (binary >= 0)
2262 fprintf_ln(stderr, _("The -b/--binary option has been a no-op for long time, and\n"
2263 "it will be removed. Please do not use it anymore."));
2264
5e4f9cff
PT
2265 /* Ensure a valid committer ident can be constructed */
2266 git_committer_info(IDENT_STRICT);
2267
38a824fe
PT
2268 if (read_index_preload(&the_index, NULL) < 0)
2269 die(_("failed to read the index"));
2270
852a1710 2271 if (in_progress) {
8d185503
PT
2272 /*
2273 * Catch user error to feed us patches when there is a session
2274 * in progress:
2275 *
2276 * 1. mbox path(s) are provided on the command-line.
2277 * 2. stdin is not a tty: the user is trying to feed us a patch
2278 * from standard input. This is somewhat unreliable -- stdin
2279 * could be /dev/null for example and the caller did not
2280 * intend to feed us a patch but wanted to continue
2281 * unattended.
2282 */
2283 if (argc || (resume == RESUME_FALSE && !isatty(0)))
2284 die(_("previous rebase directory %s still exists but mbox given."),
2285 state.dir);
2286
8c7b1563
PT
2287 if (resume == RESUME_FALSE)
2288 resume = RESUME_APPLY;
b5e82359
PT
2289
2290 if (state.signoff == SIGNOFF_EXPLICIT)
2291 am_append_signoff(&state);
8c7b1563 2292 } else {
11c2177f
PT
2293 struct argv_array paths = ARGV_ARRAY_INIT;
2294 int i;
2295
6d42ac29
PT
2296 /*
2297 * Handle stray state directory in the independent-run case. In
2298 * the --rebasing case, it is up to the caller to take care of
2299 * stray directories.
2300 */
2301 if (file_exists(state.dir) && !state.rebasing) {
2302 if (resume == RESUME_ABORT) {
2303 am_destroy(&state);
2304 am_state_release(&state);
2305 return 0;
2306 }
2307
2308 die(_("Stray %s directory found.\n"
2309 "Use \"git am --abort\" to remove it."),
2310 state.dir);
2311 }
2312
240bfd2d
PT
2313 if (resume)
2314 die(_("Resolve operation not in progress, we are not resuming."));
2315
11c2177f
PT
2316 for (i = 0; i < argc; i++) {
2317 if (is_absolute_path(argv[i]) || !prefix)
2318 argv_array_push(&paths, argv[i]);
2319 else
2320 argv_array_push(&paths, mkpath("%s/%s", prefix, argv[i]));
2321 }
2322
5d123a40 2323 am_setup(&state, patch_format, paths.argv, keep_cr);
11c2177f
PT
2324
2325 argv_array_clear(&paths);
2326 }
8c3bd9e2 2327
240bfd2d
PT
2328 switch (resume) {
2329 case RESUME_FALSE:
8c7b1563
PT
2330 am_run(&state, 0);
2331 break;
2332 case RESUME_APPLY:
2333 am_run(&state, 1);
240bfd2d
PT
2334 break;
2335 case RESUME_RESOLVED:
2336 am_resolve(&state);
2337 break;
9990080c
PT
2338 case RESUME_SKIP:
2339 am_skip(&state);
2340 break;
33388a71
PT
2341 case RESUME_ABORT:
2342 am_abort(&state);
2343 break;
240bfd2d
PT
2344 default:
2345 die("BUG: invalid resume value");
2346 }
8c3bd9e2
PT
2347
2348 am_state_release(&state);
2349
73c2779f
PT
2350 return 0;
2351}