1cf68ede1263dd56466689f5c94eedfe194c45da
   1/*
   2 * apply.c
   3 *
   4 * Copyright (C) Linus Torvalds, 2005
   5 *
   6 * This applies patches on top of some (arbitrary) version of the SCM.
   7 *
   8 */
   9#include "cache.h"
  10#include "cache-tree.h"
  11#include "quote.h"
  12#include "blob.h"
  13#include "delta.h"
  14#include "builtin.h"
  15
  16/*
  17 *  --check turns on checking that the working tree matches the
  18 *    files that are being modified, but doesn't apply the patch
  19 *  --stat does just a diffstat, and doesn't actually apply
  20 *  --numstat does numeric diffstat, and doesn't actually apply
  21 *  --index-info shows the old and new index info for paths if available.
  22 *  --index updates the cache as well.
  23 *  --cached updates only the cache without ever touching the working tree.
  24 */
  25static const char *prefix;
  26static int prefix_length = -1;
  27static int newfd = -1;
  28
  29static int unidiff_zero;
  30static int p_value = 1;
  31static int p_value_known;
  32static int check_index;
  33static int update_index;
  34static int cached;
  35static int diffstat;
  36static int numstat;
  37static int summary;
  38static int check;
  39static int apply = 1;
  40static int apply_in_reverse;
  41static int apply_with_reject;
  42static int apply_verbosely;
  43static int no_add;
  44static int show_index_info;
  45static int line_termination = '\n';
  46static unsigned long p_context = ULONG_MAX;
  47static const char apply_usage[] =
  48"git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--cached] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [--reverse] [--reject] [--verbose] [-z] [-pNUM] [-CNUM] [--whitespace=<nowarn|warn|error|error-all|strip>] <patch>...";
  49
  50static enum whitespace_eol {
  51        nowarn_whitespace,
  52        warn_on_whitespace,
  53        error_on_whitespace,
  54        strip_whitespace,
  55} new_whitespace = warn_on_whitespace;
  56static int whitespace_error;
  57static int squelch_whitespace_errors = 5;
  58static int applied_after_fixing_ws;
  59static const char *patch_input_file;
  60
  61static void parse_whitespace_option(const char *option)
  62{
  63        if (!option) {
  64                new_whitespace = warn_on_whitespace;
  65                return;
  66        }
  67        if (!strcmp(option, "warn")) {
  68                new_whitespace = warn_on_whitespace;
  69                return;
  70        }
  71        if (!strcmp(option, "nowarn")) {
  72                new_whitespace = nowarn_whitespace;
  73                return;
  74        }
  75        if (!strcmp(option, "error")) {
  76                new_whitespace = error_on_whitespace;
  77                return;
  78        }
  79        if (!strcmp(option, "error-all")) {
  80                new_whitespace = error_on_whitespace;
  81                squelch_whitespace_errors = 0;
  82                return;
  83        }
  84        if (!strcmp(option, "strip")) {
  85                new_whitespace = strip_whitespace;
  86                return;
  87        }
  88        die("unrecognized whitespace option '%s'", option);
  89}
  90
  91static void set_default_whitespace_mode(const char *whitespace_option)
  92{
  93        if (!whitespace_option && !apply_default_whitespace) {
  94                new_whitespace = (apply
  95                                  ? warn_on_whitespace
  96                                  : nowarn_whitespace);
  97        }
  98}
  99
 100/*
 101 * For "diff-stat" like behaviour, we keep track of the biggest change
 102 * we've seen, and the longest filename. That allows us to do simple
 103 * scaling.
 104 */
 105static int max_change, max_len;
 106
 107/*
 108 * Various "current state", notably line numbers and what
 109 * file (and how) we're patching right now.. The "is_xxxx"
 110 * things are flags, where -1 means "don't know yet".
 111 */
 112static int linenr = 1;
 113
 114/*
 115 * This represents one "hunk" from a patch, starting with
 116 * "@@ -oldpos,oldlines +newpos,newlines @@" marker.  The
 117 * patch text is pointed at by patch, and its byte length
 118 * is stored in size.  leading and trailing are the number
 119 * of context lines.
 120 */
 121struct fragment {
 122        unsigned long leading, trailing;
 123        unsigned long oldpos, oldlines;
 124        unsigned long newpos, newlines;
 125        const char *patch;
 126        int size;
 127        int rejected;
 128        struct fragment *next;
 129};
 130
 131/*
 132 * When dealing with a binary patch, we reuse "leading" field
 133 * to store the type of the binary hunk, either deflated "delta"
 134 * or deflated "literal".
 135 */
 136#define binary_patch_method leading
 137#define BINARY_DELTA_DEFLATED   1
 138#define BINARY_LITERAL_DEFLATED 2
 139
 140struct patch {
 141        char *new_name, *old_name, *def_name;
 142        unsigned int old_mode, new_mode;
 143        int is_new, is_delete;  /* -1 = unknown, 0 = false, 1 = true */
 144        int rejected;
 145        unsigned long deflate_origlen;
 146        int lines_added, lines_deleted;
 147        int score;
 148        unsigned int is_toplevel_relative:1;
 149        unsigned int inaccurate_eof:1;
 150        unsigned int is_binary:1;
 151        unsigned int is_copy:1;
 152        unsigned int is_rename:1;
 153        struct fragment *fragments;
 154        char *result;
 155        unsigned long resultsize;
 156        char old_sha1_prefix[41];
 157        char new_sha1_prefix[41];
 158        struct patch *next;
 159};
 160
 161static void say_patch_name(FILE *output, const char *pre, struct patch *patch, const char *post)
 162{
 163        fputs(pre, output);
 164        if (patch->old_name && patch->new_name &&
 165            strcmp(patch->old_name, patch->new_name)) {
 166                write_name_quoted(NULL, 0, patch->old_name, 1, output);
 167                fputs(" => ", output);
 168                write_name_quoted(NULL, 0, patch->new_name, 1, output);
 169        }
 170        else {
 171                const char *n = patch->new_name;
 172                if (!n)
 173                        n = patch->old_name;
 174                write_name_quoted(NULL, 0, n, 1, output);
 175        }
 176        fputs(post, output);
 177}
 178
 179#define CHUNKSIZE (8192)
 180#define SLOP (16)
 181
 182static void *read_patch_file(int fd, unsigned long *sizep)
 183{
 184        struct strbuf buf;
 185
 186        strbuf_init(&buf, 0);
 187        if (strbuf_read(&buf, fd, 0) < 0)
 188                die("git-apply: read returned %s", strerror(errno));
 189        *sizep = buf.len;
 190
 191        /*
 192         * Make sure that we have some slop in the buffer
 193         * so that we can do speculative "memcmp" etc, and
 194         * see to it that it is NUL-filled.
 195         */
 196        strbuf_grow(&buf, SLOP);
 197        memset(buf.buf + buf.len, 0, SLOP);
 198        return strbuf_detach(&buf);
 199}
 200
 201static unsigned long linelen(const char *buffer, unsigned long size)
 202{
 203        unsigned long len = 0;
 204        while (size--) {
 205                len++;
 206                if (*buffer++ == '\n')
 207                        break;
 208        }
 209        return len;
 210}
 211
 212static int is_dev_null(const char *str)
 213{
 214        return !memcmp("/dev/null", str, 9) && isspace(str[9]);
 215}
 216
 217#define TERM_SPACE      1
 218#define TERM_TAB        2
 219
 220static int name_terminate(const char *name, int namelen, int c, int terminate)
 221{
 222        if (c == ' ' && !(terminate & TERM_SPACE))
 223                return 0;
 224        if (c == '\t' && !(terminate & TERM_TAB))
 225                return 0;
 226
 227        return 1;
 228}
 229
 230static char *find_name(const char *line, char *def, int p_value, int terminate)
 231{
 232        int len;
 233        const char *start = line;
 234
 235        if (*line == '"') {
 236                struct strbuf name;
 237
 238                /* Proposed "new-style" GNU patch/diff format; see
 239                 * http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2
 240                 */
 241                strbuf_init(&name, 0);
 242                if (!unquote_c_style(&name, line, NULL)) {
 243                        char *cp;
 244
 245                        for (cp = name.buf; p_value; p_value--) {
 246                                cp = strchr(cp, '/');
 247                                if (!cp)
 248                                        break;
 249                                cp++;
 250                        }
 251                        if (cp) {
 252                                /* name can later be freed, so we need
 253                                 * to memmove, not just return cp
 254                                 */
 255                                strbuf_remove(&name, 0, cp - name.buf);
 256                                free(def);
 257                                return name.buf;
 258                        }
 259                }
 260                strbuf_release(&name);
 261        }
 262
 263        for (;;) {
 264                char c = *line;
 265
 266                if (isspace(c)) {
 267                        if (c == '\n')
 268                                break;
 269                        if (name_terminate(start, line-start, c, terminate))
 270                                break;
 271                }
 272                line++;
 273                if (c == '/' && !--p_value)
 274                        start = line;
 275        }
 276        if (!start)
 277                return def;
 278        len = line - start;
 279        if (!len)
 280                return def;
 281
 282        /*
 283         * Generally we prefer the shorter name, especially
 284         * if the other one is just a variation of that with
 285         * something else tacked on to the end (ie "file.orig"
 286         * or "file~").
 287         */
 288        if (def) {
 289                int deflen = strlen(def);
 290                if (deflen < len && !strncmp(start, def, deflen))
 291                        return def;
 292                free(def);
 293        }
 294
 295        return xmemdupz(start, len);
 296}
 297
 298static int count_slashes(const char *cp)
 299{
 300        int cnt = 0;
 301        char ch;
 302
 303        while ((ch = *cp++))
 304                if (ch == '/')
 305                        cnt++;
 306        return cnt;
 307}
 308
 309/*
 310 * Given the string after "--- " or "+++ ", guess the appropriate
 311 * p_value for the given patch.
 312 */
 313static int guess_p_value(const char *nameline)
 314{
 315        char *name, *cp;
 316        int val = -1;
 317
 318        if (is_dev_null(nameline))
 319                return -1;
 320        name = find_name(nameline, NULL, 0, TERM_SPACE | TERM_TAB);
 321        if (!name)
 322                return -1;
 323        cp = strchr(name, '/');
 324        if (!cp)
 325                val = 0;
 326        else if (prefix) {
 327                /*
 328                 * Does it begin with "a/$our-prefix" and such?  Then this is
 329                 * very likely to apply to our directory.
 330                 */
 331                if (!strncmp(name, prefix, prefix_length))
 332                        val = count_slashes(prefix);
 333                else {
 334                        cp++;
 335                        if (!strncmp(cp, prefix, prefix_length))
 336                                val = count_slashes(prefix) + 1;
 337                }
 338        }
 339        free(name);
 340        return val;
 341}
 342
 343/*
 344 * Get the name etc info from the --/+++ lines of a traditional patch header
 345 *
 346 * FIXME! The end-of-filename heuristics are kind of screwy. For existing
 347 * files, we can happily check the index for a match, but for creating a
 348 * new file we should try to match whatever "patch" does. I have no idea.
 349 */
 350static void parse_traditional_patch(const char *first, const char *second, struct patch *patch)
 351{
 352        char *name;
 353
 354        first += 4;     /* skip "--- " */
 355        second += 4;    /* skip "+++ " */
 356        if (!p_value_known) {
 357                int p, q;
 358                p = guess_p_value(first);
 359                q = guess_p_value(second);
 360                if (p < 0) p = q;
 361                if (0 <= p && p == q) {
 362                        p_value = p;
 363                        p_value_known = 1;
 364                }
 365        }
 366        if (is_dev_null(first)) {
 367                patch->is_new = 1;
 368                patch->is_delete = 0;
 369                name = find_name(second, NULL, p_value, TERM_SPACE | TERM_TAB);
 370                patch->new_name = name;
 371        } else if (is_dev_null(second)) {
 372                patch->is_new = 0;
 373                patch->is_delete = 1;
 374                name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
 375                patch->old_name = name;
 376        } else {
 377                name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
 378                name = find_name(second, name, p_value, TERM_SPACE | TERM_TAB);
 379                patch->old_name = patch->new_name = name;
 380        }
 381        if (!name)
 382                die("unable to find filename in patch at line %d", linenr);
 383}
 384
 385static int gitdiff_hdrend(const char *line, struct patch *patch)
 386{
 387        return -1;
 388}
 389
 390/*
 391 * We're anal about diff header consistency, to make
 392 * sure that we don't end up having strange ambiguous
 393 * patches floating around.
 394 *
 395 * As a result, gitdiff_{old|new}name() will check
 396 * their names against any previous information, just
 397 * to make sure..
 398 */
 399static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, const char *oldnew)
 400{
 401        if (!orig_name && !isnull)
 402                return find_name(line, NULL, p_value, TERM_TAB);
 403
 404        if (orig_name) {
 405                int len;
 406                const char *name;
 407                char *another;
 408                name = orig_name;
 409                len = strlen(name);
 410                if (isnull)
 411                        die("git-apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr);
 412                another = find_name(line, NULL, p_value, TERM_TAB);
 413                if (!another || memcmp(another, name, len))
 414                        die("git-apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr);
 415                free(another);
 416                return orig_name;
 417        }
 418        else {
 419                /* expect "/dev/null" */
 420                if (memcmp("/dev/null", line, 9) || line[9] != '\n')
 421                        die("git-apply: bad git-diff - expected /dev/null on line %d", linenr);
 422                return NULL;
 423        }
 424}
 425
 426static int gitdiff_oldname(const char *line, struct patch *patch)
 427{
 428        patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name, "old");
 429        return 0;
 430}
 431
 432static int gitdiff_newname(const char *line, struct patch *patch)
 433{
 434        patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name, "new");
 435        return 0;
 436}
 437
 438static int gitdiff_oldmode(const char *line, struct patch *patch)
 439{
 440        patch->old_mode = strtoul(line, NULL, 8);
 441        return 0;
 442}
 443
 444static int gitdiff_newmode(const char *line, struct patch *patch)
 445{
 446        patch->new_mode = strtoul(line, NULL, 8);
 447        return 0;
 448}
 449
 450static int gitdiff_delete(const char *line, struct patch *patch)
 451{
 452        patch->is_delete = 1;
 453        patch->old_name = patch->def_name;
 454        return gitdiff_oldmode(line, patch);
 455}
 456
 457static int gitdiff_newfile(const char *line, struct patch *patch)
 458{
 459        patch->is_new = 1;
 460        patch->new_name = patch->def_name;
 461        return gitdiff_newmode(line, patch);
 462}
 463
 464static int gitdiff_copysrc(const char *line, struct patch *patch)
 465{
 466        patch->is_copy = 1;
 467        patch->old_name = find_name(line, NULL, 0, 0);
 468        return 0;
 469}
 470
 471static int gitdiff_copydst(const char *line, struct patch *patch)
 472{
 473        patch->is_copy = 1;
 474        patch->new_name = find_name(line, NULL, 0, 0);
 475        return 0;
 476}
 477
 478static int gitdiff_renamesrc(const char *line, struct patch *patch)
 479{
 480        patch->is_rename = 1;
 481        patch->old_name = find_name(line, NULL, 0, 0);
 482        return 0;
 483}
 484
 485static int gitdiff_renamedst(const char *line, struct patch *patch)
 486{
 487        patch->is_rename = 1;
 488        patch->new_name = find_name(line, NULL, 0, 0);
 489        return 0;
 490}
 491
 492static int gitdiff_similarity(const char *line, struct patch *patch)
 493{
 494        if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
 495                patch->score = 0;
 496        return 0;
 497}
 498
 499static int gitdiff_dissimilarity(const char *line, struct patch *patch)
 500{
 501        if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
 502                patch->score = 0;
 503        return 0;
 504}
 505
 506static int gitdiff_index(const char *line, struct patch *patch)
 507{
 508        /* index line is N hexadecimal, "..", N hexadecimal,
 509         * and optional space with octal mode.
 510         */
 511        const char *ptr, *eol;
 512        int len;
 513
 514        ptr = strchr(line, '.');
 515        if (!ptr || ptr[1] != '.' || 40 < ptr - line)
 516                return 0;
 517        len = ptr - line;
 518        memcpy(patch->old_sha1_prefix, line, len);
 519        patch->old_sha1_prefix[len] = 0;
 520
 521        line = ptr + 2;
 522        ptr = strchr(line, ' ');
 523        eol = strchr(line, '\n');
 524
 525        if (!ptr || eol < ptr)
 526                ptr = eol;
 527        len = ptr - line;
 528
 529        if (40 < len)
 530                return 0;
 531        memcpy(patch->new_sha1_prefix, line, len);
 532        patch->new_sha1_prefix[len] = 0;
 533        if (*ptr == ' ')
 534                patch->new_mode = patch->old_mode = strtoul(ptr+1, NULL, 8);
 535        return 0;
 536}
 537
 538/*
 539 * This is normal for a diff that doesn't change anything: we'll fall through
 540 * into the next diff. Tell the parser to break out.
 541 */
 542static int gitdiff_unrecognized(const char *line, struct patch *patch)
 543{
 544        return -1;
 545}
 546
 547static const char *stop_at_slash(const char *line, int llen)
 548{
 549        int i;
 550
 551        for (i = 0; i < llen; i++) {
 552                int ch = line[i];
 553                if (ch == '/')
 554                        return line + i;
 555        }
 556        return NULL;
 557}
 558
 559/* This is to extract the same name that appears on "diff --git"
 560 * line.  We do not find and return anything if it is a rename
 561 * patch, and it is OK because we will find the name elsewhere.
 562 * We need to reliably find name only when it is mode-change only,
 563 * creation or deletion of an empty file.  In any of these cases,
 564 * both sides are the same name under a/ and b/ respectively.
 565 */
 566static char *git_header_name(char *line, int llen)
 567{
 568        const char *name;
 569        const char *second = NULL;
 570        size_t len;
 571
 572        line += strlen("diff --git ");
 573        llen -= strlen("diff --git ");
 574
 575        if (*line == '"') {
 576                const char *cp;
 577                struct strbuf first;
 578                struct strbuf sp;
 579
 580                strbuf_init(&first, 0);
 581                strbuf_init(&sp, 0);
 582
 583                if (unquote_c_style(&first, line, &second))
 584                        goto free_and_fail1;
 585
 586                /* advance to the first slash */
 587                cp = stop_at_slash(first.buf, first.len);
 588                /* we do not accept absolute paths */
 589                if (!cp || cp == first.buf)
 590                        goto free_and_fail1;
 591                strbuf_remove(&first, 0, cp + 1 - first.buf);
 592
 593                /* second points at one past closing dq of name.
 594                 * find the second name.
 595                 */
 596                while ((second < line + llen) && isspace(*second))
 597                        second++;
 598
 599                if (line + llen <= second)
 600                        goto free_and_fail1;
 601                if (*second == '"') {
 602                        if (unquote_c_style(&sp, second, NULL))
 603                                goto free_and_fail1;
 604                        cp = stop_at_slash(sp.buf, sp.len);
 605                        if (!cp || cp == sp.buf)
 606                                goto free_and_fail1;
 607                        /* They must match, otherwise ignore */
 608                        if (strcmp(cp + 1, first.buf))
 609                                goto free_and_fail1;
 610                        strbuf_release(&sp);
 611                        return first.buf;
 612                }
 613
 614                /* unquoted second */
 615                cp = stop_at_slash(second, line + llen - second);
 616                if (!cp || cp == second)
 617                        goto free_and_fail1;
 618                cp++;
 619                if (line + llen - cp != first.len + 1 ||
 620                    memcmp(first.buf, cp, first.len))
 621                        goto free_and_fail1;
 622                return first.buf;
 623
 624        free_and_fail1:
 625                strbuf_release(&first);
 626                strbuf_release(&sp);
 627                return NULL;
 628        }
 629
 630        /* unquoted first name */
 631        name = stop_at_slash(line, llen);
 632        if (!name || name == line)
 633                return NULL;
 634        name++;
 635
 636        /* since the first name is unquoted, a dq if exists must be
 637         * the beginning of the second name.
 638         */
 639        for (second = name; second < line + llen; second++) {
 640                if (*second == '"') {
 641                        struct strbuf sp;
 642                        const char *np;
 643
 644                        strbuf_init(&sp, 0);
 645                        if (unquote_c_style(&sp, second, NULL))
 646                                goto free_and_fail2;
 647
 648                        np = stop_at_slash(sp.buf, sp.len);
 649                        if (!np || np == sp.buf)
 650                                goto free_and_fail2;
 651                        np++;
 652
 653                        len = sp.buf + sp.len - np;
 654                        if (len < second - name &&
 655                            !strncmp(np, name, len) &&
 656                            isspace(name[len])) {
 657                                /* Good */
 658                                strbuf_remove(&sp, 0, np - sp.buf);
 659                                return sp.buf;
 660                        }
 661
 662                free_and_fail2:
 663                        strbuf_release(&sp);
 664                        return NULL;
 665                }
 666        }
 667
 668        /*
 669         * Accept a name only if it shows up twice, exactly the same
 670         * form.
 671         */
 672        for (len = 0 ; ; len++) {
 673                switch (name[len]) {
 674                default:
 675                        continue;
 676                case '\n':
 677                        return NULL;
 678                case '\t': case ' ':
 679                        second = name+len;
 680                        for (;;) {
 681                                char c = *second++;
 682                                if (c == '\n')
 683                                        return NULL;
 684                                if (c == '/')
 685                                        break;
 686                        }
 687                        if (second[len] == '\n' && !memcmp(name, second, len)) {
 688                                return xmemdupz(name, len);
 689                        }
 690                }
 691        }
 692        return NULL;
 693}
 694
 695/* Verify that we recognize the lines following a git header */
 696static int parse_git_header(char *line, int len, unsigned int size, struct patch *patch)
 697{
 698        unsigned long offset;
 699
 700        /* A git diff has explicit new/delete information, so we don't guess */
 701        patch->is_new = 0;
 702        patch->is_delete = 0;
 703
 704        /*
 705         * Some things may not have the old name in the
 706         * rest of the headers anywhere (pure mode changes,
 707         * or removing or adding empty files), so we get
 708         * the default name from the header.
 709         */
 710        patch->def_name = git_header_name(line, len);
 711
 712        line += len;
 713        size -= len;
 714        linenr++;
 715        for (offset = len ; size > 0 ; offset += len, size -= len, line += len, linenr++) {
 716                static const struct opentry {
 717                        const char *str;
 718                        int (*fn)(const char *, struct patch *);
 719                } optable[] = {
 720                        { "@@ -", gitdiff_hdrend },
 721                        { "--- ", gitdiff_oldname },
 722                        { "+++ ", gitdiff_newname },
 723                        { "old mode ", gitdiff_oldmode },
 724                        { "new mode ", gitdiff_newmode },
 725                        { "deleted file mode ", gitdiff_delete },
 726                        { "new file mode ", gitdiff_newfile },
 727                        { "copy from ", gitdiff_copysrc },
 728                        { "copy to ", gitdiff_copydst },
 729                        { "rename old ", gitdiff_renamesrc },
 730                        { "rename new ", gitdiff_renamedst },
 731                        { "rename from ", gitdiff_renamesrc },
 732                        { "rename to ", gitdiff_renamedst },
 733                        { "similarity index ", gitdiff_similarity },
 734                        { "dissimilarity index ", gitdiff_dissimilarity },
 735                        { "index ", gitdiff_index },
 736                        { "", gitdiff_unrecognized },
 737                };
 738                int i;
 739
 740                len = linelen(line, size);
 741                if (!len || line[len-1] != '\n')
 742                        break;
 743                for (i = 0; i < ARRAY_SIZE(optable); i++) {
 744                        const struct opentry *p = optable + i;
 745                        int oplen = strlen(p->str);
 746                        if (len < oplen || memcmp(p->str, line, oplen))
 747                                continue;
 748                        if (p->fn(line + oplen, patch) < 0)
 749                                return offset;
 750                        break;
 751                }
 752        }
 753
 754        return offset;
 755}
 756
 757static int parse_num(const char *line, unsigned long *p)
 758{
 759        char *ptr;
 760
 761        if (!isdigit(*line))
 762                return 0;
 763        *p = strtoul(line, &ptr, 10);
 764        return ptr - line;
 765}
 766
 767static int parse_range(const char *line, int len, int offset, const char *expect,
 768                        unsigned long *p1, unsigned long *p2)
 769{
 770        int digits, ex;
 771
 772        if (offset < 0 || offset >= len)
 773                return -1;
 774        line += offset;
 775        len -= offset;
 776
 777        digits = parse_num(line, p1);
 778        if (!digits)
 779                return -1;
 780
 781        offset += digits;
 782        line += digits;
 783        len -= digits;
 784
 785        *p2 = 1;
 786        if (*line == ',') {
 787                digits = parse_num(line+1, p2);
 788                if (!digits)
 789                        return -1;
 790
 791                offset += digits+1;
 792                line += digits+1;
 793                len -= digits+1;
 794        }
 795
 796        ex = strlen(expect);
 797        if (ex > len)
 798                return -1;
 799        if (memcmp(line, expect, ex))
 800                return -1;
 801
 802        return offset + ex;
 803}
 804
 805/*
 806 * Parse a unified diff fragment header of the
 807 * form "@@ -a,b +c,d @@"
 808 */
 809static int parse_fragment_header(char *line, int len, struct fragment *fragment)
 810{
 811        int offset;
 812
 813        if (!len || line[len-1] != '\n')
 814                return -1;
 815
 816        /* Figure out the number of lines in a fragment */
 817        offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);
 818        offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);
 819
 820        return offset;
 821}
 822
 823static int find_header(char *line, unsigned long size, int *hdrsize, struct patch *patch)
 824{
 825        unsigned long offset, len;
 826
 827        patch->is_toplevel_relative = 0;
 828        patch->is_rename = patch->is_copy = 0;
 829        patch->is_new = patch->is_delete = -1;
 830        patch->old_mode = patch->new_mode = 0;
 831        patch->old_name = patch->new_name = NULL;
 832        for (offset = 0; size > 0; offset += len, size -= len, line += len, linenr++) {
 833                unsigned long nextlen;
 834
 835                len = linelen(line, size);
 836                if (!len)
 837                        break;
 838
 839                /* Testing this early allows us to take a few shortcuts.. */
 840                if (len < 6)
 841                        continue;
 842
 843                /*
 844                 * Make sure we don't find any unconnected patch fragments.
 845                 * That's a sign that we didn't find a header, and that a
 846                 * patch has become corrupted/broken up.
 847                 */
 848                if (!memcmp("@@ -", line, 4)) {
 849                        struct fragment dummy;
 850                        if (parse_fragment_header(line, len, &dummy) < 0)
 851                                continue;
 852                        die("patch fragment without header at line %d: %.*s",
 853                            linenr, (int)len-1, line);
 854                }
 855
 856                if (size < len + 6)
 857                        break;
 858
 859                /*
 860                 * Git patch? It might not have a real patch, just a rename
 861                 * or mode change, so we handle that specially
 862                 */
 863                if (!memcmp("diff --git ", line, 11)) {
 864                        int git_hdr_len = parse_git_header(line, len, size, patch);
 865                        if (git_hdr_len <= len)
 866                                continue;
 867                        if (!patch->old_name && !patch->new_name) {
 868                                if (!patch->def_name)
 869                                        die("git diff header lacks filename information (line %d)", linenr);
 870                                patch->old_name = patch->new_name = patch->def_name;
 871                        }
 872                        patch->is_toplevel_relative = 1;
 873                        *hdrsize = git_hdr_len;
 874                        return offset;
 875                }
 876
 877                /** --- followed by +++ ? */
 878                if (memcmp("--- ", line,  4) || memcmp("+++ ", line + len, 4))
 879                        continue;
 880
 881                /*
 882                 * We only accept unified patches, so we want it to
 883                 * at least have "@@ -a,b +c,d @@\n", which is 14 chars
 884                 * minimum
 885                 */
 886                nextlen = linelen(line + len, size - len);
 887                if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))
 888                        continue;
 889
 890                /* Ok, we'll consider it a patch */
 891                parse_traditional_patch(line, line+len, patch);
 892                *hdrsize = len + nextlen;
 893                linenr += 2;
 894                return offset;
 895        }
 896        return -1;
 897}
 898
 899static void check_whitespace(const char *line, int len)
 900{
 901        const char *err = "Adds trailing whitespace";
 902        int seen_space = 0;
 903        int i;
 904
 905        /*
 906         * We know len is at least two, since we have a '+' and we
 907         * checked that the last character was a '\n' before calling
 908         * this function.  That is, an addition of an empty line would
 909         * check the '+' here.  Sneaky...
 910         */
 911        if (isspace(line[len-2]))
 912                goto error;
 913
 914        /*
 915         * Make sure that there is no space followed by a tab in
 916         * indentation.
 917         */
 918        err = "Space in indent is followed by a tab";
 919        for (i = 1; i < len; i++) {
 920                if (line[i] == '\t') {
 921                        if (seen_space)
 922                                goto error;
 923                }
 924                else if (line[i] == ' ')
 925                        seen_space = 1;
 926                else
 927                        break;
 928        }
 929        return;
 930
 931 error:
 932        whitespace_error++;
 933        if (squelch_whitespace_errors &&
 934            squelch_whitespace_errors < whitespace_error)
 935                ;
 936        else
 937                fprintf(stderr, "%s.\n%s:%d:%.*s\n",
 938                        err, patch_input_file, linenr, len-2, line+1);
 939}
 940
 941
 942/*
 943 * Parse a unified diff. Note that this really needs to parse each
 944 * fragment separately, since the only way to know the difference
 945 * between a "---" that is part of a patch, and a "---" that starts
 946 * the next patch is to look at the line counts..
 947 */
 948static int parse_fragment(char *line, unsigned long size, struct patch *patch, struct fragment *fragment)
 949{
 950        int added, deleted;
 951        int len = linelen(line, size), offset;
 952        unsigned long oldlines, newlines;
 953        unsigned long leading, trailing;
 954
 955        offset = parse_fragment_header(line, len, fragment);
 956        if (offset < 0)
 957                return -1;
 958        oldlines = fragment->oldlines;
 959        newlines = fragment->newlines;
 960        leading = 0;
 961        trailing = 0;
 962
 963        /* Parse the thing.. */
 964        line += len;
 965        size -= len;
 966        linenr++;
 967        added = deleted = 0;
 968        for (offset = len;
 969             0 < size;
 970             offset += len, size -= len, line += len, linenr++) {
 971                if (!oldlines && !newlines)
 972                        break;
 973                len = linelen(line, size);
 974                if (!len || line[len-1] != '\n')
 975                        return -1;
 976                switch (*line) {
 977                default:
 978                        return -1;
 979                case '\n': /* newer GNU diff, an empty context line */
 980                case ' ':
 981                        oldlines--;
 982                        newlines--;
 983                        if (!deleted && !added)
 984                                leading++;
 985                        trailing++;
 986                        break;
 987                case '-':
 988                        if (apply_in_reverse &&
 989                                        new_whitespace != nowarn_whitespace)
 990                                check_whitespace(line, len);
 991                        deleted++;
 992                        oldlines--;
 993                        trailing = 0;
 994                        break;
 995                case '+':
 996                        if (!apply_in_reverse &&
 997                                        new_whitespace != nowarn_whitespace)
 998                                check_whitespace(line, len);
 999                        added++;
1000                        newlines--;
1001                        trailing = 0;
1002                        break;
1003
1004                /* We allow "\ No newline at end of file". Depending
1005                 * on locale settings when the patch was produced we
1006                 * don't know what this line looks like. The only
1007                 * thing we do know is that it begins with "\ ".
1008                 * Checking for 12 is just for sanity check -- any
1009                 * l10n of "\ No newline..." is at least that long.
1010                 */
1011                case '\\':
1012                        if (len < 12 || memcmp(line, "\\ ", 2))
1013                                return -1;
1014                        break;
1015                }
1016        }
1017        if (oldlines || newlines)
1018                return -1;
1019        fragment->leading = leading;
1020        fragment->trailing = trailing;
1021
1022        /* If a fragment ends with an incomplete line, we failed to include
1023         * it in the above loop because we hit oldlines == newlines == 0
1024         * before seeing it.
1025         */
1026        if (12 < size && !memcmp(line, "\\ ", 2))
1027                offset += linelen(line, size);
1028
1029        patch->lines_added += added;
1030        patch->lines_deleted += deleted;
1031
1032        if (0 < patch->is_new && oldlines)
1033                return error("new file depends on old contents");
1034        if (0 < patch->is_delete && newlines)
1035                return error("deleted file still has contents");
1036        return offset;
1037}
1038
1039static int parse_single_patch(char *line, unsigned long size, struct patch *patch)
1040{
1041        unsigned long offset = 0;
1042        unsigned long oldlines = 0, newlines = 0, context = 0;
1043        struct fragment **fragp = &patch->fragments;
1044
1045        while (size > 4 && !memcmp(line, "@@ -", 4)) {
1046                struct fragment *fragment;
1047                int len;
1048
1049                fragment = xcalloc(1, sizeof(*fragment));
1050                len = parse_fragment(line, size, patch, fragment);
1051                if (len <= 0)
1052                        die("corrupt patch at line %d", linenr);
1053                fragment->patch = line;
1054                fragment->size = len;
1055                oldlines += fragment->oldlines;
1056                newlines += fragment->newlines;
1057                context += fragment->leading + fragment->trailing;
1058
1059                *fragp = fragment;
1060                fragp = &fragment->next;
1061
1062                offset += len;
1063                line += len;
1064                size -= len;
1065        }
1066
1067        /*
1068         * If something was removed (i.e. we have old-lines) it cannot
1069         * be creation, and if something was added it cannot be
1070         * deletion.  However, the reverse is not true; --unified=0
1071         * patches that only add are not necessarily creation even
1072         * though they do not have any old lines, and ones that only
1073         * delete are not necessarily deletion.
1074         *
1075         * Unfortunately, a real creation/deletion patch do _not_ have
1076         * any context line by definition, so we cannot safely tell it
1077         * apart with --unified=0 insanity.  At least if the patch has
1078         * more than one hunk it is not creation or deletion.
1079         */
1080        if (patch->is_new < 0 &&
1081            (oldlines || (patch->fragments && patch->fragments->next)))
1082                patch->is_new = 0;
1083        if (patch->is_delete < 0 &&
1084            (newlines || (patch->fragments && patch->fragments->next)))
1085                patch->is_delete = 0;
1086        if (!unidiff_zero || context) {
1087                /* If the user says the patch is not generated with
1088                 * --unified=0, or if we have seen context lines,
1089                 * then not having oldlines means the patch is creation,
1090                 * and not having newlines means the patch is deletion.
1091                 */
1092                if (patch->is_new < 0 && !oldlines) {
1093                        patch->is_new = 1;
1094                        patch->old_name = NULL;
1095                }
1096                if (patch->is_delete < 0 && !newlines) {
1097                        patch->is_delete = 1;
1098                        patch->new_name = NULL;
1099                }
1100        }
1101
1102        if (0 < patch->is_new && oldlines)
1103                die("new file %s depends on old contents", patch->new_name);
1104        if (0 < patch->is_delete && newlines)
1105                die("deleted file %s still has contents", patch->old_name);
1106        if (!patch->is_delete && !newlines && context)
1107                fprintf(stderr, "** warning: file %s becomes empty but "
1108                        "is not deleted\n", patch->new_name);
1109
1110        return offset;
1111}
1112
1113static inline int metadata_changes(struct patch *patch)
1114{
1115        return  patch->is_rename > 0 ||
1116                patch->is_copy > 0 ||
1117                patch->is_new > 0 ||
1118                patch->is_delete ||
1119                (patch->old_mode && patch->new_mode &&
1120                 patch->old_mode != patch->new_mode);
1121}
1122
1123static char *inflate_it(const void *data, unsigned long size,
1124                        unsigned long inflated_size)
1125{
1126        z_stream stream;
1127        void *out;
1128        int st;
1129
1130        memset(&stream, 0, sizeof(stream));
1131
1132        stream.next_in = (unsigned char *)data;
1133        stream.avail_in = size;
1134        stream.next_out = out = xmalloc(inflated_size);
1135        stream.avail_out = inflated_size;
1136        inflateInit(&stream);
1137        st = inflate(&stream, Z_FINISH);
1138        if ((st != Z_STREAM_END) || stream.total_out != inflated_size) {
1139                free(out);
1140                return NULL;
1141        }
1142        return out;
1143}
1144
1145static struct fragment *parse_binary_hunk(char **buf_p,
1146                                          unsigned long *sz_p,
1147                                          int *status_p,
1148                                          int *used_p)
1149{
1150        /* Expect a line that begins with binary patch method ("literal"
1151         * or "delta"), followed by the length of data before deflating.
1152         * a sequence of 'length-byte' followed by base-85 encoded data
1153         * should follow, terminated by a newline.
1154         *
1155         * Each 5-byte sequence of base-85 encodes up to 4 bytes,
1156         * and we would limit the patch line to 66 characters,
1157         * so one line can fit up to 13 groups that would decode
1158         * to 52 bytes max.  The length byte 'A'-'Z' corresponds
1159         * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.
1160         */
1161        int llen, used;
1162        unsigned long size = *sz_p;
1163        char *buffer = *buf_p;
1164        int patch_method;
1165        unsigned long origlen;
1166        char *data = NULL;
1167        int hunk_size = 0;
1168        struct fragment *frag;
1169
1170        llen = linelen(buffer, size);
1171        used = llen;
1172
1173        *status_p = 0;
1174
1175        if (!prefixcmp(buffer, "delta ")) {
1176                patch_method = BINARY_DELTA_DEFLATED;
1177                origlen = strtoul(buffer + 6, NULL, 10);
1178        }
1179        else if (!prefixcmp(buffer, "literal ")) {
1180                patch_method = BINARY_LITERAL_DEFLATED;
1181                origlen = strtoul(buffer + 8, NULL, 10);
1182        }
1183        else
1184                return NULL;
1185
1186        linenr++;
1187        buffer += llen;
1188        while (1) {
1189                int byte_length, max_byte_length, newsize;
1190                llen = linelen(buffer, size);
1191                used += llen;
1192                linenr++;
1193                if (llen == 1) {
1194                        /* consume the blank line */
1195                        buffer++;
1196                        size--;
1197                        break;
1198                }
1199                /* Minimum line is "A00000\n" which is 7-byte long,
1200                 * and the line length must be multiple of 5 plus 2.
1201                 */
1202                if ((llen < 7) || (llen-2) % 5)
1203                        goto corrupt;
1204                max_byte_length = (llen - 2) / 5 * 4;
1205                byte_length = *buffer;
1206                if ('A' <= byte_length && byte_length <= 'Z')
1207                        byte_length = byte_length - 'A' + 1;
1208                else if ('a' <= byte_length && byte_length <= 'z')
1209                        byte_length = byte_length - 'a' + 27;
1210                else
1211                        goto corrupt;
1212                /* if the input length was not multiple of 4, we would
1213                 * have filler at the end but the filler should never
1214                 * exceed 3 bytes
1215                 */
1216                if (max_byte_length < byte_length ||
1217                    byte_length <= max_byte_length - 4)
1218                        goto corrupt;
1219                newsize = hunk_size + byte_length;
1220                data = xrealloc(data, newsize);
1221                if (decode_85(data + hunk_size, buffer + 1, byte_length))
1222                        goto corrupt;
1223                hunk_size = newsize;
1224                buffer += llen;
1225                size -= llen;
1226        }
1227
1228        frag = xcalloc(1, sizeof(*frag));
1229        frag->patch = inflate_it(data, hunk_size, origlen);
1230        if (!frag->patch)
1231                goto corrupt;
1232        free(data);
1233        frag->size = origlen;
1234        *buf_p = buffer;
1235        *sz_p = size;
1236        *used_p = used;
1237        frag->binary_patch_method = patch_method;
1238        return frag;
1239
1240 corrupt:
1241        free(data);
1242        *status_p = -1;
1243        error("corrupt binary patch at line %d: %.*s",
1244              linenr-1, llen-1, buffer);
1245        return NULL;
1246}
1247
1248static int parse_binary(char *buffer, unsigned long size, struct patch *patch)
1249{
1250        /* We have read "GIT binary patch\n"; what follows is a line
1251         * that says the patch method (currently, either "literal" or
1252         * "delta") and the length of data before deflating; a
1253         * sequence of 'length-byte' followed by base-85 encoded data
1254         * follows.
1255         *
1256         * When a binary patch is reversible, there is another binary
1257         * hunk in the same format, starting with patch method (either
1258         * "literal" or "delta") with the length of data, and a sequence
1259         * of length-byte + base-85 encoded data, terminated with another
1260         * empty line.  This data, when applied to the postimage, produces
1261         * the preimage.
1262         */
1263        struct fragment *forward;
1264        struct fragment *reverse;
1265        int status;
1266        int used, used_1;
1267
1268        forward = parse_binary_hunk(&buffer, &size, &status, &used);
1269        if (!forward && !status)
1270                /* there has to be one hunk (forward hunk) */
1271                return error("unrecognized binary patch at line %d", linenr-1);
1272        if (status)
1273                /* otherwise we already gave an error message */
1274                return status;
1275
1276        reverse = parse_binary_hunk(&buffer, &size, &status, &used_1);
1277        if (reverse)
1278                used += used_1;
1279        else if (status) {
1280                /* not having reverse hunk is not an error, but having
1281                 * a corrupt reverse hunk is.
1282                 */
1283                free((void*) forward->patch);
1284                free(forward);
1285                return status;
1286        }
1287        forward->next = reverse;
1288        patch->fragments = forward;
1289        patch->is_binary = 1;
1290        return used;
1291}
1292
1293static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
1294{
1295        int hdrsize, patchsize;
1296        int offset = find_header(buffer, size, &hdrsize, patch);
1297
1298        if (offset < 0)
1299                return offset;
1300
1301        patchsize = parse_single_patch(buffer + offset + hdrsize, size - offset - hdrsize, patch);
1302
1303        if (!patchsize) {
1304                static const char *binhdr[] = {
1305                        "Binary files ",
1306                        "Files ",
1307                        NULL,
1308                };
1309                static const char git_binary[] = "GIT binary patch\n";
1310                int i;
1311                int hd = hdrsize + offset;
1312                unsigned long llen = linelen(buffer + hd, size - hd);
1313
1314                if (llen == sizeof(git_binary) - 1 &&
1315                    !memcmp(git_binary, buffer + hd, llen)) {
1316                        int used;
1317                        linenr++;
1318                        used = parse_binary(buffer + hd + llen,
1319                                            size - hd - llen, patch);
1320                        if (used)
1321                                patchsize = used + llen;
1322                        else
1323                                patchsize = 0;
1324                }
1325                else if (!memcmp(" differ\n", buffer + hd + llen - 8, 8)) {
1326                        for (i = 0; binhdr[i]; i++) {
1327                                int len = strlen(binhdr[i]);
1328                                if (len < size - hd &&
1329                                    !memcmp(binhdr[i], buffer + hd, len)) {
1330                                        linenr++;
1331                                        patch->is_binary = 1;
1332                                        patchsize = llen;
1333                                        break;
1334                                }
1335                        }
1336                }
1337
1338                /* Empty patch cannot be applied if it is a text patch
1339                 * without metadata change.  A binary patch appears
1340                 * empty to us here.
1341                 */
1342                if ((apply || check) &&
1343                    (!patch->is_binary && !metadata_changes(patch)))
1344                        die("patch with only garbage at line %d", linenr);
1345        }
1346
1347        return offset + hdrsize + patchsize;
1348}
1349
1350#define swap(a,b) myswap((a),(b),sizeof(a))
1351
1352#define myswap(a, b, size) do {         \
1353        unsigned char mytmp[size];      \
1354        memcpy(mytmp, &a, size);                \
1355        memcpy(&a, &b, size);           \
1356        memcpy(&b, mytmp, size);                \
1357} while (0)
1358
1359static void reverse_patches(struct patch *p)
1360{
1361        for (; p; p = p->next) {
1362                struct fragment *frag = p->fragments;
1363
1364                swap(p->new_name, p->old_name);
1365                swap(p->new_mode, p->old_mode);
1366                swap(p->is_new, p->is_delete);
1367                swap(p->lines_added, p->lines_deleted);
1368                swap(p->old_sha1_prefix, p->new_sha1_prefix);
1369
1370                for (; frag; frag = frag->next) {
1371                        swap(frag->newpos, frag->oldpos);
1372                        swap(frag->newlines, frag->oldlines);
1373                }
1374        }
1375}
1376
1377static const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
1378static const char minuses[]= "----------------------------------------------------------------------";
1379
1380static void show_stats(struct patch *patch)
1381{
1382        const char *prefix = "";
1383        char *name = patch->new_name;
1384        char *qname = NULL;
1385        int len, max, add, del, total;
1386
1387        if (!name)
1388                name = patch->old_name;
1389
1390        if (0 < (len = quote_c_style(name, NULL, NULL, 0))) {
1391                qname = xmalloc(len + 1);
1392                quote_c_style(name, qname, NULL, 0);
1393                name = qname;
1394        }
1395
1396        /*
1397         * "scale" the filename
1398         */
1399        len = strlen(name);
1400        max = max_len;
1401        if (max > 50)
1402                max = 50;
1403        if (len > max) {
1404                char *slash;
1405                prefix = "...";
1406                max -= 3;
1407                name += len - max;
1408                slash = strchr(name, '/');
1409                if (slash)
1410                        name = slash;
1411        }
1412        len = max;
1413
1414        /*
1415         * scale the add/delete
1416         */
1417        max = max_change;
1418        if (max + len > 70)
1419                max = 70 - len;
1420
1421        add = patch->lines_added;
1422        del = patch->lines_deleted;
1423        total = add + del;
1424
1425        if (max_change > 0) {
1426                total = (total * max + max_change / 2) / max_change;
1427                add = (add * max + max_change / 2) / max_change;
1428                del = total - add;
1429        }
1430        if (patch->is_binary)
1431                printf(" %s%-*s |  Bin\n", prefix, len, name);
1432        else
1433                printf(" %s%-*s |%5d %.*s%.*s\n", prefix,
1434                       len, name, patch->lines_added + patch->lines_deleted,
1435                       add, pluses, del, minuses);
1436        free(qname);
1437}
1438
1439static int read_old_data(struct stat *st, const char *path, struct strbuf *buf)
1440{
1441        int fd;
1442
1443        switch (st->st_mode & S_IFMT) {
1444        case S_IFLNK:
1445                strbuf_grow(buf, st->st_size);
1446                if (readlink(path, buf->buf, st->st_size) != st->st_size)
1447                        return -1;
1448                strbuf_setlen(buf, st->st_size);
1449                return 0;
1450        case S_IFREG:
1451                fd = open(path, O_RDONLY);
1452                if (fd < 0)
1453                        return error("unable to open %s", path);
1454                if (strbuf_read(buf, fd, st->st_size) < 0) {
1455                        close(fd);
1456                        return -1;
1457                }
1458                close(fd);
1459                convert_to_git(path, buf->buf, buf->len, buf);
1460                return 0;
1461        default:
1462                return -1;
1463        }
1464}
1465
1466static int find_offset(const char *buf, unsigned long size, const char *fragment, unsigned long fragsize, int line, int *lines)
1467{
1468        int i;
1469        unsigned long start, backwards, forwards;
1470
1471        if (fragsize > size)
1472                return -1;
1473
1474        start = 0;
1475        if (line > 1) {
1476                unsigned long offset = 0;
1477                i = line-1;
1478                while (offset + fragsize <= size) {
1479                        if (buf[offset++] == '\n') {
1480                                start = offset;
1481                                if (!--i)
1482                                        break;
1483                        }
1484                }
1485        }
1486
1487        /* Exact line number? */
1488        if ((start + fragsize <= size) &&
1489            !memcmp(buf + start, fragment, fragsize))
1490                return start;
1491
1492        /*
1493         * There's probably some smart way to do this, but I'll leave
1494         * that to the smart and beautiful people. I'm simple and stupid.
1495         */
1496        backwards = start;
1497        forwards = start;
1498        for (i = 0; ; i++) {
1499                unsigned long try;
1500                int n;
1501
1502                /* "backward" */
1503                if (i & 1) {
1504                        if (!backwards) {
1505                                if (forwards + fragsize > size)
1506                                        break;
1507                                continue;
1508                        }
1509                        do {
1510                                --backwards;
1511                        } while (backwards && buf[backwards-1] != '\n');
1512                        try = backwards;
1513                } else {
1514                        while (forwards + fragsize <= size) {
1515                                if (buf[forwards++] == '\n')
1516                                        break;
1517                        }
1518                        try = forwards;
1519                }
1520
1521                if (try + fragsize > size)
1522                        continue;
1523                if (memcmp(buf + try, fragment, fragsize))
1524                        continue;
1525                n = (i >> 1)+1;
1526                if (i & 1)
1527                        n = -n;
1528                *lines = n;
1529                return try;
1530        }
1531
1532        /*
1533         * We should start searching forward and backward.
1534         */
1535        return -1;
1536}
1537
1538static void remove_first_line(const char **rbuf, int *rsize)
1539{
1540        const char *buf = *rbuf;
1541        int size = *rsize;
1542        unsigned long offset;
1543        offset = 0;
1544        while (offset <= size) {
1545                if (buf[offset++] == '\n')
1546                        break;
1547        }
1548        *rsize = size - offset;
1549        *rbuf = buf + offset;
1550}
1551
1552static void remove_last_line(const char **rbuf, int *rsize)
1553{
1554        const char *buf = *rbuf;
1555        int size = *rsize;
1556        unsigned long offset;
1557        offset = size - 1;
1558        while (offset > 0) {
1559                if (buf[--offset] == '\n')
1560                        break;
1561        }
1562        *rsize = offset + 1;
1563}
1564
1565static int apply_line(char *output, const char *patch, int plen)
1566{
1567        /* plen is number of bytes to be copied from patch,
1568         * starting at patch+1 (patch[0] is '+').  Typically
1569         * patch[plen] is '\n', unless this is the incomplete
1570         * last line.
1571         */
1572        int i;
1573        int add_nl_to_tail = 0;
1574        int fixed = 0;
1575        int last_tab_in_indent = -1;
1576        int last_space_in_indent = -1;
1577        int need_fix_leading_space = 0;
1578        char *buf;
1579
1580        if ((new_whitespace != strip_whitespace) || !whitespace_error ||
1581            *patch != '+') {
1582                memcpy(output, patch + 1, plen);
1583                return plen;
1584        }
1585
1586        if (1 < plen && isspace(patch[plen-1])) {
1587                if (patch[plen] == '\n')
1588                        add_nl_to_tail = 1;
1589                plen--;
1590                while (0 < plen && isspace(patch[plen]))
1591                        plen--;
1592                fixed = 1;
1593        }
1594
1595        for (i = 1; i < plen; i++) {
1596                char ch = patch[i];
1597                if (ch == '\t') {
1598                        last_tab_in_indent = i;
1599                        if (0 <= last_space_in_indent)
1600                                need_fix_leading_space = 1;
1601                }
1602                else if (ch == ' ')
1603                        last_space_in_indent = i;
1604                else
1605                        break;
1606        }
1607
1608        buf = output;
1609        if (need_fix_leading_space) {
1610                int consecutive_spaces = 0;
1611                /* between patch[1..last_tab_in_indent] strip the
1612                 * funny spaces, updating them to tab as needed.
1613                 */
1614                for (i = 1; i < last_tab_in_indent; i++, plen--) {
1615                        char ch = patch[i];
1616                        if (ch != ' ') {
1617                                consecutive_spaces = 0;
1618                                *output++ = ch;
1619                        } else {
1620                                consecutive_spaces++;
1621                                if (consecutive_spaces == 8) {
1622                                        *output++ = '\t';
1623                                        consecutive_spaces = 0;
1624                                }
1625                        }
1626                }
1627                fixed = 1;
1628                i = last_tab_in_indent;
1629        }
1630        else
1631                i = 1;
1632
1633        memcpy(output, patch + i, plen);
1634        if (add_nl_to_tail)
1635                output[plen++] = '\n';
1636        if (fixed)
1637                applied_after_fixing_ws++;
1638        return output + plen - buf;
1639}
1640
1641static int apply_one_fragment(struct strbuf *buf, struct fragment *frag, int inaccurate_eof)
1642{
1643        int match_beginning, match_end;
1644        const char *patch = frag->patch;
1645        int offset, size = frag->size;
1646        char *old = xmalloc(size);
1647        char *new = xmalloc(size);
1648        const char *oldlines, *newlines;
1649        int oldsize = 0, newsize = 0;
1650        int new_blank_lines_at_end = 0;
1651        unsigned long leading, trailing;
1652        int pos, lines;
1653
1654        while (size > 0) {
1655                char first;
1656                int len = linelen(patch, size);
1657                int plen;
1658                int added_blank_line = 0;
1659
1660                if (!len)
1661                        break;
1662
1663                /*
1664                 * "plen" is how much of the line we should use for
1665                 * the actual patch data. Normally we just remove the
1666                 * first character on the line, but if the line is
1667                 * followed by "\ No newline", then we also remove the
1668                 * last one (which is the newline, of course).
1669                 */
1670                plen = len-1;
1671                if (len < size && patch[len] == '\\')
1672                        plen--;
1673                first = *patch;
1674                if (apply_in_reverse) {
1675                        if (first == '-')
1676                                first = '+';
1677                        else if (first == '+')
1678                                first = '-';
1679                }
1680
1681                switch (first) {
1682                case '\n':
1683                        /* Newer GNU diff, empty context line */
1684                        if (plen < 0)
1685                                /* ... followed by '\No newline'; nothing */
1686                                break;
1687                        old[oldsize++] = '\n';
1688                        new[newsize++] = '\n';
1689                        break;
1690                case ' ':
1691                case '-':
1692                        memcpy(old + oldsize, patch + 1, plen);
1693                        oldsize += plen;
1694                        if (first == '-')
1695                                break;
1696                /* Fall-through for ' ' */
1697                case '+':
1698                        if (first != '+' || !no_add) {
1699                                int added = apply_line(new + newsize, patch,
1700                                                       plen);
1701                                newsize += added;
1702                                if (first == '+' &&
1703                                    added == 1 && new[newsize-1] == '\n')
1704                                        added_blank_line = 1;
1705                        }
1706                        break;
1707                case '@': case '\\':
1708                        /* Ignore it, we already handled it */
1709                        break;
1710                default:
1711                        if (apply_verbosely)
1712                                error("invalid start of line: '%c'", first);
1713                        return -1;
1714                }
1715                if (added_blank_line)
1716                        new_blank_lines_at_end++;
1717                else
1718                        new_blank_lines_at_end = 0;
1719                patch += len;
1720                size -= len;
1721        }
1722
1723        if (inaccurate_eof && oldsize > 0 && old[oldsize - 1] == '\n' &&
1724                        newsize > 0 && new[newsize - 1] == '\n') {
1725                oldsize--;
1726                newsize--;
1727        }
1728
1729        oldlines = old;
1730        newlines = new;
1731        leading = frag->leading;
1732        trailing = frag->trailing;
1733
1734        /*
1735         * If we don't have any leading/trailing data in the patch,
1736         * we want it to match at the beginning/end of the file.
1737         *
1738         * But that would break if the patch is generated with
1739         * --unified=0; sane people wouldn't do that to cause us
1740         * trouble, but we try to please not so sane ones as well.
1741         */
1742        if (unidiff_zero) {
1743                match_beginning = (!leading && !frag->oldpos);
1744                match_end = 0;
1745        }
1746        else {
1747                match_beginning = !leading && (frag->oldpos == 1);
1748                match_end = !trailing;
1749        }
1750
1751        lines = 0;
1752        pos = frag->newpos;
1753        for (;;) {
1754                offset = find_offset(buf->buf, buf->len,
1755                                     oldlines, oldsize, pos, &lines);
1756                if (match_end && offset + oldsize != buf->len)
1757                        offset = -1;
1758                if (match_beginning && offset)
1759                        offset = -1;
1760                if (offset >= 0) {
1761                        if (new_whitespace == strip_whitespace &&
1762                            (buf->len - oldsize - offset == 0)) /* end of file? */
1763                                newsize -= new_blank_lines_at_end;
1764
1765                        /* Warn if it was necessary to reduce the number
1766                         * of context lines.
1767                         */
1768                        if ((leading != frag->leading) ||
1769                            (trailing != frag->trailing))
1770                                fprintf(stderr, "Context reduced to (%ld/%ld)"
1771                                        " to apply fragment at %d\n",
1772                                        leading, trailing, pos + lines);
1773
1774                        strbuf_splice(buf, offset, oldsize, newlines, newsize);
1775                        offset = 0;
1776                        break;
1777                }
1778
1779                /* Am I at my context limits? */
1780                if ((leading <= p_context) && (trailing <= p_context))
1781                        break;
1782                if (match_beginning || match_end) {
1783                        match_beginning = match_end = 0;
1784                        continue;
1785                }
1786                /* Reduce the number of context lines
1787                 * Reduce both leading and trailing if they are equal
1788                 * otherwise just reduce the larger context.
1789                 */
1790                if (leading >= trailing) {
1791                        remove_first_line(&oldlines, &oldsize);
1792                        remove_first_line(&newlines, &newsize);
1793                        pos--;
1794                        leading--;
1795                }
1796                if (trailing > leading) {
1797                        remove_last_line(&oldlines, &oldsize);
1798                        remove_last_line(&newlines, &newsize);
1799                        trailing--;
1800                }
1801        }
1802
1803        if (offset && apply_verbosely)
1804                error("while searching for:\n%.*s", oldsize, oldlines);
1805
1806        free(old);
1807        free(new);
1808        return offset;
1809}
1810
1811static int apply_binary_fragment(struct strbuf *buf, struct patch *patch)
1812{
1813        struct fragment *fragment = patch->fragments;
1814        unsigned long len;
1815        void *dst;
1816
1817        /* Binary patch is irreversible without the optional second hunk */
1818        if (apply_in_reverse) {
1819                if (!fragment->next)
1820                        return error("cannot reverse-apply a binary patch "
1821                                     "without the reverse hunk to '%s'",
1822                                     patch->new_name
1823                                     ? patch->new_name : patch->old_name);
1824                fragment = fragment->next;
1825        }
1826        switch (fragment->binary_patch_method) {
1827        case BINARY_DELTA_DEFLATED:
1828                dst = patch_delta(buf->buf, buf->len, fragment->patch,
1829                                  fragment->size, &len);
1830                if (!dst)
1831                        return -1;
1832                /* XXX patch_delta NUL-terminates */
1833                strbuf_attach(buf, dst, len, len + 1);
1834                return 0;
1835        case BINARY_LITERAL_DEFLATED:
1836                strbuf_reset(buf);
1837                strbuf_add(buf, fragment->patch, fragment->size);
1838                return 0;
1839        }
1840        return -1;
1841}
1842
1843static int apply_binary(struct strbuf *buf, struct patch *patch)
1844{
1845        const char *name = patch->old_name ? patch->old_name : patch->new_name;
1846        unsigned char sha1[20];
1847
1848        /* For safety, we require patch index line to contain
1849         * full 40-byte textual SHA1 for old and new, at least for now.
1850         */
1851        if (strlen(patch->old_sha1_prefix) != 40 ||
1852            strlen(patch->new_sha1_prefix) != 40 ||
1853            get_sha1_hex(patch->old_sha1_prefix, sha1) ||
1854            get_sha1_hex(patch->new_sha1_prefix, sha1))
1855                return error("cannot apply binary patch to '%s' "
1856                             "without full index line", name);
1857
1858        if (patch->old_name) {
1859                /* See if the old one matches what the patch
1860                 * applies to.
1861                 */
1862                hash_sha1_file(buf->buf, buf->len, blob_type, sha1);
1863                if (strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))
1864                        return error("the patch applies to '%s' (%s), "
1865                                     "which does not match the "
1866                                     "current contents.",
1867                                     name, sha1_to_hex(sha1));
1868        }
1869        else {
1870                /* Otherwise, the old one must be empty. */
1871                if (buf->len)
1872                        return error("the patch applies to an empty "
1873                                     "'%s' but it is not empty", name);
1874        }
1875
1876        get_sha1_hex(patch->new_sha1_prefix, sha1);
1877        if (is_null_sha1(sha1)) {
1878                strbuf_release(buf);
1879                return 0; /* deletion patch */
1880        }
1881
1882        if (has_sha1_file(sha1)) {
1883                /* We already have the postimage */
1884                enum object_type type;
1885                unsigned long size;
1886                char *result;
1887
1888                result = read_sha1_file(sha1, &type, &size);
1889                if (!result)
1890                        return error("the necessary postimage %s for "
1891                                     "'%s' cannot be read",
1892                                     patch->new_sha1_prefix, name);
1893                /* XXX read_sha1_file NUL-terminates */
1894                strbuf_attach(buf, result, size, size + 1);
1895        } else {
1896                /* We have verified buf matches the preimage;
1897                 * apply the patch data to it, which is stored
1898                 * in the patch->fragments->{patch,size}.
1899                 */
1900                if (apply_binary_fragment(buf, patch))
1901                        return error("binary patch does not apply to '%s'",
1902                                     name);
1903
1904                /* verify that the result matches */
1905                hash_sha1_file(buf->buf, buf->len, blob_type, sha1);
1906                if (strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))
1907                        return error("binary patch to '%s' creates incorrect result (expecting %s, got %s)",
1908                                name, patch->new_sha1_prefix, sha1_to_hex(sha1));
1909        }
1910
1911        return 0;
1912}
1913
1914static int apply_fragments(struct strbuf *buf, struct patch *patch)
1915{
1916        struct fragment *frag = patch->fragments;
1917        const char *name = patch->old_name ? patch->old_name : patch->new_name;
1918
1919        if (patch->is_binary)
1920                return apply_binary(buf, patch);
1921
1922        while (frag) {
1923                if (apply_one_fragment(buf, frag, patch->inaccurate_eof)) {
1924                        error("patch failed: %s:%ld", name, frag->oldpos);
1925                        if (!apply_with_reject)
1926                                return -1;
1927                        frag->rejected = 1;
1928                }
1929                frag = frag->next;
1930        }
1931        return 0;
1932}
1933
1934static int read_file_or_gitlink(struct cache_entry *ce, struct strbuf *buf)
1935{
1936        if (!ce)
1937                return 0;
1938
1939        if (S_ISGITLINK(ntohl(ce->ce_mode))) {
1940                strbuf_grow(buf, 100);
1941                strbuf_addf(buf, "Subproject commit %s\n", sha1_to_hex(ce->sha1));
1942        } else {
1943                enum object_type type;
1944                unsigned long sz;
1945                char *result;
1946
1947                result = read_sha1_file(ce->sha1, &type, &sz);
1948                if (!result)
1949                        return -1;
1950                /* XXX read_sha1_file NUL-terminates */
1951                strbuf_attach(buf, result, sz, sz + 1);
1952        }
1953        return 0;
1954}
1955
1956static int apply_data(struct patch *patch, struct stat *st, struct cache_entry *ce)
1957{
1958        struct strbuf buf;
1959
1960        strbuf_init(&buf, 0);
1961        if (cached) {
1962                if (read_file_or_gitlink(ce, &buf))
1963                        return error("read of %s failed", patch->old_name);
1964        } else if (patch->old_name) {
1965                if (S_ISGITLINK(patch->old_mode)) {
1966                        if (ce) {
1967                                read_file_or_gitlink(ce, &buf);
1968                        } else {
1969                                /*
1970                                 * There is no way to apply subproject
1971                                 * patch without looking at the index.
1972                                 */
1973                                patch->fragments = NULL;
1974                        }
1975                } else {
1976                        if (read_old_data(st, patch->old_name, &buf))
1977                                return error("read of %s failed", patch->old_name);
1978                }
1979        }
1980
1981        if (apply_fragments(&buf, patch) < 0)
1982                return -1; /* note with --reject this succeeds. */
1983        patch->result = buf.buf;
1984        patch->resultsize = buf.len;
1985
1986        if (0 < patch->is_delete && patch->resultsize)
1987                return error("removal patch leaves file contents");
1988
1989        return 0;
1990}
1991
1992static int check_to_create_blob(const char *new_name, int ok_if_exists)
1993{
1994        struct stat nst;
1995        if (!lstat(new_name, &nst)) {
1996                if (S_ISDIR(nst.st_mode) || ok_if_exists)
1997                        return 0;
1998                /*
1999                 * A leading component of new_name might be a symlink
2000                 * that is going to be removed with this patch, but
2001                 * still pointing at somewhere that has the path.
2002                 * In such a case, path "new_name" does not exist as
2003                 * far as git is concerned.
2004                 */
2005                if (has_symlink_leading_path(new_name, NULL))
2006                        return 0;
2007
2008                return error("%s: already exists in working directory", new_name);
2009        }
2010        else if ((errno != ENOENT) && (errno != ENOTDIR))
2011                return error("%s: %s", new_name, strerror(errno));
2012        return 0;
2013}
2014
2015static int verify_index_match(struct cache_entry *ce, struct stat *st)
2016{
2017        if (S_ISGITLINK(ntohl(ce->ce_mode))) {
2018                if (!S_ISDIR(st->st_mode))
2019                        return -1;
2020                return 0;
2021        }
2022        return ce_match_stat(ce, st, 1);
2023}
2024
2025static int check_patch(struct patch *patch, struct patch *prev_patch)
2026{
2027        struct stat st;
2028        const char *old_name = patch->old_name;
2029        const char *new_name = patch->new_name;
2030        const char *name = old_name ? old_name : new_name;
2031        struct cache_entry *ce = NULL;
2032        int ok_if_exists;
2033
2034        patch->rejected = 1; /* we will drop this after we succeed */
2035
2036        /*
2037         * Make sure that we do not have local modifications from the
2038         * index when we are looking at the index.  Also make sure
2039         * we have the preimage file to be patched in the work tree,
2040         * unless --cached, which tells git to apply only in the index.
2041         */
2042        if (old_name) {
2043                int stat_ret = 0;
2044                unsigned st_mode = 0;
2045
2046                if (!cached)
2047                        stat_ret = lstat(old_name, &st);
2048                if (check_index) {
2049                        int pos = cache_name_pos(old_name, strlen(old_name));
2050                        if (pos < 0)
2051                                return error("%s: does not exist in index",
2052                                             old_name);
2053                        ce = active_cache[pos];
2054                        if (stat_ret < 0) {
2055                                struct checkout costate;
2056                                if (errno != ENOENT)
2057                                        return error("%s: %s", old_name,
2058                                                     strerror(errno));
2059                                /* checkout */
2060                                costate.base_dir = "";
2061                                costate.base_dir_len = 0;
2062                                costate.force = 0;
2063                                costate.quiet = 0;
2064                                costate.not_new = 0;
2065                                costate.refresh_cache = 1;
2066                                if (checkout_entry(ce,
2067                                                   &costate,
2068                                                   NULL) ||
2069                                    lstat(old_name, &st))
2070                                        return -1;
2071                        }
2072                        if (!cached && verify_index_match(ce, &st))
2073                                return error("%s: does not match index",
2074                                             old_name);
2075                        if (cached)
2076                                st_mode = ntohl(ce->ce_mode);
2077                } else if (stat_ret < 0)
2078                        return error("%s: %s", old_name, strerror(errno));
2079
2080                if (!cached)
2081                        st_mode = ntohl(ce_mode_from_stat(ce, st.st_mode));
2082
2083                if (patch->is_new < 0)
2084                        patch->is_new = 0;
2085                if (!patch->old_mode)
2086                        patch->old_mode = st_mode;
2087                if ((st_mode ^ patch->old_mode) & S_IFMT)
2088                        return error("%s: wrong type", old_name);
2089                if (st_mode != patch->old_mode)
2090                        fprintf(stderr, "warning: %s has type %o, expected %o\n",
2091                                old_name, st_mode, patch->old_mode);
2092        }
2093
2094        if (new_name && prev_patch && 0 < prev_patch->is_delete &&
2095            !strcmp(prev_patch->old_name, new_name))
2096                /* A type-change diff is always split into a patch to
2097                 * delete old, immediately followed by a patch to
2098                 * create new (see diff.c::run_diff()); in such a case
2099                 * it is Ok that the entry to be deleted by the
2100                 * previous patch is still in the working tree and in
2101                 * the index.
2102                 */
2103                ok_if_exists = 1;
2104        else
2105                ok_if_exists = 0;
2106
2107        if (new_name &&
2108            ((0 < patch->is_new) | (0 < patch->is_rename) | patch->is_copy)) {
2109                if (check_index &&
2110                    cache_name_pos(new_name, strlen(new_name)) >= 0 &&
2111                    !ok_if_exists)
2112                        return error("%s: already exists in index", new_name);
2113                if (!cached) {
2114                        int err = check_to_create_blob(new_name, ok_if_exists);
2115                        if (err)
2116                                return err;
2117                }
2118                if (!patch->new_mode) {
2119                        if (0 < patch->is_new)
2120                                patch->new_mode = S_IFREG | 0644;
2121                        else
2122                                patch->new_mode = patch->old_mode;
2123                }
2124        }
2125
2126        if (new_name && old_name) {
2127                int same = !strcmp(old_name, new_name);
2128                if (!patch->new_mode)
2129                        patch->new_mode = patch->old_mode;
2130                if ((patch->old_mode ^ patch->new_mode) & S_IFMT)
2131                        return error("new mode (%o) of %s does not match old mode (%o)%s%s",
2132                                patch->new_mode, new_name, patch->old_mode,
2133                                same ? "" : " of ", same ? "" : old_name);
2134        }
2135
2136        if (apply_data(patch, &st, ce) < 0)
2137                return error("%s: patch does not apply", name);
2138        patch->rejected = 0;
2139        return 0;
2140}
2141
2142static int check_patch_list(struct patch *patch)
2143{
2144        struct patch *prev_patch = NULL;
2145        int err = 0;
2146
2147        for (prev_patch = NULL; patch ; patch = patch->next) {
2148                if (apply_verbosely)
2149                        say_patch_name(stderr,
2150                                       "Checking patch ", patch, "...\n");
2151                err |= check_patch(patch, prev_patch);
2152                prev_patch = patch;
2153        }
2154        return err;
2155}
2156
2157/* This function tries to read the sha1 from the current index */
2158static int get_current_sha1(const char *path, unsigned char *sha1)
2159{
2160        int pos;
2161
2162        if (read_cache() < 0)
2163                return -1;
2164        pos = cache_name_pos(path, strlen(path));
2165        if (pos < 0)
2166                return -1;
2167        hashcpy(sha1, active_cache[pos]->sha1);
2168        return 0;
2169}
2170
2171static void show_index_list(struct patch *list)
2172{
2173        struct patch *patch;
2174
2175        /* Once we start supporting the reverse patch, it may be
2176         * worth showing the new sha1 prefix, but until then...
2177         */
2178        for (patch = list; patch; patch = patch->next) {
2179                const unsigned char *sha1_ptr;
2180                unsigned char sha1[20];
2181                const char *name;
2182
2183                name = patch->old_name ? patch->old_name : patch->new_name;
2184                if (0 < patch->is_new)
2185                        sha1_ptr = null_sha1;
2186                else if (get_sha1(patch->old_sha1_prefix, sha1))
2187                        /* git diff has no index line for mode/type changes */
2188                        if (!patch->lines_added && !patch->lines_deleted) {
2189                                if (get_current_sha1(patch->new_name, sha1) ||
2190                                    get_current_sha1(patch->old_name, sha1))
2191                                        die("mode change for %s, which is not "
2192                                                "in current HEAD", name);
2193                                sha1_ptr = sha1;
2194                        } else
2195                                die("sha1 information is lacking or useless "
2196                                        "(%s).", name);
2197                else
2198                        sha1_ptr = sha1;
2199
2200                printf("%06o %s ",patch->old_mode, sha1_to_hex(sha1_ptr));
2201                if (line_termination && quote_c_style(name, NULL, NULL, 0))
2202                        quote_c_style(name, NULL, stdout, 0);
2203                else
2204                        fputs(name, stdout);
2205                putchar(line_termination);
2206        }
2207}
2208
2209static void stat_patch_list(struct patch *patch)
2210{
2211        int files, adds, dels;
2212
2213        for (files = adds = dels = 0 ; patch ; patch = patch->next) {
2214                files++;
2215                adds += patch->lines_added;
2216                dels += patch->lines_deleted;
2217                show_stats(patch);
2218        }
2219
2220        printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);
2221}
2222
2223static void numstat_patch_list(struct patch *patch)
2224{
2225        for ( ; patch; patch = patch->next) {
2226                const char *name;
2227                name = patch->new_name ? patch->new_name : patch->old_name;
2228                if (patch->is_binary)
2229                        printf("-\t-\t");
2230                else
2231                        printf("%d\t%d\t",
2232                               patch->lines_added, patch->lines_deleted);
2233                if (line_termination && quote_c_style(name, NULL, NULL, 0))
2234                        quote_c_style(name, NULL, stdout, 0);
2235                else
2236                        fputs(name, stdout);
2237                putchar(line_termination);
2238        }
2239}
2240
2241static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)
2242{
2243        if (mode)
2244                printf(" %s mode %06o %s\n", newdelete, mode, name);
2245        else
2246                printf(" %s %s\n", newdelete, name);
2247}
2248
2249static void show_mode_change(struct patch *p, int show_name)
2250{
2251        if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {
2252                if (show_name)
2253                        printf(" mode change %06o => %06o %s\n",
2254                               p->old_mode, p->new_mode, p->new_name);
2255                else
2256                        printf(" mode change %06o => %06o\n",
2257                               p->old_mode, p->new_mode);
2258        }
2259}
2260
2261static void show_rename_copy(struct patch *p)
2262{
2263        const char *renamecopy = p->is_rename ? "rename" : "copy";
2264        const char *old, *new;
2265
2266        /* Find common prefix */
2267        old = p->old_name;
2268        new = p->new_name;
2269        while (1) {
2270                const char *slash_old, *slash_new;
2271                slash_old = strchr(old, '/');
2272                slash_new = strchr(new, '/');
2273                if (!slash_old ||
2274                    !slash_new ||
2275                    slash_old - old != slash_new - new ||
2276                    memcmp(old, new, slash_new - new))
2277                        break;
2278                old = slash_old + 1;
2279                new = slash_new + 1;
2280        }
2281        /* p->old_name thru old is the common prefix, and old and new
2282         * through the end of names are renames
2283         */
2284        if (old != p->old_name)
2285                printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,
2286                       (int)(old - p->old_name), p->old_name,
2287                       old, new, p->score);
2288        else
2289                printf(" %s %s => %s (%d%%)\n", renamecopy,
2290                       p->old_name, p->new_name, p->score);
2291        show_mode_change(p, 0);
2292}
2293
2294static void summary_patch_list(struct patch *patch)
2295{
2296        struct patch *p;
2297
2298        for (p = patch; p; p = p->next) {
2299                if (p->is_new)
2300                        show_file_mode_name("create", p->new_mode, p->new_name);
2301                else if (p->is_delete)
2302                        show_file_mode_name("delete", p->old_mode, p->old_name);
2303                else {
2304                        if (p->is_rename || p->is_copy)
2305                                show_rename_copy(p);
2306                        else {
2307                                if (p->score) {
2308                                        printf(" rewrite %s (%d%%)\n",
2309                                               p->new_name, p->score);
2310                                        show_mode_change(p, 0);
2311                                }
2312                                else
2313                                        show_mode_change(p, 1);
2314                        }
2315                }
2316        }
2317}
2318
2319static void patch_stats(struct patch *patch)
2320{
2321        int lines = patch->lines_added + patch->lines_deleted;
2322
2323        if (lines > max_change)
2324                max_change = lines;
2325        if (patch->old_name) {
2326                int len = quote_c_style(patch->old_name, NULL, NULL, 0);
2327                if (!len)
2328                        len = strlen(patch->old_name);
2329                if (len > max_len)
2330                        max_len = len;
2331        }
2332        if (patch->new_name) {
2333                int len = quote_c_style(patch->new_name, NULL, NULL, 0);
2334                if (!len)
2335                        len = strlen(patch->new_name);
2336                if (len > max_len)
2337                        max_len = len;
2338        }
2339}
2340
2341static void remove_file(struct patch *patch, int rmdir_empty)
2342{
2343        if (update_index) {
2344                if (remove_file_from_cache(patch->old_name) < 0)
2345                        die("unable to remove %s from index", patch->old_name);
2346        }
2347        if (!cached) {
2348                if (S_ISGITLINK(patch->old_mode)) {
2349                        if (rmdir(patch->old_name))
2350                                warning("unable to remove submodule %s",
2351                                        patch->old_name);
2352                } else if (!unlink(patch->old_name) && rmdir_empty) {
2353                        char *name = xstrdup(patch->old_name);
2354                        char *end = strrchr(name, '/');
2355                        while (end) {
2356                                *end = 0;
2357                                if (rmdir(name))
2358                                        break;
2359                                end = strrchr(name, '/');
2360                        }
2361                        free(name);
2362                }
2363        }
2364}
2365
2366static void add_index_file(const char *path, unsigned mode, void *buf, unsigned long size)
2367{
2368        struct stat st;
2369        struct cache_entry *ce;
2370        int namelen = strlen(path);
2371        unsigned ce_size = cache_entry_size(namelen);
2372
2373        if (!update_index)
2374                return;
2375
2376        ce = xcalloc(1, ce_size);
2377        memcpy(ce->name, path, namelen);
2378        ce->ce_mode = create_ce_mode(mode);
2379        ce->ce_flags = htons(namelen);
2380        if (S_ISGITLINK(mode)) {
2381                const char *s = buf;
2382
2383                if (get_sha1_hex(s + strlen("Subproject commit "), ce->sha1))
2384                        die("corrupt patch for subproject %s", path);
2385        } else {
2386                if (!cached) {
2387                        if (lstat(path, &st) < 0)
2388                                die("unable to stat newly created file %s",
2389                                    path);
2390                        fill_stat_cache_info(ce, &st);
2391                }
2392                if (write_sha1_file(buf, size, blob_type, ce->sha1) < 0)
2393                        die("unable to create backing store for newly created file %s", path);
2394        }
2395        if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
2396                die("unable to add cache entry for %s", path);
2397}
2398
2399static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)
2400{
2401        int fd;
2402        struct strbuf nbuf;
2403
2404        if (S_ISGITLINK(mode)) {
2405                struct stat st;
2406                if (!lstat(path, &st) && S_ISDIR(st.st_mode))
2407                        return 0;
2408                return mkdir(path, 0777);
2409        }
2410
2411        if (has_symlinks && S_ISLNK(mode))
2412                /* Although buf:size is counted string, it also is NUL
2413                 * terminated.
2414                 */
2415                return symlink(buf, path);
2416
2417        fd = open(path, O_CREAT | O_EXCL | O_WRONLY, (mode & 0100) ? 0777 : 0666);
2418        if (fd < 0)
2419                return -1;
2420
2421        strbuf_init(&nbuf, 0);
2422        if (convert_to_working_tree(path, buf, size, &nbuf)) {
2423                size = nbuf.len;
2424                buf  = nbuf.buf;
2425        }
2426        write_or_die(fd, buf, size);
2427        strbuf_release(&nbuf);
2428
2429        if (close(fd) < 0)
2430                die("closing file %s: %s", path, strerror(errno));
2431        return 0;
2432}
2433
2434/*
2435 * We optimistically assume that the directories exist,
2436 * which is true 99% of the time anyway. If they don't,
2437 * we create them and try again.
2438 */
2439static void create_one_file(char *path, unsigned mode, const char *buf, unsigned long size)
2440{
2441        if (cached)
2442                return;
2443        if (!try_create_file(path, mode, buf, size))
2444                return;
2445
2446        if (errno == ENOENT) {
2447                if (safe_create_leading_directories(path))
2448                        return;
2449                if (!try_create_file(path, mode, buf, size))
2450                        return;
2451        }
2452
2453        if (errno == EEXIST || errno == EACCES) {
2454                /* We may be trying to create a file where a directory
2455                 * used to be.
2456                 */
2457                struct stat st;
2458                if (!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))
2459                        errno = EEXIST;
2460        }
2461
2462        if (errno == EEXIST) {
2463                unsigned int nr = getpid();
2464
2465                for (;;) {
2466                        const char *newpath;
2467                        newpath = mkpath("%s~%u", path, nr);
2468                        if (!try_create_file(newpath, mode, buf, size)) {
2469                                if (!rename(newpath, path))
2470                                        return;
2471                                unlink(newpath);
2472                                break;
2473                        }
2474                        if (errno != EEXIST)
2475                                break;
2476                        ++nr;
2477                }
2478        }
2479        die("unable to write file %s mode %o", path, mode);
2480}
2481
2482static void create_file(struct patch *patch)
2483{
2484        char *path = patch->new_name;
2485        unsigned mode = patch->new_mode;
2486        unsigned long size = patch->resultsize;
2487        char *buf = patch->result;
2488
2489        if (!mode)
2490                mode = S_IFREG | 0644;
2491        create_one_file(path, mode, buf, size);
2492        add_index_file(path, mode, buf, size);
2493}
2494
2495/* phase zero is to remove, phase one is to create */
2496static void write_out_one_result(struct patch *patch, int phase)
2497{
2498        if (patch->is_delete > 0) {
2499                if (phase == 0)
2500                        remove_file(patch, 1);
2501                return;
2502        }
2503        if (patch->is_new > 0 || patch->is_copy) {
2504                if (phase == 1)
2505                        create_file(patch);
2506                return;
2507        }
2508        /*
2509         * Rename or modification boils down to the same
2510         * thing: remove the old, write the new
2511         */
2512        if (phase == 0)
2513                remove_file(patch, patch->is_rename);
2514        if (phase == 1)
2515                create_file(patch);
2516}
2517
2518static int write_out_one_reject(struct patch *patch)
2519{
2520        FILE *rej;
2521        char namebuf[PATH_MAX];
2522        struct fragment *frag;
2523        int cnt = 0;
2524
2525        for (cnt = 0, frag = patch->fragments; frag; frag = frag->next) {
2526                if (!frag->rejected)
2527                        continue;
2528                cnt++;
2529        }
2530
2531        if (!cnt) {
2532                if (apply_verbosely)
2533                        say_patch_name(stderr,
2534                                       "Applied patch ", patch, " cleanly.\n");
2535                return 0;
2536        }
2537
2538        /* This should not happen, because a removal patch that leaves
2539         * contents are marked "rejected" at the patch level.
2540         */
2541        if (!patch->new_name)
2542                die("internal error");
2543
2544        /* Say this even without --verbose */
2545        say_patch_name(stderr, "Applying patch ", patch, " with");
2546        fprintf(stderr, " %d rejects...\n", cnt);
2547
2548        cnt = strlen(patch->new_name);
2549        if (ARRAY_SIZE(namebuf) <= cnt + 5) {
2550                cnt = ARRAY_SIZE(namebuf) - 5;
2551                fprintf(stderr,
2552                        "warning: truncating .rej filename to %.*s.rej",
2553                        cnt - 1, patch->new_name);
2554        }
2555        memcpy(namebuf, patch->new_name, cnt);
2556        memcpy(namebuf + cnt, ".rej", 5);
2557
2558        rej = fopen(namebuf, "w");
2559        if (!rej)
2560                return error("cannot open %s: %s", namebuf, strerror(errno));
2561
2562        /* Normal git tools never deal with .rej, so do not pretend
2563         * this is a git patch by saying --git nor give extended
2564         * headers.  While at it, maybe please "kompare" that wants
2565         * the trailing TAB and some garbage at the end of line ;-).
2566         */
2567        fprintf(rej, "diff a/%s b/%s\t(rejected hunks)\n",
2568                patch->new_name, patch->new_name);
2569        for (cnt = 1, frag = patch->fragments;
2570             frag;
2571             cnt++, frag = frag->next) {
2572                if (!frag->rejected) {
2573                        fprintf(stderr, "Hunk #%d applied cleanly.\n", cnt);
2574                        continue;
2575                }
2576                fprintf(stderr, "Rejected hunk #%d.\n", cnt);
2577                fprintf(rej, "%.*s", frag->size, frag->patch);
2578                if (frag->patch[frag->size-1] != '\n')
2579                        fputc('\n', rej);
2580        }
2581        fclose(rej);
2582        return -1;
2583}
2584
2585static int write_out_results(struct patch *list, int skipped_patch)
2586{
2587        int phase;
2588        int errs = 0;
2589        struct patch *l;
2590
2591        if (!list && !skipped_patch)
2592                return error("No changes");
2593
2594        for (phase = 0; phase < 2; phase++) {
2595                l = list;
2596                while (l) {
2597                        if (l->rejected)
2598                                errs = 1;
2599                        else {
2600                                write_out_one_result(l, phase);
2601                                if (phase == 1 && write_out_one_reject(l))
2602                                        errs = 1;
2603                        }
2604                        l = l->next;
2605                }
2606        }
2607        return errs;
2608}
2609
2610static struct lock_file lock_file;
2611
2612static struct excludes {
2613        struct excludes *next;
2614        const char *path;
2615} *excludes;
2616
2617static int use_patch(struct patch *p)
2618{
2619        const char *pathname = p->new_name ? p->new_name : p->old_name;
2620        struct excludes *x = excludes;
2621        while (x) {
2622                if (fnmatch(x->path, pathname, 0) == 0)
2623                        return 0;
2624                x = x->next;
2625        }
2626        if (0 < prefix_length) {
2627                int pathlen = strlen(pathname);
2628                if (pathlen <= prefix_length ||
2629                    memcmp(prefix, pathname, prefix_length))
2630                        return 0;
2631        }
2632        return 1;
2633}
2634
2635static void prefix_one(char **name)
2636{
2637        char *old_name = *name;
2638        if (!old_name)
2639                return;
2640        *name = xstrdup(prefix_filename(prefix, prefix_length, *name));
2641        free(old_name);
2642}
2643
2644static void prefix_patches(struct patch *p)
2645{
2646        if (!prefix || p->is_toplevel_relative)
2647                return;
2648        for ( ; p; p = p->next) {
2649                if (p->new_name == p->old_name) {
2650                        char *prefixed = p->new_name;
2651                        prefix_one(&prefixed);
2652                        p->new_name = p->old_name = prefixed;
2653                }
2654                else {
2655                        prefix_one(&p->new_name);
2656                        prefix_one(&p->old_name);
2657                }
2658        }
2659}
2660
2661static int apply_patch(int fd, const char *filename, int inaccurate_eof)
2662{
2663        unsigned long offset, size;
2664        char *buffer = read_patch_file(fd, &size);
2665        struct patch *list = NULL, **listp = &list;
2666        int skipped_patch = 0;
2667
2668        patch_input_file = filename;
2669        if (!buffer)
2670                return -1;
2671        offset = 0;
2672        while (size > 0) {
2673                struct patch *patch;
2674                int nr;
2675
2676                patch = xcalloc(1, sizeof(*patch));
2677                patch->inaccurate_eof = inaccurate_eof;
2678                nr = parse_chunk(buffer + offset, size, patch);
2679                if (nr < 0)
2680                        break;
2681                if (apply_in_reverse)
2682                        reverse_patches(patch);
2683                if (prefix)
2684                        prefix_patches(patch);
2685                if (use_patch(patch)) {
2686                        patch_stats(patch);
2687                        *listp = patch;
2688                        listp = &patch->next;
2689                }
2690                else {
2691                        /* perhaps free it a bit better? */
2692                        free(patch);
2693                        skipped_patch++;
2694                }
2695                offset += nr;
2696                size -= nr;
2697        }
2698
2699        if (whitespace_error && (new_whitespace == error_on_whitespace))
2700                apply = 0;
2701
2702        update_index = check_index && apply;
2703        if (update_index && newfd < 0)
2704                newfd = hold_locked_index(&lock_file, 1);
2705
2706        if (check_index) {
2707                if (read_cache() < 0)
2708                        die("unable to read index file");
2709        }
2710
2711        if ((check || apply) &&
2712            check_patch_list(list) < 0 &&
2713            !apply_with_reject)
2714                exit(1);
2715
2716        if (apply && write_out_results(list, skipped_patch))
2717                exit(1);
2718
2719        if (show_index_info)
2720                show_index_list(list);
2721
2722        if (diffstat)
2723                stat_patch_list(list);
2724
2725        if (numstat)
2726                numstat_patch_list(list);
2727
2728        if (summary)
2729                summary_patch_list(list);
2730
2731        free(buffer);
2732        return 0;
2733}
2734
2735static int git_apply_config(const char *var, const char *value)
2736{
2737        if (!strcmp(var, "apply.whitespace")) {
2738                apply_default_whitespace = xstrdup(value);
2739                return 0;
2740        }
2741        return git_default_config(var, value);
2742}
2743
2744
2745int cmd_apply(int argc, const char **argv, const char *unused_prefix)
2746{
2747        int i;
2748        int read_stdin = 1;
2749        int inaccurate_eof = 0;
2750        int errs = 0;
2751        int is_not_gitdir = 0;
2752
2753        const char *whitespace_option = NULL;
2754
2755        prefix = setup_git_directory_gently(&is_not_gitdir);
2756        prefix_length = prefix ? strlen(prefix) : 0;
2757        git_config(git_apply_config);
2758        if (apply_default_whitespace)
2759                parse_whitespace_option(apply_default_whitespace);
2760
2761        for (i = 1; i < argc; i++) {
2762                const char *arg = argv[i];
2763                char *end;
2764                int fd;
2765
2766                if (!strcmp(arg, "-")) {
2767                        errs |= apply_patch(0, "<stdin>", inaccurate_eof);
2768                        read_stdin = 0;
2769                        continue;
2770                }
2771                if (!prefixcmp(arg, "--exclude=")) {
2772                        struct excludes *x = xmalloc(sizeof(*x));
2773                        x->path = arg + 10;
2774                        x->next = excludes;
2775                        excludes = x;
2776                        continue;
2777                }
2778                if (!prefixcmp(arg, "-p")) {
2779                        p_value = atoi(arg + 2);
2780                        p_value_known = 1;
2781                        continue;
2782                }
2783                if (!strcmp(arg, "--no-add")) {
2784                        no_add = 1;
2785                        continue;
2786                }
2787                if (!strcmp(arg, "--stat")) {
2788                        apply = 0;
2789                        diffstat = 1;
2790                        continue;
2791                }
2792                if (!strcmp(arg, "--allow-binary-replacement") ||
2793                    !strcmp(arg, "--binary")) {
2794                        continue; /* now no-op */
2795                }
2796                if (!strcmp(arg, "--numstat")) {
2797                        apply = 0;
2798                        numstat = 1;
2799                        continue;
2800                }
2801                if (!strcmp(arg, "--summary")) {
2802                        apply = 0;
2803                        summary = 1;
2804                        continue;
2805                }
2806                if (!strcmp(arg, "--check")) {
2807                        apply = 0;
2808                        check = 1;
2809                        continue;
2810                }
2811                if (!strcmp(arg, "--index")) {
2812                        if (is_not_gitdir)
2813                                die("--index outside a repository");
2814                        check_index = 1;
2815                        continue;
2816                }
2817                if (!strcmp(arg, "--cached")) {
2818                        if (is_not_gitdir)
2819                                die("--cached outside a repository");
2820                        check_index = 1;
2821                        cached = 1;
2822                        continue;
2823                }
2824                if (!strcmp(arg, "--apply")) {
2825                        apply = 1;
2826                        continue;
2827                }
2828                if (!strcmp(arg, "--index-info")) {
2829                        apply = 0;
2830                        show_index_info = 1;
2831                        continue;
2832                }
2833                if (!strcmp(arg, "-z")) {
2834                        line_termination = 0;
2835                        continue;
2836                }
2837                if (!prefixcmp(arg, "-C")) {
2838                        p_context = strtoul(arg + 2, &end, 0);
2839                        if (*end != '\0')
2840                                die("unrecognized context count '%s'", arg + 2);
2841                        continue;
2842                }
2843                if (!prefixcmp(arg, "--whitespace=")) {
2844                        whitespace_option = arg + 13;
2845                        parse_whitespace_option(arg + 13);
2846                        continue;
2847                }
2848                if (!strcmp(arg, "-R") || !strcmp(arg, "--reverse")) {
2849                        apply_in_reverse = 1;
2850                        continue;
2851                }
2852                if (!strcmp(arg, "--unidiff-zero")) {
2853                        unidiff_zero = 1;
2854                        continue;
2855                }
2856                if (!strcmp(arg, "--reject")) {
2857                        apply = apply_with_reject = apply_verbosely = 1;
2858                        continue;
2859                }
2860                if (!strcmp(arg, "-v") || !strcmp(arg, "--verbose")) {
2861                        apply_verbosely = 1;
2862                        continue;
2863                }
2864                if (!strcmp(arg, "--inaccurate-eof")) {
2865                        inaccurate_eof = 1;
2866                        continue;
2867                }
2868                if (0 < prefix_length)
2869                        arg = prefix_filename(prefix, prefix_length, arg);
2870
2871                fd = open(arg, O_RDONLY);
2872                if (fd < 0)
2873                        usage(apply_usage);
2874                read_stdin = 0;
2875                set_default_whitespace_mode(whitespace_option);
2876                errs |= apply_patch(fd, arg, inaccurate_eof);
2877                close(fd);
2878        }
2879        set_default_whitespace_mode(whitespace_option);
2880        if (read_stdin)
2881                errs |= apply_patch(0, "<stdin>", inaccurate_eof);
2882        if (whitespace_error) {
2883                if (squelch_whitespace_errors &&
2884                    squelch_whitespace_errors < whitespace_error) {
2885                        int squelched =
2886                                whitespace_error - squelch_whitespace_errors;
2887                        fprintf(stderr, "warning: squelched %d "
2888                                "whitespace error%s\n",
2889                                squelched,
2890                                squelched == 1 ? "" : "s");
2891                }
2892                if (new_whitespace == error_on_whitespace)
2893                        die("%d line%s add%s whitespace errors.",
2894                            whitespace_error,
2895                            whitespace_error == 1 ? "" : "s",
2896                            whitespace_error == 1 ? "s" : "");
2897                if (applied_after_fixing_ws)
2898                        fprintf(stderr, "warning: %d line%s applied after"
2899                                " fixing whitespace errors.\n",
2900                                applied_after_fixing_ws,
2901                                applied_after_fixing_ws == 1 ? "" : "s");
2902                else if (whitespace_error)
2903                        fprintf(stderr, "warning: %d line%s add%s whitespace errors.\n",
2904                                whitespace_error,
2905                                whitespace_error == 1 ? "" : "s",
2906                                whitespace_error == 1 ? "s" : "");
2907        }
2908
2909        if (update_index) {
2910                if (write_cache(newfd, active_cache, active_nr) ||
2911                    close(newfd) || commit_locked_index(&lock_file))
2912                        die("Unable to write new index file");
2913        }
2914
2915        return !!errs;
2916}