634f7a7aa717e6da7ff9a549cb7d5c5585e10873
   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 */
  33static int is_empty_file(const char *filename)
  34{
  35        struct stat st;
  36
  37        if (stat(filename, &st) < 0) {
  38                if (errno == ENOENT)
  39                        return 1;
  40                die_errno(_("could not stat %s"), filename);
  41        }
  42
  43        return !st.st_size;
  44}
  45
  46/**
  47 * Like strbuf_getline(), but treats both '\n' and "\r\n" as line terminators.
  48 */
  49static int strbuf_getline_crlf(struct strbuf *sb, FILE *fp)
  50{
  51        if (strbuf_getwholeline(sb, fp, '\n'))
  52                return EOF;
  53        if (sb->buf[sb->len - 1] == '\n') {
  54                strbuf_setlen(sb, sb->len - 1);
  55                if (sb->len > 0 && sb->buf[sb->len - 1] == '\r')
  56                        strbuf_setlen(sb, sb->len - 1);
  57        }
  58        return 0;
  59}
  60
  61/**
  62 * Returns the length of the first line of msg.
  63 */
  64static int linelen(const char *msg)
  65{
  66        return strchrnul(msg, '\n') - msg;
  67}
  68
  69/**
  70 * Returns true if `str` consists of only whitespace, false otherwise.
  71 */
  72static int str_isspace(const char *str)
  73{
  74        for (; *str; str++)
  75                if (!isspace(*str))
  76                        return 0;
  77
  78        return 1;
  79}
  80
  81enum 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
  89enum keep_type {
  90        KEEP_FALSE = 0,
  91        KEEP_TRUE,      /* pass -k flag to git-mailinfo */
  92        KEEP_NON_PATCH  /* pass -b flag to git-mailinfo */
  93};
  94
  95enum scissors_type {
  96        SCISSORS_UNSET = -1,
  97        SCISSORS_FALSE = 0,  /* pass --no-scissors to git-mailinfo */
  98        SCISSORS_TRUE        /* pass --scissors to git-mailinfo */
  99};
 100
 101enum signoff_type {
 102        SIGNOFF_FALSE = 0,
 103        SIGNOFF_TRUE = 1,
 104        SIGNOFF_EXPLICIT /* --signoff was set on the command-line */
 105};
 106
 107struct am_state {
 108        /* state directory path */
 109        char *dir;
 110
 111        /* current and last patch numbers, 1-indexed */
 112        int cur;
 113        int last;
 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 */
 150static 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 */
 178static 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 */
 191static inline const char *am_path(const struct am_state *state, const char *path)
 192{
 193        return mkpath("%s/%s", state->dir, path);
 194}
 195
 196/**
 197 * If state->quiet is false, calls fprintf(fp, fmt, ...), and appends a newline
 198 * at the end.
 199 */
 200static void say(const struct am_state *state, FILE *fp, const char *fmt, ...)
 201{
 202        va_list ap;
 203
 204        va_start(ap, fmt);
 205        if (!state->quiet) {
 206                vfprintf(fp, fmt, ap);
 207                putc('\n', fp);
 208        }
 209        va_end(ap);
 210}
 211
 212/**
 213 * Returns 1 if there is an am session in progress, 0 otherwise.
 214 */
 215static int am_in_progress(const struct am_state *state)
 216{
 217        struct stat st;
 218
 219        if (lstat(state->dir, &st) < 0 || !S_ISDIR(st.st_mode))
 220                return 0;
 221        if (lstat(am_path(state, "last"), &st) || !S_ISREG(st.st_mode))
 222                return 0;
 223        if (lstat(am_path(state, "next"), &st) || !S_ISREG(st.st_mode))
 224                return 0;
 225        return 1;
 226}
 227
 228/**
 229 * Reads the contents of `file` in the `state` directory into `sb`. Returns the
 230 * number of bytes read on success, -1 if the file does not exist. If `trim` is
 231 * set, trailing whitespace will be removed.
 232 */
 233static int read_state_file(struct strbuf *sb, const struct am_state *state,
 234                        const char *file, int trim)
 235{
 236        strbuf_reset(sb);
 237
 238        if (strbuf_read_file(sb, am_path(state, file), 0) >= 0) {
 239                if (trim)
 240                        strbuf_trim(sb);
 241
 242                return sb->len;
 243        }
 244
 245        if (errno == ENOENT)
 246                return -1;
 247
 248        die_errno(_("could not read '%s'"), am_path(state, file));
 249}
 250
 251/**
 252 * Reads a KEY=VALUE shell variable assignment from `fp`, returning the VALUE
 253 * as a newly-allocated string. VALUE must be a quoted string, and the KEY must
 254 * match `key`. Returns NULL on failure.
 255 *
 256 * This is used by read_author_script() to read the GIT_AUTHOR_* variables from
 257 * the author-script.
 258 */
 259static char *read_shell_var(FILE *fp, const char *key)
 260{
 261        struct strbuf sb = STRBUF_INIT;
 262        const char *str;
 263
 264        if (strbuf_getline(&sb, fp, '\n'))
 265                goto fail;
 266
 267        if (!skip_prefix(sb.buf, key, &str))
 268                goto fail;
 269
 270        if (!skip_prefix(str, "=", &str))
 271                goto fail;
 272
 273        strbuf_remove(&sb, 0, str - sb.buf);
 274
 275        str = sq_dequote(sb.buf);
 276        if (!str)
 277                goto fail;
 278
 279        return strbuf_detach(&sb, NULL);
 280
 281fail:
 282        strbuf_release(&sb);
 283        return NULL;
 284}
 285
 286/**
 287 * Reads and parses the state directory's "author-script" file, and sets
 288 * state->author_name, state->author_email and state->author_date accordingly.
 289 * Returns 0 on success, -1 if the file could not be parsed.
 290 *
 291 * The author script is of the format:
 292 *
 293 *      GIT_AUTHOR_NAME='$author_name'
 294 *      GIT_AUTHOR_EMAIL='$author_email'
 295 *      GIT_AUTHOR_DATE='$author_date'
 296 *
 297 * where $author_name, $author_email and $author_date are quoted. We are strict
 298 * with our parsing, as the file was meant to be eval'd in the old git-am.sh
 299 * script, and thus if the file differs from what this function expects, it is
 300 * better to bail out than to do something that the user does not expect.
 301 */
 302static int read_author_script(struct am_state *state)
 303{
 304        const char *filename = am_path(state, "author-script");
 305        FILE *fp;
 306
 307        assert(!state->author_name);
 308        assert(!state->author_email);
 309        assert(!state->author_date);
 310
 311        fp = fopen(filename, "r");
 312        if (!fp) {
 313                if (errno == ENOENT)
 314                        return 0;
 315                die_errno(_("could not open '%s' for reading"), filename);
 316        }
 317
 318        state->author_name = read_shell_var(fp, "GIT_AUTHOR_NAME");
 319        if (!state->author_name) {
 320                fclose(fp);
 321                return -1;
 322        }
 323
 324        state->author_email = read_shell_var(fp, "GIT_AUTHOR_EMAIL");
 325        if (!state->author_email) {
 326                fclose(fp);
 327                return -1;
 328        }
 329
 330        state->author_date = read_shell_var(fp, "GIT_AUTHOR_DATE");
 331        if (!state->author_date) {
 332                fclose(fp);
 333                return -1;
 334        }
 335
 336        if (fgetc(fp) != EOF) {
 337                fclose(fp);
 338                return -1;
 339        }
 340
 341        fclose(fp);
 342        return 0;
 343}
 344
 345/**
 346 * Saves state->author_name, state->author_email and state->author_date in the
 347 * state directory's "author-script" file.
 348 */
 349static void write_author_script(const struct am_state *state)
 350{
 351        struct strbuf sb = STRBUF_INIT;
 352
 353        strbuf_addstr(&sb, "GIT_AUTHOR_NAME=");
 354        sq_quote_buf(&sb, state->author_name);
 355        strbuf_addch(&sb, '\n');
 356
 357        strbuf_addstr(&sb, "GIT_AUTHOR_EMAIL=");
 358        sq_quote_buf(&sb, state->author_email);
 359        strbuf_addch(&sb, '\n');
 360
 361        strbuf_addstr(&sb, "GIT_AUTHOR_DATE=");
 362        sq_quote_buf(&sb, state->author_date);
 363        strbuf_addch(&sb, '\n');
 364
 365        write_file(am_path(state, "author-script"), 1, "%s", sb.buf);
 366
 367        strbuf_release(&sb);
 368}
 369
 370/**
 371 * Reads the commit message from the state directory's "final-commit" file,
 372 * setting state->msg to its contents and state->msg_len to the length of its
 373 * contents in bytes.
 374 *
 375 * Returns 0 on success, -1 if the file does not exist.
 376 */
 377static int read_commit_msg(struct am_state *state)
 378{
 379        struct strbuf sb = STRBUF_INIT;
 380
 381        assert(!state->msg);
 382
 383        if (read_state_file(&sb, state, "final-commit", 0) < 0) {
 384                strbuf_release(&sb);
 385                return -1;
 386        }
 387
 388        state->msg = strbuf_detach(&sb, &state->msg_len);
 389        return 0;
 390}
 391
 392/**
 393 * Saves state->msg in the state directory's "final-commit" file.
 394 */
 395static void write_commit_msg(const struct am_state *state)
 396{
 397        int fd;
 398        const char *filename = am_path(state, "final-commit");
 399
 400        fd = xopen(filename, O_WRONLY | O_CREAT, 0666);
 401        if (write_in_full(fd, state->msg, state->msg_len) < 0)
 402                die_errno(_("could not write to %s"), filename);
 403        close(fd);
 404}
 405
 406/**
 407 * Loads state from disk.
 408 */
 409static void am_load(struct am_state *state)
 410{
 411        struct strbuf sb = STRBUF_INIT;
 412
 413        if (read_state_file(&sb, state, "next", 1) < 0)
 414                die("BUG: state file 'next' does not exist");
 415        state->cur = strtol(sb.buf, NULL, 10);
 416
 417        if (read_state_file(&sb, state, "last", 1) < 0)
 418                die("BUG: state file 'last' does not exist");
 419        state->last = strtol(sb.buf, NULL, 10);
 420
 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 */
 476static void am_destroy(const struct am_state *state)
 477{
 478        struct strbuf sb = STRBUF_INIT;
 479
 480        strbuf_addstr(&sb, state->dir);
 481        remove_dir_recursively(&sb, 0);
 482        strbuf_release(&sb);
 483}
 484
 485/**
 486 * Runs applypatch-msg hook. Returns its exit code.
 487 */
 488static int run_applypatch_msg_hook(struct am_state *state)
 489{
 490        int ret;
 491
 492        assert(state->msg);
 493        ret = run_hook_le(NULL, "applypatch-msg", am_path(state, "final-commit"), NULL);
 494
 495        if (!ret) {
 496                free(state->msg);
 497                state->msg = NULL;
 498                if (read_commit_msg(state) < 0)
 499                        die(_("'%s' was deleted by the applypatch-msg hook"),
 500                                am_path(state, "final-commit"));
 501        }
 502
 503        return ret;
 504}
 505
 506/**
 507 * Runs post-rewrite hook. Returns it exit code.
 508 */
 509static int run_post_rewrite_hook(const struct am_state *state)
 510{
 511        struct child_process cp = CHILD_PROCESS_INIT;
 512        const char *hook = find_hook("post-rewrite");
 513        int ret;
 514
 515        if (!hook)
 516                return 0;
 517
 518        argv_array_push(&cp.args, hook);
 519        argv_array_push(&cp.args, "rebase");
 520
 521        cp.in = xopen(am_path(state, "rewritten"), O_RDONLY);
 522        cp.stdout_to_stderr = 1;
 523
 524        ret = run_command(&cp);
 525
 526        close(cp.in);
 527        return ret;
 528}
 529
 530/**
 531 * Reads the state directory's "rewritten" file, and copies notes from the old
 532 * commits listed in the file to their rewritten commits.
 533 *
 534 * Returns 0 on success, -1 on failure.
 535 */
 536static int copy_notes_for_rebase(const struct am_state *state)
 537{
 538        struct notes_rewrite_cfg *c;
 539        struct strbuf sb = STRBUF_INIT;
 540        const char *invalid_line = _("Malformed input line: '%s'.");
 541        const char *msg = "Notes added by 'git rebase'";
 542        FILE *fp;
 543        int ret = 0;
 544
 545        assert(state->rebasing);
 546
 547        c = init_copy_notes_for_rewrite("rebase");
 548        if (!c)
 549                return 0;
 550
 551        fp = xfopen(am_path(state, "rewritten"), "r");
 552
 553        while (!strbuf_getline(&sb, fp, '\n')) {
 554                unsigned char from_obj[GIT_SHA1_RAWSZ], to_obj[GIT_SHA1_RAWSZ];
 555
 556                if (sb.len != GIT_SHA1_HEXSZ * 2 + 1) {
 557                        ret = error(invalid_line, sb.buf);
 558                        goto finish;
 559                }
 560
 561                if (get_sha1_hex(sb.buf, from_obj)) {
 562                        ret = error(invalid_line, sb.buf);
 563                        goto finish;
 564                }
 565
 566                if (sb.buf[GIT_SHA1_HEXSZ] != ' ') {
 567                        ret = error(invalid_line, sb.buf);
 568                        goto finish;
 569                }
 570
 571                if (get_sha1_hex(sb.buf + GIT_SHA1_HEXSZ + 1, to_obj)) {
 572                        ret = error(invalid_line, sb.buf);
 573                        goto finish;
 574                }
 575
 576                if (copy_note_for_rewrite(c, from_obj, to_obj))
 577                        ret = error(_("Failed to copy notes from '%s' to '%s'"),
 578                                        sha1_to_hex(from_obj), sha1_to_hex(to_obj));
 579        }
 580
 581finish:
 582        finish_copy_notes_for_rewrite(c, msg);
 583        fclose(fp);
 584        strbuf_release(&sb);
 585        return ret;
 586}
 587
 588/**
 589 * Determines if the file looks like a piece of RFC2822 mail by grabbing all
 590 * non-indented lines and checking if they look like they begin with valid
 591 * header field names.
 592 *
 593 * Returns 1 if the file looks like a piece of mail, 0 otherwise.
 594 */
 595static int is_mail(FILE *fp)
 596{
 597        const char *header_regex = "^[!-9;-~]+:";
 598        struct strbuf sb = STRBUF_INIT;
 599        regex_t regex;
 600        int ret = 1;
 601
 602        if (fseek(fp, 0L, SEEK_SET))
 603                die_errno(_("fseek failed"));
 604
 605        if (regcomp(&regex, header_regex, REG_NOSUB | REG_EXTENDED))
 606                die("invalid pattern: %s", header_regex);
 607
 608        while (!strbuf_getline_crlf(&sb, fp)) {
 609                if (!sb.len)
 610                        break; /* End of header */
 611
 612                /* Ignore indented folded lines */
 613                if (*sb.buf == '\t' || *sb.buf == ' ')
 614                        continue;
 615
 616                /* It's a header if it matches header_regex */
 617                if (regexec(&regex, sb.buf, 0, NULL, 0)) {
 618                        ret = 0;
 619                        goto done;
 620                }
 621        }
 622
 623done:
 624        regfree(&regex);
 625        strbuf_release(&sb);
 626        return ret;
 627}
 628
 629/**
 630 * Attempts to detect the patch_format of the patches contained in `paths`,
 631 * returning the PATCH_FORMAT_* enum value. Returns PATCH_FORMAT_UNKNOWN if
 632 * detection fails.
 633 */
 634static int detect_patch_format(const char **paths)
 635{
 636        enum patch_format ret = PATCH_FORMAT_UNKNOWN;
 637        struct strbuf l1 = STRBUF_INIT;
 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
 697done:
 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 */
 707static 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 */
 736typedef int (*mail_conv_fn)(FILE *out, FILE *in, int keep_cr);
 737
 738/**
 739 * Calls `fn` for each file in `paths` to convert the foreign patch to the
 740 * RFC2822 mail format suitable for parsing with git-mailinfo.
 741 *
 742 * Returns 0 on success, -1 on failure.
 743 */
 744static int split_mail_conv(mail_conv_fn fn, struct am_state *state,
 745                        const char **paths, int keep_cr)
 746{
 747        static const char *stdin_only[] = {"-", NULL};
 748        int i;
 749
 750        if (!*paths)
 751                paths = stdin_only;
 752
 753        for (i = 0; *paths; paths++, i++) {
 754                FILE *in, *out;
 755                const char *mail;
 756                int ret;
 757
 758                if (!strcmp(*paths, "-"))
 759                        in = stdin;
 760                else
 761                        in = fopen(*paths, "r");
 762
 763                if (!in)
 764                        return error(_("could not open '%s' for reading: %s"),
 765                                        *paths, strerror(errno));
 766
 767                mail = mkpath("%s/%0*d", state->dir, state->prec, i + 1);
 768
 769                out = fopen(mail, "w");
 770                if (!out)
 771                        return error(_("could not open '%s' for writing: %s"),
 772                                        mail, strerror(errno));
 773
 774                ret = fn(out, in, keep_cr);
 775
 776                fclose(out);
 777                fclose(in);
 778
 779                if (ret)
 780                        return error(_("could not parse patch '%s'"), *paths);
 781        }
 782
 783        state->cur = 1;
 784        state->last = i;
 785        return 0;
 786}
 787
 788/**
 789 * A split_mail_conv() callback that converts an StGit patch to an RFC2822
 790 * message suitable for parsing with git-mailinfo.
 791 */
 792static int stgit_patch_to_mail(FILE *out, FILE *in, int keep_cr)
 793{
 794        struct strbuf sb = STRBUF_INIT;
 795        int subject_printed = 0;
 796
 797        while (!strbuf_getline(&sb, in, '\n')) {
 798                const char *str;
 799
 800                if (str_isspace(sb.buf))
 801                        continue;
 802                else if (skip_prefix(sb.buf, "Author:", &str))
 803                        fprintf(out, "From:%s\n", str);
 804                else if (starts_with(sb.buf, "From") || starts_with(sb.buf, "Date"))
 805                        fprintf(out, "%s\n", sb.buf);
 806                else if (!subject_printed) {
 807                        fprintf(out, "Subject: %s\n", sb.buf);
 808                        subject_printed = 1;
 809                } else {
 810                        fprintf(out, "\n%s\n", sb.buf);
 811                        break;
 812                }
 813        }
 814
 815        strbuf_reset(&sb);
 816        while (strbuf_fread(&sb, 8192, in) > 0) {
 817                fwrite(sb.buf, 1, sb.len, out);
 818                strbuf_reset(&sb);
 819        }
 820
 821        strbuf_release(&sb);
 822        return 0;
 823}
 824
 825/**
 826 * This function only supports a single StGit series file in `paths`.
 827 *
 828 * Given an StGit series file, converts the StGit patches in the series into
 829 * RFC2822 messages suitable for parsing with git-mailinfo, and queues them in
 830 * the state directory.
 831 *
 832 * Returns 0 on success, -1 on failure.
 833 */
 834static int split_mail_stgit_series(struct am_state *state, const char **paths,
 835                                        int keep_cr)
 836{
 837        const char *series_dir;
 838        char *series_dir_buf;
 839        FILE *fp;
 840        struct argv_array patches = ARGV_ARRAY_INIT;
 841        struct strbuf sb = STRBUF_INIT;
 842        int ret;
 843
 844        if (!paths[0] || paths[1])
 845                return error(_("Only one StGIT patch series can be applied at once"));
 846
 847        series_dir_buf = xstrdup(*paths);
 848        series_dir = dirname(series_dir_buf);
 849
 850        fp = fopen(*paths, "r");
 851        if (!fp)
 852                return error(_("could not open '%s' for reading: %s"), *paths,
 853                                strerror(errno));
 854
 855        while (!strbuf_getline(&sb, fp, '\n')) {
 856                if (*sb.buf == '#')
 857                        continue; /* skip comment lines */
 858
 859                argv_array_push(&patches, mkpath("%s/%s", series_dir, sb.buf));
 860        }
 861
 862        fclose(fp);
 863        strbuf_release(&sb);
 864        free(series_dir_buf);
 865
 866        ret = split_mail_conv(stgit_patch_to_mail, state, patches.argv, keep_cr);
 867
 868        argv_array_clear(&patches);
 869        return ret;
 870}
 871
 872/**
 873 * A split_patches_conv() callback that converts a mercurial patch to a RFC2822
 874 * message suitable for parsing with git-mailinfo.
 875 */
 876static int hg_patch_to_mail(FILE *out, FILE *in, int keep_cr)
 877{
 878        struct strbuf sb = STRBUF_INIT;
 879
 880        while (!strbuf_getline(&sb, in, '\n')) {
 881                const char *str;
 882
 883                if (skip_prefix(sb.buf, "# User ", &str))
 884                        fprintf(out, "From: %s\n", str);
 885                else if (skip_prefix(sb.buf, "# Date ", &str)) {
 886                        unsigned long timestamp;
 887                        long tz, tz2;
 888                        char *end;
 889
 890                        errno = 0;
 891                        timestamp = strtoul(str, &end, 10);
 892                        if (errno)
 893                                return error(_("invalid timestamp"));
 894
 895                        if (!skip_prefix(end, " ", &str))
 896                                return error(_("invalid Date line"));
 897
 898                        errno = 0;
 899                        tz = strtol(str, &end, 10);
 900                        if (errno)
 901                                return error(_("invalid timezone offset"));
 902
 903                        if (*end)
 904                                return error(_("invalid Date line"));
 905
 906                        /*
 907                         * mercurial's timezone is in seconds west of UTC,
 908                         * however git's timezone is in hours + minutes east of
 909                         * UTC. Convert it.
 910                         */
 911                        tz2 = labs(tz) / 3600 * 100 + labs(tz) % 3600 / 60;
 912                        if (tz > 0)
 913                                tz2 = -tz2;
 914
 915                        fprintf(out, "Date: %s\n", show_date(timestamp, tz2, DATE_MODE(RFC2822)));
 916                } else if (starts_with(sb.buf, "# ")) {
 917                        continue;
 918                } else {
 919                        fprintf(out, "\n%s\n", sb.buf);
 920                        break;
 921                }
 922        }
 923
 924        strbuf_reset(&sb);
 925        while (strbuf_fread(&sb, 8192, in) > 0) {
 926                fwrite(sb.buf, 1, sb.len, out);
 927                strbuf_reset(&sb);
 928        }
 929
 930        strbuf_release(&sb);
 931        return 0;
 932}
 933
 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 */
 951static 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 */
 977static 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 */
1080static 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 */
1115static const char *msgnum(const struct am_state *state)
1116{
1117        static struct strbuf sb = STRBUF_INIT;
1118
1119        strbuf_reset(&sb);
1120        strbuf_addf(&sb, "%0*d", state->prec, state->cur);
1121
1122        return sb.buf;
1123}
1124
1125/**
1126 * Refresh and write index.
1127 */
1128static void refresh_and_write_cache(void)
1129{
1130        struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
1131
1132        hold_locked_index(lock_file, 1);
1133        refresh_cache(REFRESH_QUIET);
1134        if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))
1135                die(_("unable to write index file"));
1136}
1137
1138/**
1139 * Returns 1 if the index differs from HEAD, 0 otherwise. When on an unborn
1140 * branch, returns 1 if there are entries in the index, 0 otherwise. If an
1141 * strbuf is provided, the space-separated list of files that differ will be
1142 * appended to it.
1143 */
1144static int index_has_changes(struct strbuf *sb)
1145{
1146        unsigned char head[GIT_SHA1_RAWSZ];
1147        int i;
1148
1149        if (!get_sha1_tree("HEAD", head)) {
1150                struct diff_options opt;
1151
1152                diff_setup(&opt);
1153                DIFF_OPT_SET(&opt, EXIT_WITH_STATUS);
1154                if (!sb)
1155                        DIFF_OPT_SET(&opt, QUICK);
1156                do_diff_cache(head, &opt);
1157                diffcore_std(&opt);
1158                for (i = 0; sb && i < diff_queued_diff.nr; i++) {
1159                        if (i)
1160                                strbuf_addch(sb, ' ');
1161                        strbuf_addstr(sb, diff_queued_diff.queue[i]->two->path);
1162                }
1163                diff_flush(&opt);
1164                return DIFF_OPT_TST(&opt, HAS_CHANGES) != 0;
1165        } else {
1166                for (i = 0; sb && i < active_nr; i++) {
1167                        if (i)
1168                                strbuf_addch(sb, ' ');
1169                        strbuf_addstr(sb, active_cache[i]->name);
1170                }
1171                return !!active_nr;
1172        }
1173}
1174
1175/**
1176 * Dies with a user-friendly message on how to proceed after resolving the
1177 * problem. This message can be overridden with state->resolvemsg.
1178 */
1179static void NORETURN die_user_resolve(const struct am_state *state)
1180{
1181        if (state->resolvemsg) {
1182                printf_ln("%s", state->resolvemsg);
1183        } else {
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 */
1197static void am_append_signoff(struct am_state *state)
1198{
1199        struct strbuf sb = STRBUF_INIT;
1200
1201        strbuf_attach(&sb, state->msg, state->msg_len, state->msg_len);
1202        append_signoff(&sb, 0, 0);
1203        state->msg = strbuf_detach(&sb, &state->msg_len);
1204}
1205
1206/**
1207 * Parses `mail` using git-mailinfo, extracting its patch and authorship info.
1208 * state->msg will be set to the patch message. state->author_name,
1209 * state->author_email and state->author_date will be set to the patch author's
1210 * name, email and date respectively. The patch body will be written to the
1211 * state directory's "patch" file.
1212 *
1213 * Returns 1 if the patch should be skipped, 0 otherwise.
1214 */
1215static int parse_mail(struct am_state *state, const char *mail)
1216{
1217        FILE *fp;
1218        struct child_process cp = CHILD_PROCESS_INIT;
1219        struct strbuf sb = STRBUF_INIT;
1220        struct strbuf msg = STRBUF_INIT;
1221        struct strbuf author_name = STRBUF_INIT;
1222        struct strbuf author_date = STRBUF_INIT;
1223        struct strbuf author_email = STRBUF_INIT;
1224        int ret = 0;
1225
1226        cp.git_cmd = 1;
1227        cp.in = xopen(mail, O_RDONLY, 0);
1228        cp.out = xopen(am_path(state, "info"), O_WRONLY | O_CREAT, 0777);
1229
1230        argv_array_push(&cp.args, "mailinfo");
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
1320finish:
1321        strbuf_release(&msg);
1322        strbuf_release(&author_date);
1323        strbuf_release(&author_email);
1324        strbuf_release(&author_name);
1325        strbuf_release(&sb);
1326        return ret;
1327}
1328
1329/**
1330 * Sets commit_id to the commit hash where the mail was generated from.
1331 * Returns 0 on success, -1 on failure.
1332 */
1333static int get_mail_commit_sha1(unsigned char *commit_id, const char *mail)
1334{
1335        struct strbuf sb = STRBUF_INIT;
1336        FILE *fp = xfopen(mail, "r");
1337        const char *x;
1338
1339        if (strbuf_getline(&sb, fp, '\n'))
1340                return -1;
1341
1342        if (!skip_prefix(sb.buf, "From ", &x))
1343                return -1;
1344
1345        if (get_sha1_hex(x, commit_id) < 0)
1346                return -1;
1347
1348        strbuf_release(&sb);
1349        fclose(fp);
1350        return 0;
1351}
1352
1353/**
1354 * Sets state->msg, state->author_name, state->author_email, state->author_date
1355 * to the commit's respective info.
1356 */
1357static void get_commit_info(struct am_state *state, struct commit *commit)
1358{
1359        const char *buffer, *ident_line, *author_date, *msg;
1360        size_t ident_len;
1361        struct ident_split ident_split;
1362        struct strbuf sb = STRBUF_INIT;
1363
1364        buffer = logmsg_reencode(commit, NULL, get_commit_output_encoding());
1365
1366        ident_line = find_commit_header(buffer, "author", &ident_len);
1367
1368        if (split_ident_line(&ident_split, ident_line, ident_len) < 0) {
1369                strbuf_add(&sb, ident_line, ident_len);
1370                die(_("invalid ident line: %s"), sb.buf);
1371        }
1372
1373        assert(!state->author_name);
1374        if (ident_split.name_begin) {
1375                strbuf_add(&sb, ident_split.name_begin,
1376                        ident_split.name_end - ident_split.name_begin);
1377                state->author_name = strbuf_detach(&sb, NULL);
1378        } else
1379                state->author_name = xstrdup("");
1380
1381        assert(!state->author_email);
1382        if (ident_split.mail_begin) {
1383                strbuf_add(&sb, ident_split.mail_begin,
1384                        ident_split.mail_end - ident_split.mail_begin);
1385                state->author_email = strbuf_detach(&sb, NULL);
1386        } else
1387                state->author_email = xstrdup("");
1388
1389        author_date = show_ident_date(&ident_split, DATE_MODE(NORMAL));
1390        strbuf_addstr(&sb, author_date);
1391        assert(!state->author_date);
1392        state->author_date = strbuf_detach(&sb, NULL);
1393
1394        assert(!state->msg);
1395        msg = strstr(buffer, "\n\n");
1396        if (!msg)
1397                die(_("unable to parse commit %s"), sha1_to_hex(commit->object.sha1));
1398        state->msg = xstrdup(msg + 2);
1399        state->msg_len = strlen(state->msg);
1400}
1401
1402/**
1403 * Writes `commit` as a patch to the state directory's "patch" file.
1404 */
1405static void write_commit_patch(const struct am_state *state, struct commit *commit)
1406{
1407        struct rev_info rev_info;
1408        FILE *fp;
1409
1410        fp = xfopen(am_path(state, "patch"), "w");
1411        init_revisions(&rev_info, NULL);
1412        rev_info.diff = 1;
1413        rev_info.abbrev = 0;
1414        rev_info.disable_stdin = 1;
1415        rev_info.show_root_diff = 1;
1416        rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;
1417        rev_info.no_commit_id = 1;
1418        DIFF_OPT_SET(&rev_info.diffopt, BINARY);
1419        DIFF_OPT_SET(&rev_info.diffopt, FULL_INDEX);
1420        rev_info.diffopt.use_color = 0;
1421        rev_info.diffopt.file = fp;
1422        rev_info.diffopt.close_file = 1;
1423        add_pending_object(&rev_info, &commit->object, "");
1424        diff_setup_done(&rev_info.diffopt);
1425        log_tree_commit(&rev_info, commit);
1426}
1427
1428/**
1429 * Writes the diff of the index against HEAD as a patch to the state
1430 * directory's "patch" file.
1431 */
1432static void write_index_patch(const struct am_state *state)
1433{
1434        struct tree *tree;
1435        unsigned char head[GIT_SHA1_RAWSZ];
1436        struct rev_info rev_info;
1437        FILE *fp;
1438
1439        if (!get_sha1_tree("HEAD", head))
1440                tree = lookup_tree(head);
1441        else
1442                tree = lookup_tree(EMPTY_TREE_SHA1_BIN);
1443
1444        fp = xfopen(am_path(state, "patch"), "w");
1445        init_revisions(&rev_info, NULL);
1446        rev_info.diff = 1;
1447        rev_info.disable_stdin = 1;
1448        rev_info.no_commit_id = 1;
1449        rev_info.diffopt.output_format = DIFF_FORMAT_PATCH;
1450        rev_info.diffopt.use_color = 0;
1451        rev_info.diffopt.file = fp;
1452        rev_info.diffopt.close_file = 1;
1453        add_pending_object(&rev_info, &tree->object, "");
1454        diff_setup_done(&rev_info.diffopt);
1455        run_diff_index(&rev_info, 1);
1456}
1457
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 */
1467static int parse_mail_rebase(struct am_state *state, const char *mail)
1468{
1469        struct commit *commit;
1470        unsigned char commit_sha1[GIT_SHA1_RAWSZ];
1471
1472        if (get_mail_commit_sha1(commit_sha1, mail) < 0)
1473                die(_("could not parse %s"), mail);
1474
1475        commit = lookup_commit_or_die(commit_sha1, mail);
1476
1477        get_commit_info(state, commit);
1478
1479        write_commit_patch(state, commit);
1480
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 */
1492static 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 */
1534static int build_fake_ancestor(const struct am_state *state, const char *index_file)
1535{
1536        struct child_process cp = CHILD_PROCESS_INIT;
1537
1538        cp.git_cmd = 1;
1539        argv_array_push(&cp.args, "apply");
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 */
1553static int fall_back_threeway(const struct am_state *state, const char *index_path)
1554{
1555        unsigned char orig_tree[GIT_SHA1_RAWSZ], his_tree[GIT_SHA1_RAWSZ],
1556                      our_tree[GIT_SHA1_RAWSZ];
1557        const unsigned char *bases[1] = {orig_tree};
1558        struct merge_options o;
1559        struct commit *result;
1560        char *his_tree_name;
1561
1562        if (get_sha1("HEAD", our_tree) < 0)
1563                hashcpy(our_tree, EMPTY_TREE_SHA1_BIN);
1564
1565        if (build_fake_ancestor(state, index_path))
1566                return error("could not build fake ancestor");
1567
1568        discard_cache();
1569        read_cache_from(index_path);
1570
1571        if (write_index_as_tree(orig_tree, &the_index, index_path, 0, NULL))
1572                return error(_("Repository lacks necessary blobs to fall back on 3-way merge."));
1573
1574        say(state, stdout, _("Using index info to reconstruct a base tree..."));
1575
1576        if (!state->quiet) {
1577                /*
1578                 * List paths that needed 3-way fallback, so that the user can
1579                 * review them with extra care to spot mismerges.
1580                 */
1581                struct rev_info rev_info;
1582                const char *diff_filter_str = "--diff-filter=AM";
1583
1584                init_revisions(&rev_info, NULL);
1585                rev_info.diffopt.output_format = DIFF_FORMAT_NAME_STATUS;
1586                diff_opt_parse(&rev_info.diffopt, &diff_filter_str, 1);
1587                add_pending_sha1(&rev_info, "HEAD", our_tree, 0);
1588                diff_setup_done(&rev_info.diffopt);
1589                run_diff_index(&rev_info, 1);
1590        }
1591
1592        if (run_apply(state, index_path))
1593                return error(_("Did you hand edit your patch?\n"
1594                                "It does not apply to blobs recorded in its index."));
1595
1596        if (write_index_as_tree(his_tree, &the_index, index_path, 0, NULL))
1597                return error("could not write tree");
1598
1599        say(state, stdout, _("Falling back to patching base and 3-way merge..."));
1600
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 */
1636static void do_commit(const struct am_state *state)
1637{
1638        unsigned char tree[GIT_SHA1_RAWSZ], parent[GIT_SHA1_RAWSZ],
1639                      commit[GIT_SHA1_RAWSZ];
1640        unsigned char *ptr;
1641        struct commit_list *parents = NULL;
1642        const char *reflog_msg, *author;
1643        struct strbuf sb = STRBUF_INIT;
1644
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 */
1698static void validate_resume_state(const struct am_state *state)
1699{
1700        if (!state->msg)
1701                die(_("cannot resume: %s does not exist."),
1702                        am_path(state, "final-commit"));
1703
1704        if (!state->author_name || !state->author_email || !state->author_date)
1705                die(_("cannot resume: %s does not exist."),
1706                        am_path(state, "author-script"));
1707}
1708
1709/**
1710 * Interactively prompt the user on whether the current patch should be
1711 * applied.
1712 *
1713 * Returns 0 if the user chooses to apply the patch, 1 if the user chooses to
1714 * skip it.
1715 */
1716static int do_interactive(struct am_state *state)
1717{
1718        assert(state->msg);
1719
1720        if (!isatty(0))
1721                die(_("cannot be interactive without stdin connected to a terminal."));
1722
1723        for (;;) {
1724                const char *reply;
1725
1726                puts(_("Commit Body is:"));
1727                puts("--------------------------");
1728                printf("%s", state->msg);
1729                puts("--------------------------");
1730
1731                /*
1732                 * TRANSLATORS: Make sure to include [y], [n], [e], [v] and [a]
1733                 * in your translation. The program will only accept English
1734                 * input at this point.
1735                 */
1736                reply = git_prompt(_("Apply? [y]es/[n]o/[e]dit/[v]iew patch/[a]ccept all: "), PROMPT_ECHO);
1737
1738                if (!reply) {
1739                        continue;
1740                } else if (*reply == 'y' || *reply == 'Y') {
1741                        return 0;
1742                } else if (*reply == 'a' || *reply == 'A') {
1743                        state->interactive = 0;
1744                        return 0;
1745                } else if (*reply == 'n' || *reply == 'N') {
1746                        return 1;
1747                } else if (*reply == 'e' || *reply == 'E') {
1748                        struct strbuf msg = STRBUF_INIT;
1749
1750                        if (!launch_editor(am_path(state, "final-commit"), &msg, NULL)) {
1751                                free(state->msg);
1752                                state->msg = strbuf_detach(&msg, &state->msg_len);
1753                        }
1754                        strbuf_release(&msg);
1755                } else if (*reply == 'v' || *reply == 'V') {
1756                        const char *pager = git_pager(1);
1757                        struct child_process cp = CHILD_PROCESS_INIT;
1758
1759                        if (!pager)
1760                                pager = "cat";
1761                        argv_array_push(&cp.args, pager);
1762                        argv_array_push(&cp.args, am_path(state, "patch"));
1763                        run_command(&cp);
1764                }
1765        }
1766}
1767
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 */
1775static 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
1859next:
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 */
1888static 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
1917next:
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 */
1928static int fast_forward_to(struct tree *head, struct tree *remote, int reset)
1929{
1930        struct lock_file *lock_file;
1931        struct unpack_trees_options opts;
1932        struct tree_desc t[2];
1933
1934        if (parse_tree(head) || parse_tree(remote))
1935                return -1;
1936
1937        lock_file = xcalloc(1, sizeof(struct lock_file));
1938        hold_locked_index(lock_file, 1);
1939
1940        refresh_cache(REFRESH_QUIET);
1941
1942        memset(&opts, 0, sizeof(opts));
1943        opts.head_idx = 1;
1944        opts.src_index = &the_index;
1945        opts.dst_index = &the_index;
1946        opts.update = 1;
1947        opts.merge = 1;
1948        opts.reset = reset;
1949        opts.fn = twoway_merge;
1950        init_tree_desc(&t[0], head->buffer, head->size);
1951        init_tree_desc(&t[1], remote->buffer, remote->size);
1952
1953        if (unpack_trees(2, t, &opts)) {
1954                rollback_lock_file(lock_file);
1955                return -1;
1956        }
1957
1958        if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))
1959                die(_("unable to write new index file"));
1960
1961        return 0;
1962}
1963
1964/**
1965 * Clean the index without touching entries that are not modified between
1966 * `head` and `remote`.
1967 */
1968static int clean_index(const unsigned char *head, const unsigned char *remote)
1969{
1970        struct lock_file *lock_file;
1971        struct tree *head_tree, *remote_tree, *index_tree;
1972        unsigned char index[GIT_SHA1_RAWSZ];
1973        struct pathspec pathspec;
1974
1975        head_tree = parse_tree_indirect(head);
1976        if (!head_tree)
1977                return error(_("Could not parse object '%s'."), sha1_to_hex(head));
1978
1979        remote_tree = parse_tree_indirect(remote);
1980        if (!remote_tree)
1981                return error(_("Could not parse object '%s'."), sha1_to_hex(remote));
1982
1983        read_cache_unmerged();
1984
1985        if (fast_forward_to(head_tree, head_tree, 1))
1986                return -1;
1987
1988        if (write_cache_as_tree(index, 0, NULL))
1989                return -1;
1990
1991        index_tree = parse_tree_indirect(index);
1992        if (!index_tree)
1993                return error(_("Could not parse object '%s'."), sha1_to_hex(index));
1994
1995        if (fast_forward_to(index_tree, remote_tree, 0))
1996                return -1;
1997
1998        memset(&pathspec, 0, sizeof(pathspec));
1999
2000        lock_file = xcalloc(1, sizeof(struct lock_file));
2001        hold_locked_index(lock_file, 1);
2002
2003        if (read_tree(remote_tree, 0, &pathspec)) {
2004                rollback_lock_file(lock_file);
2005                return -1;
2006        }
2007
2008        if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))
2009                die(_("unable to write new index file"));
2010
2011        remove_branch_state();
2012
2013        return 0;
2014}
2015
2016/**
2017 * Resets rerere's merge resolution metadata.
2018 */
2019static void am_rerere_clear(void)
2020{
2021        struct string_list merge_rr = STRING_LIST_INIT_DUP;
2022        int fd = setup_rerere(&merge_rr, 0);
2023
2024        if (fd < 0)
2025                return;
2026
2027        rerere_clear(&merge_rr);
2028        string_list_clear(&merge_rr, 1);
2029}
2030
2031/**
2032 * Resume the current am session by skipping the current patch.
2033 */
2034static void am_skip(struct am_state *state)
2035{
2036        unsigned char head[GIT_SHA1_RAWSZ];
2037
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 */
2058static int safe_to_abort(const struct am_state *state)
2059{
2060        struct strbuf sb = STRBUF_INIT;
2061        unsigned char abort_safety[GIT_SHA1_RAWSZ], head[GIT_SHA1_RAWSZ];
2062
2063        if (file_exists(am_path(state, "dirtyindex")))
2064                return 0;
2065
2066        if (read_state_file(&sb, state, "abort-safety", 1) > 0) {
2067                if (get_sha1_hex(sb.buf, abort_safety))
2068                        die(_("could not parse %s"), am_path(state, "abort_safety"));
2069        } else
2070                hashclr(abort_safety);
2071
2072        if (get_sha1("HEAD", head))
2073                hashclr(head);
2074
2075        if (!hashcmp(head, abort_safety))
2076                return 1;
2077
2078        error(_("You seem to have moved HEAD since the last 'am' failure.\n"
2079                "Not rewinding to ORIG_HEAD"));
2080
2081        return 0;
2082}
2083
2084/**
2085 * Aborts the current am session if it is safe to do so.
2086 */
2087static void am_abort(struct am_state *state)
2088{
2089        unsigned char curr_head[GIT_SHA1_RAWSZ], orig_head[GIT_SHA1_RAWSZ];
2090        int has_curr_head, has_orig_head;
2091        char *curr_branch;
2092
2093        if (!safe_to_abort(state)) {
2094                am_destroy(state);
2095                return;
2096        }
2097
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 */
2126static int parse_opt_patchformat(const struct option *opt, const char *arg, int unset)
2127{
2128        int *opt_value = opt->value;
2129
2130        if (!strcmp(arg, "mbox"))
2131                *opt_value = PATCH_FORMAT_MBOX;
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
2143enum resume_mode {
2144        RESUME_FALSE = 0,
2145        RESUME_APPLY,
2146        RESUME_RESOLVED,
2147        RESUME_SKIP,
2148        RESUME_ABORT
2149};
2150
2151int 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}