git.oblomov.eu Git - git/blob - 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 "lockfile.h"
  14 #include "cache-tree.h"
  15 #include "refs.h"
  16 #include "commit.h"
  17 #include "diff.h"
  18 #include "diffcore.h"
  19 #include "unpack-trees.h"
  20 #include "branch.h"
  21 #include "sequencer.h"
  22 #include "revision.h"
  23 #include "merge-recursive.h"
  24 #include "revision.h"
  25 #include "log-tree.h"
  26 #include "notes-utils.h"
  27 #include "rerere.h"
  28 #include "prompt.h"
  29
  30 /**
  31  * Returns 1 if the file is empty or does not exist, 0 otherwise.
  32  */
  33 static 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 }
  45
  46 /**
  47  * Like strbuf_getline(), but treats both '\n' and "\r\n" as line terminators.
  48  */
  49 static 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
  61 /**
  62  * Returns the length of the first line of msg.
  63  */
  64 static int linelen(const char *msg)
  65 {
  66         return strchrnul(msg, '\n') - msg;
  67 }
  68
  69 /**
  70  * Returns true if `str` consists of only whitespace, false otherwise.
  71  */
  72 static int str_isspace(const char *str)
  73 {
  74         for (; *str; str++)
  75                 if (!isspace(*str))
  76                         return 0;
  77
  78         return 1;
  79 }
  80
  81 enum patch_format {
  82         PATCH_FORMAT_UNKNOWN = 0,
  83         PATCH_FORMAT_MBOX,
  84         PATCH_FORMAT_STGIT,
  85         PATCH_FORMAT_STGIT_SERIES,
  86         PATCH_FORMAT_HG
  87 };
  88
  89 enum 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
  95 enum 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
 101 enum signoff_type {
 102         SIGNOFF_FALSE = 0,
 103         SIGNOFF_TRUE = 1,
 104         SIGNOFF_EXPLICIT /* --signoff was set on the command-line */
 105 };
 106
 107 struct am_state {
 108         /* state directory path */
 109         char *dir;
 110
 111         /* current and last patch numbers, 1-indexed */
 112         int cur;
 113         int last;
 114
 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
 122         /* when --rebasing, records the original commit the patch came from */
 123         unsigned char orig_commit[GIT_SHA1_RAWSZ];
 124
 125         /* number of digits in patch filename */
 126         int prec;
 127
 128         /* various operating modes and command line options */
 129         int interactive;
 130         int threeway;
 131         int quiet;
 132         int signoff; /* enum signoff_type */
 133         int utf8;
 134         int keep; /* enum keep_type */
 135         int message_id;
 136         int scissors; /* enum scissors_type */
 137         struct argv_array git_apply_opts;
 138         const char *resolvemsg;
 139         int committer_date_is_author_date;
 140         int ignore_date;
 141         int allow_rerere_autoupdate;
 142         const char *sign_commit;
 143         int rebasing;
 144 };
 145
 146 /**
 147  * Initializes am_state with the default values. The state directory is set to
 148  * dir.
 149  */
 150 static void am_state_init(struct am_state *state, const char *dir)
 151 {
 152         int gpgsign;
 153
 154         memset(state, 0, sizeof(*state));
 155
 156         assert(dir);
 157         state->dir = xstrdup(dir);
 158
 159         state->prec = 4;
 160
 161         git_config_get_bool("am.threeway", &state->threeway);
 162
 163         state->utf8 = 1;
 164
 165         git_config_get_bool("am.messageid", &state->message_id);
 166
 167         state->scissors = SCISSORS_UNSET;
 168
 169         argv_array_init(&state->git_apply_opts);
 170
 171         if (!git_config_get_bool("commit.gpgsign", &gpgsign))
 172                 state->sign_commit = gpgsign ? "" : NULL;
 173 }
 174
 175 /**
 176  * Releases memory allocated by an am_state.
 177  */
 178 static void am_state_release(struct am_state *state)
 179 {
 180         free(state->dir);
 181         free(state->author_name);
 182         free(state->author_email);
 183         free(state->author_date);
 184         free(state->msg);
 185         argv_array_clear(&state->git_apply_opts);
 186 }
 187
 188 /**
 189  * Returns path relative to the am_state directory.
 190  */
 191 static inline const char *am_path(const struct am_state *state, const char *path)
 192 {
 193         return mkpath("%s/%s", state->dir, path);
 194 }
 195
 196 /**
 197  * If state->quiet is false, calls fprintf(fp, fmt, ...), and appends a newline
 198  * at the end.
 199  */
 200 static 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
 212 /**
 213  * Returns 1 if there is an am session in progress, 0 otherwise.
 214  */
 215 static 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  */
 233 static 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
 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  */
 259 static 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
 281 fail:
 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  */
 302 static 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  */
 349 static 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  */
 377 static 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  */
 395 static 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
 406 /**
 407  * Loads state from disk.
 408  */
 409 static 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
 421         if (read_author_script(state) < 0)
 422                 die(_("could not parse author script"));
 423
 424         read_commit_msg(state);
 425
 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
 431         read_state_file(&sb, state, "threeway", 1);
 432         state->threeway = !strcmp(sb.buf, "t");
 433
 434         read_state_file(&sb, state, "quiet", 1);
 435         state->quiet = !strcmp(sb.buf, "t");
 436
 437         read_state_file(&sb, state, "sign", 1);
 438         state->signoff = !strcmp(sb.buf, "t");
 439
 440         read_state_file(&sb, state, "utf8", 1);
 441         state->utf8 = !strcmp(sb.buf, "t");
 442
 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
 451         read_state_file(&sb, state, "messageid", 1);
 452         state->message_id = !strcmp(sb.buf, "t");
 453
 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
 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
 467         state->rebasing = !!file_exists(am_path(state, "rebasing"));
 468
 469         strbuf_release(&sb);
 470 }
 471
 472 /**
 473  * Removes the am_state directory, forcefully terminating the current am
 474  * session.
 475  */
 476 static 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
 485 /**
 486  * Runs applypatch-msg hook. Returns its exit code.
 487  */
 488 static 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
 506 /**
 507  * Runs post-rewrite hook. Returns it exit code.
 508  */
 509 static 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
 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  */
 536 static 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
 581 finish:
 582         finish_copy_notes_for_rewrite(c, msg);
 583         fclose(fp);
 584         strbuf_release(&sb);
 585         return ret;
 586 }
 587
 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  */
 595 static 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
 623 done:
 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  */
 634 static int detect_patch_format(const char **paths)
 635 {
 636         enum patch_format ret = PATCH_FORMAT_UNKNOWN;
 637         struct strbuf l1 = STRBUF_INIT;
 638         struct strbuf l2 = STRBUF_INIT;
 639         struct strbuf l3 = STRBUF_INIT;
 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
 665         if (starts_with(l1.buf, "# This series applies on GIT commit")) {
 666                 ret = PATCH_FORMAT_STGIT_SERIES;
 667                 goto done;
 668         }
 669
 670         if (!strcmp(l1.buf, "# HG changeset patch")) {
 671                 ret = PATCH_FORMAT_HG;
 672                 goto done;
 673         }
 674
 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
 692         if (l1.len && is_mail(fp)) {
 693                 ret = PATCH_FORMAT_MBOX;
 694                 goto done;
 695         }
 696
 697 done:
 698         fclose(fp);
 699         strbuf_release(&l1);
 700         return ret;
 701 }
 702
 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  */
 707 static int split_mail_mbox(struct am_state *state, const char **paths, int keep_cr)
 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");
 717         if (keep_cr)
 718                 argv_array_push(&cp.args, "--keep-cr");
 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
 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  */
 736 typedef 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  */
 744 static 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  */
 792 static 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
 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  */
 834 static 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
 872 /**
 873  * A split_patches_conv() callback that converts a mercurial patch to a RFC2822
 874  * message suitable for parsing with git-mailinfo.
 875  */
 876 static 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
 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  *
 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  *
 949  * Returns 0 on success, -1 on failure.
 950  */
 951 static int split_mail(struct am_state *state, enum patch_format patch_format,
 952                         const char **paths, int keep_cr)
 953 {
 954         if (keep_cr < 0) {
 955                 keep_cr = 0;
 956                 git_config_get_bool("am.keepcr", &keep_cr);
 957         }
 958
 959         switch (patch_format) {
 960         case PATCH_FORMAT_MBOX:
 961                 return split_mail_mbox(state, paths, keep_cr);
 962         case PATCH_FORMAT_STGIT:
 963                 return split_mail_conv(stgit_patch_to_mail, state, paths, keep_cr);
 964         case PATCH_FORMAT_STGIT_SERIES:
 965                 return split_mail_stgit_series(state, paths, keep_cr);
 966         case PATCH_FORMAT_HG:
 967                 return split_mail_conv(hg_patch_to_mail, state, paths, keep_cr);
 968         default:
 969                 die("BUG: invalid patch_format");
 970         }
 971         return -1;
 972 }
 973
 974 /**
 975  * Setup a new am session for applying patches
 976  */
 977 static void am_setup(struct am_state *state, enum patch_format patch_format,
 978                         const char **paths, int keep_cr)
 979 {
 980         unsigned char curr_head[GIT_SHA1_RAWSZ];
 981         const char *str;
 982         struct strbuf sb = STRBUF_INIT;
 983
 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
 992         if (mkdir(state->dir, 0777) < 0 && errno != EEXIST)
 993                 die_errno(_("failed to create directory '%s'"), state->dir);
 994
 995         if (split_mail(state, patch_format, paths, keep_cr) < 0) {
 996                 am_destroy(state);
 997                 die(_("Failed to split patches."));
 998         }
 999
1000         if (state->rebasing)
1001                 state->threeway = 1;
1002
1003         write_file(am_path(state, "threeway"), 1, state->threeway ? "t" : "f");
1004
1005         write_file(am_path(state, "quiet"), 1, state->quiet ? "t" : "f");
1006
1007         write_file(am_path(state, "sign"), 1, state->signoff ? "t" : "f");
1008
1009         write_file(am_path(state, "utf8"), 1, state->utf8 ? "t" : "f");
1010
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
1027         write_file(am_path(state, "messageid"), 1, state->message_id ? "t" : "f");
1028
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
1045         sq_quote_argv(&sb, state->git_apply_opts.argv, 0);
1046         write_file(am_path(state, "apply-opt"), 1, "%s", sb.buf);
1047
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
1053         if (!get_sha1("HEAD", curr_head)) {
1054                 write_file(am_path(state, "abort-safety"), 1, "%s", sha1_to_hex(curr_head));
1055                 if (!state->rebasing)
1056                         update_ref("am", "ORIG_HEAD", curr_head, NULL, 0,
1057                                         UPDATE_REFS_DIE_ON_ERR);
1058         } else {
1059                 write_file(am_path(state, "abort-safety"), 1, "%s", "");
1060                 if (!state->rebasing)
1061                         delete_ref("ORIG_HEAD", NULL, 0);
1062         }
1063
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);
1072
1073         strbuf_release(&sb);
1074 }
1075
1076 /**
1077  * Increments the patch pointer, and cleans am_state for the application of the
1078  * next patch.
1079  */
1080 static void am_next(struct am_state *state)
1081 {
1082         unsigned char head[GIT_SHA1_RAWSZ];
1083
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
1100         hashclr(state->orig_commit);
1101         unlink(am_path(state, "original-commit"));
1102
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
1108         state->cur++;
1109         write_file(am_path(state, "next"), 1, "%d", state->cur);
1110 }
1111
1112 /**
1113  * Returns the filename of the current patch email.
1114  */
1115 static 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
1125 /**
1126  * Refresh and write index.
1127  */
1128 static 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
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  */
1144 static 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
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  */
1179 static void NORETURN die_user_resolve(const struct am_state *state)
1180 {
1181         if (state->resolvemsg) {
1182                 printf_ln("%s", state->resolvemsg);
1183         } else {
1184                 const char *cmdline = state->interactive ? "git am -i" : "git am";
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
1194 /**
1195  * Appends signoff to the "msg" field of the am_state.
1196  */
1197 static 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
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  */
1215 static 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");
1231         argv_array_push(&cp.args, state->utf8 ? "-u" : "-n");
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
1246         if (state->message_id)
1247                 argv_array_push(&cp.args, "-m");
1248
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
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?"));
1297                 die_user_resolve(state);
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
1305         if (state->signoff)
1306                 append_signoff(&msg, 0, 0);
1307
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
1320 finish:
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
1329 /**
1330  * Sets commit_id to the commit hash where the mail was generated from.
1331  * Returns 0 on success, -1 on failure.
1332  */
1333 static 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  */
1357 static 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  */
1405 static 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
1428 /**
1429  * Writes the diff of the index against HEAD as a patch to the state
1430  * directory's "patch" file.
1431  */
1432 static 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
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  *
1463  * state->orig_commit will be set to the original commit ID.
1464  *
1465  * Will always return 0 as the patch should never be skipped.
1466  */
1467 static 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
1481         hashcpy(state->orig_commit, commit_sha1);
1482         write_file(am_path(state, "original-commit"), 1, "%s",
1483                         sha1_to_hex(commit_sha1));
1484
1485         return 0;
1486 }
1487
1488 /**
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.
1491  */
1492 static int run_apply(const struct am_state *state, const char *index_file)
1493 {
1494         struct child_process cp = CHILD_PROCESS_INIT;
1495
1496         cp.git_cmd = 1;
1497
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
1510         argv_array_push(&cp.args, "apply");
1511
1512         argv_array_pushv(&cp.args, state->git_apply_opts.argv);
1513
1514         if (index_file)
1515                 argv_array_push(&cp.args, "--cached");
1516         else
1517                 argv_array_push(&cp.args, "--index");
1518
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. */
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  */
1534 static 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");
1540         argv_array_pushv(&cp.args, state->git_apply_opts.argv);
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  */
1553 static 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
1601         discard_cache();
1602         read_cache();
1603
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)) {
1622                 rerere(state->allow_rerere_autoupdate);
1623                 free(his_tree_name);
1624                 return error(_("Failed to merge in the changes."));
1625         }
1626
1627         free(his_tree_name);
1628         return 0;
1629 }
1630
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  */
1636 static 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
1645         if (run_hook_le(NULL, "pre-applypatch", NULL))
1646                 exit(1);
1647
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;
1656                 say(state, stderr, _("applying to an empty history"));
1657         }
1658
1659         author = fmt_ident(state->author_name, state->author_email,
1660                         state->ignore_date ? NULL : state->author_date,
1661                         IDENT_STRICT);
1662
1663         if (state->committer_date_is_author_date)
1664                 setenv("GIT_COMMITTER_DATE",
1665                         state->ignore_date ? "" : state->author_date, 1);
1666
1667         if (commit_tree(state->msg, state->msg_len, tree, parents, commit,
1668                                 author, state->sign_commit))
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
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
1689         run_hook_le(NULL, "post-applypatch", NULL);
1690
1691         strbuf_release(&sb);
1692 }
1693
1694 /**
1695  * Validates the am_state for resuming -- the "msg" and authorship fields must
1696  * be filled up.
1697  */
1698 static 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
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  */
1716 static 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
1768 /**
1769  * Applies all queued mail.
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.
1774  */
1775 static void am_run(struct am_state *state, int resume)
1776 {
1777         const char *argv_gc_auto[] = {"gc", "--auto", NULL};
1778         struct strbuf sb = STRBUF_INIT;
1779
1780         unlink(am_path(state, "dirtyindex"));
1781
1782         refresh_and_write_cache();
1783
1784         if (index_has_changes(&sb)) {
1785                 write_file(am_path(state, "dirtyindex"), 1, "t");
1786                 die(_("Dirty index: cannot apply patches (dirty: %s)"), sb.buf);
1787         }
1788
1789         strbuf_release(&sb);
1790
1791         while (state->cur <= state->last) {
1792                 const char *mail = am_path(state, msgnum(state));
1793                 int apply_status;
1794
1795                 if (!file_exists(mail))
1796                         goto next;
1797
1798                 if (resume) {
1799                         validate_resume_state(state);
1800                 } else {
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)
1809                                 goto next; /* mail should be skipped */
1810
1811                         write_author_script(state);
1812                         write_commit_msg(state);
1813                 }
1814
1815                 if (state->interactive && do_interactive(state))
1816                         goto next;
1817
1818                 if (run_applypatch_msg_hook(state))
1819                         exit(1);
1820
1821                 say(state, stdout, _("Applying: %.*s"), linelen(state->msg), state->msg);
1822
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) {
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
1854                         die_user_resolve(state);
1855                 }
1856
1857                 do_commit(state);
1858
1859 next:
1860                 am_next(state);
1861
1862                 if (resume)
1863                         am_load(state);
1864                 resume = 0;
1865         }
1866
1867         if (!is_empty_file(am_path(state, "rewritten"))) {
1868                 assert(state->rebasing);
1869                 copy_notes_for_rebase(state);
1870                 run_post_rewrite_hook(state);
1871         }
1872
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         }
1881 }
1882
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  */
1888 static void am_resolve(struct am_state *state)
1889 {
1890         validate_resume_state(state);
1891
1892         say(state, stdout, _("Applying: %.*s"), linelen(state->msg), state->msg);
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."));
1898                 die_user_resolve(state);
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'?"));
1904                 die_user_resolve(state);
1905         }
1906
1907         if (state->interactive) {
1908                 write_index_patch(state);
1909                 if (do_interactive(state))
1910                         goto next;
1911         }
1912
1913         rerere(0);
1914
1915         do_commit(state);
1916
1917 next:
1918         am_next(state);
1919         am_load(state);
1920         am_run(state, 0);
1921 }
1922
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  */
1928 static 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  */
1968 static 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
2016 /**
2017  * Resets rerere's merge resolution metadata.
2018  */
2019 static 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
2031 /**
2032  * Resume the current am session by skipping the current patch.
2033  */
2034 static void am_skip(struct am_state *state)
2035 {
2036         unsigned char head[GIT_SHA1_RAWSZ];
2037
2038         am_rerere_clear();
2039
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);
2047         am_load(state);
2048         am_run(state, 0);
2049 }
2050
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  */
2058 static 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  */
2087 static 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
2098         am_rerere_clear();
2099
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
2122 /**
2123  * parse_options() callback that validates and sets opt->value to the
2124  * PATCH_FORMAT_* enum value corresponding to `arg`.
2125  */
2126 static 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;
2132         else if (!strcmp(arg, "stgit"))
2133                 *opt_value = PATCH_FORMAT_STGIT;
2134         else if (!strcmp(arg, "stgit-series"))
2135                 *opt_value = PATCH_FORMAT_STGIT_SERIES;
2136         else if (!strcmp(arg, "hg"))
2137                 *opt_value = PATCH_FORMAT_HG;
2138         else
2139                 return error(_("Invalid value for --patch-format: %s"), arg);
2140         return 0;
2141 }
2142
2143 enum resume_mode {
2144         RESUME_FALSE = 0,
2145         RESUME_APPLY,
2146         RESUME_RESOLVED,
2147         RESUME_SKIP,
2148         RESUME_ABORT
2149 };
2150
2151 int cmd_am(int argc, const char **argv, const char *prefix)
2152 {
2153         struct am_state state;
2154         int binary = -1;
2155         int keep_cr = -1;
2156         int patch_format = PATCH_FORMAT_UNKNOWN;
2157         enum resume_mode resume = RESUME_FALSE;
2158         int in_progress;
2159
2160         const char * const usage[] = {
2161                 N_("git am [options] [(<mbox>|<Maildir>)...]"),
2162                 N_("git am [options] (--continue | --skip | --abort)"),
2163                 NULL
2164         };
2165
2166         struct option options[] = {
2167                 OPT_BOOL('i', "interactive", &state.interactive,
2168                         N_("run interactively")),
2169                 OPT_HIDDEN_BOOL('b', "binary", &binary,
2170                         N_("(historical option -- no-op")),
2171                 OPT_BOOL('3', "3way", &state.threeway,
2172                         N_("allow fall back on 3way merging if needed")),
2173                 OPT__QUIET(&state.quiet, N_("be quiet")),
2174                 OPT_SET_INT('s', "signoff", &state.signoff,
2175                         N_("add a Signed-off-by line to the commit message"),
2176                         SIGNOFF_EXPLICIT),
2177                 OPT_BOOL('u', "utf8", &state.utf8,
2178                         N_("recode into utf8 (default)")),
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),
2183                 OPT_BOOL('m', "message-id", &state.message_id,
2184                         N_("pass -m flag to git-mailinfo")),
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},
2191                 OPT_BOOL('c', "scissors", &state.scissors,
2192                         N_("strip everything before a scissors line")),
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),
2217                 OPT_CALLBACK(0, "patch-format", &patch_format, N_("format"),
2218                         N_("format the patch(es) are in"),
2219                         parse_opt_patchformat),
2220                 OPT_PASSTHRU_ARGV(0, "reject", &state.git_apply_opts, NULL,
2221                         N_("pass it through git-apply"),
2222                         PARSE_OPT_NOARG),
2223                 OPT_STRING(0, "resolvemsg", &state.resolvemsg, NULL,
2224                         N_("override error message when patch failure occurs")),
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),
2231                 OPT_CMDMODE(0, "skip", &resume,
2232                         N_("skip the current patch"),
2233                         RESUME_SKIP),
2234                 OPT_CMDMODE(0, "abort", &resume,
2235                         N_("restore the original branch and abort the patching operation."),
2236                         RESUME_ABORT),
2237                 OPT_BOOL(0, "committer-date-is-author-date",
2238                         &state.committer_date_is_author_date,
2239                         N_("lie about committer date")),
2240                 OPT_BOOL(0, "ignore-date", &state.ignore_date,
2241                         N_("use current timestamp for author date")),
2242                 OPT_RERERE_AUTOUPDATE(&state.allow_rerere_autoupdate),
2243                 { OPTION_STRING, 'S', "gpg-sign", &state.sign_commit, N_("key-id"),
2244                   N_("GPG-sign commits"),
2245                   PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
2246                 OPT_HIDDEN_BOOL(0, "rebasing", &state.rebasing,
2247                         N_("(internal use for git-rebase)")),
2248                 OPT_END()
2249         };
2250
2251         git_config(git_default_config, NULL);
2252
2253         am_state_init(&state, git_path("rebase-apply"));
2254
2255         in_progress = am_in_progress(&state);
2256         if (in_progress)
2257                 am_load(&state);
2258
2259         argc = parse_options(argc, argv, prefix, options, usage, 0);
2260
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
2265         /* Ensure a valid committer ident can be constructed */
2266         git_committer_info(IDENT_STRICT);
2267
2268         if (read_index_preload(&the_index, NULL) < 0)
2269                 die(_("failed to read the index"));
2270
2271         if (in_progress) {
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
2287                 if (resume == RESUME_FALSE)
2288                         resume = RESUME_APPLY;
2289
2290                 if (state.signoff == SIGNOFF_EXPLICIT)
2291                         am_append_signoff(&state);
2292         } else {
2293                 struct argv_array paths = ARGV_ARRAY_INIT;
2294                 int i;
2295
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
2313                 if (resume)
2314                         die(_("Resolve operation not in progress, we are not resuming."));
2315
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
2323                 am_setup(&state, patch_format, paths.argv, keep_cr);
2324
2325                 argv_array_clear(&paths);
2326         }
2327
2328         switch (resume) {
2329         case RESUME_FALSE:
2330                 am_run(&state, 0);
2331                 break;
2332         case RESUME_APPLY:
2333                 am_run(&state, 1);
2334                 break;
2335         case RESUME_RESOLVED:
2336                 am_resolve(&state);
2337                 break;
2338         case RESUME_SKIP:
2339                 am_skip(&state);
2340                 break;
2341         case RESUME_ABORT:
2342                 am_abort(&state);
2343                 break;
2344         default:
2345                 die("BUG: invalid resume value");
2346         }
2347
2348         am_state_release(&state);
2349
2350         return 0;
2351 }