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