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