apply.con commit Merge branch 'lt/rev-list' (21dbe12)
   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 <fnmatch.h>
  10#include "cache.h"
  11#include "quote.h"
  12
  13//  --check turns on checking that the working tree matches the
  14//    files that are being modified, but doesn't apply the patch
  15//  --stat does just a diffstat, and doesn't actually apply
  16//  --numstat does numeric diffstat, and doesn't actually apply
  17//  --index-info shows the old and new index info for paths if available.
  18//
  19static const char *prefix;
  20static int prefix_length = -1;
  21
  22static int p_value = 1;
  23static int allow_binary_replacement = 0;
  24static int check_index = 0;
  25static int write_index = 0;
  26static int diffstat = 0;
  27static int numstat = 0;
  28static int summary = 0;
  29static int check = 0;
  30static int apply = 1;
  31static int no_add = 0;
  32static int show_index_info = 0;
  33static int line_termination = '\n';
  34static const char apply_usage[] =
  35"git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [-z] [-pNUM] [--whitespace=<nowarn|warn|error|error-all|strip>] <patch>...";
  36
  37static enum whitespace_eol {
  38        nowarn_whitespace,
  39        warn_on_whitespace,
  40        error_on_whitespace,
  41        strip_whitespace,
  42} new_whitespace = warn_on_whitespace;
  43static int whitespace_error = 0;
  44static int squelch_whitespace_errors = 5;
  45static int applied_after_stripping = 0;
  46static const char *patch_input_file = NULL;
  47
  48static void parse_whitespace_option(const char *option)
  49{
  50        if (!option) {
  51                new_whitespace = warn_on_whitespace;
  52                return;
  53        }
  54        if (!strcmp(option, "warn")) {
  55                new_whitespace = warn_on_whitespace;
  56                return;
  57        }
  58        if (!strcmp(option, "nowarn")) {
  59                new_whitespace = nowarn_whitespace;
  60                return;
  61        }
  62        if (!strcmp(option, "error")) {
  63                new_whitespace = error_on_whitespace;
  64                return;
  65        }
  66        if (!strcmp(option, "error-all")) {
  67                new_whitespace = error_on_whitespace;
  68                squelch_whitespace_errors = 0;
  69                return;
  70        }
  71        if (!strcmp(option, "strip")) {
  72                new_whitespace = strip_whitespace;
  73                return;
  74        }
  75        die("unrecognized whitespace option '%s'", option);
  76}
  77
  78static void set_default_whitespace_mode(const char *whitespace_option)
  79{
  80        if (!whitespace_option && !apply_default_whitespace) {
  81                new_whitespace = (apply
  82                                  ? warn_on_whitespace
  83                                  : nowarn_whitespace);
  84        }
  85}
  86
  87/*
  88 * For "diff-stat" like behaviour, we keep track of the biggest change
  89 * we've seen, and the longest filename. That allows us to do simple
  90 * scaling.
  91 */
  92static int max_change, max_len;
  93
  94/*
  95 * Various "current state", notably line numbers and what
  96 * file (and how) we're patching right now.. The "is_xxxx"
  97 * things are flags, where -1 means "don't know yet".
  98 */
  99static int linenr = 1;
 100
 101struct fragment {
 102        unsigned long oldpos, oldlines;
 103        unsigned long newpos, newlines;
 104        const char *patch;
 105        int size;
 106        struct fragment *next;
 107};
 108
 109struct patch {
 110        char *new_name, *old_name, *def_name;
 111        unsigned int old_mode, new_mode;
 112        int is_rename, is_copy, is_new, is_delete, is_binary;
 113        int lines_added, lines_deleted;
 114        int score;
 115        struct fragment *fragments;
 116        char *result;
 117        unsigned long resultsize;
 118        char old_sha1_prefix[41];
 119        char new_sha1_prefix[41];
 120        struct patch *next;
 121};
 122
 123#define CHUNKSIZE (8192)
 124#define SLOP (16)
 125
 126static void *read_patch_file(int fd, unsigned long *sizep)
 127{
 128        unsigned long size = 0, alloc = CHUNKSIZE;
 129        void *buffer = xmalloc(alloc);
 130
 131        for (;;) {
 132                int nr = alloc - size;
 133                if (nr < 1024) {
 134                        alloc += CHUNKSIZE;
 135                        buffer = xrealloc(buffer, alloc);
 136                        nr = alloc - size;
 137                }
 138                nr = xread(fd, buffer + size, nr);
 139                if (!nr)
 140                        break;
 141                if (nr < 0)
 142                        die("git-apply: read returned %s", strerror(errno));
 143                size += nr;
 144        }
 145        *sizep = size;
 146
 147        /*
 148         * Make sure that we have some slop in the buffer
 149         * so that we can do speculative "memcmp" etc, and
 150         * see to it that it is NUL-filled.
 151         */
 152        if (alloc < size + SLOP)
 153                buffer = xrealloc(buffer, size + SLOP);
 154        memset(buffer + size, 0, SLOP);
 155        return buffer;
 156}
 157
 158static unsigned long linelen(const char *buffer, unsigned long size)
 159{
 160        unsigned long len = 0;
 161        while (size--) {
 162                len++;
 163                if (*buffer++ == '\n')
 164                        break;
 165        }
 166        return len;
 167}
 168
 169static int is_dev_null(const char *str)
 170{
 171        return !memcmp("/dev/null", str, 9) && isspace(str[9]);
 172}
 173
 174#define TERM_SPACE      1
 175#define TERM_TAB        2
 176
 177static int name_terminate(const char *name, int namelen, int c, int terminate)
 178{
 179        if (c == ' ' && !(terminate & TERM_SPACE))
 180                return 0;
 181        if (c == '\t' && !(terminate & TERM_TAB))
 182                return 0;
 183
 184        return 1;
 185}
 186
 187static char * find_name(const char *line, char *def, int p_value, int terminate)
 188{
 189        int len;
 190        const char *start = line;
 191        char *name;
 192
 193        if (*line == '"') {
 194                /* Proposed "new-style" GNU patch/diff format; see
 195                 * http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2
 196                 */
 197                name = unquote_c_style(line, NULL);
 198                if (name) {
 199                        char *cp = name;
 200                        while (p_value) {
 201                                cp = strchr(name, '/');
 202                                if (!cp)
 203                                        break;
 204                                cp++;
 205                                p_value--;
 206                        }
 207                        if (cp) {
 208                                /* name can later be freed, so we need
 209                                 * to memmove, not just return cp
 210                                 */
 211                                memmove(name, cp, strlen(cp) + 1);
 212                                free(def);
 213                                return name;
 214                        }
 215                        else {
 216                                free(name);
 217                                name = NULL;
 218                        }
 219                }
 220        }
 221
 222        for (;;) {
 223                char c = *line;
 224
 225                if (isspace(c)) {
 226                        if (c == '\n')
 227                                break;
 228                        if (name_terminate(start, line-start, c, terminate))
 229                                break;
 230                }
 231                line++;
 232                if (c == '/' && !--p_value)
 233                        start = line;
 234        }
 235        if (!start)
 236                return def;
 237        len = line - start;
 238        if (!len)
 239                return def;
 240
 241        /*
 242         * Generally we prefer the shorter name, especially
 243         * if the other one is just a variation of that with
 244         * something else tacked on to the end (ie "file.orig"
 245         * or "file~").
 246         */
 247        if (def) {
 248                int deflen = strlen(def);
 249                if (deflen < len && !strncmp(start, def, deflen))
 250                        return def;
 251        }
 252
 253        name = xmalloc(len + 1);
 254        memcpy(name, start, len);
 255        name[len] = 0;
 256        free(def);
 257        return name;
 258}
 259
 260/*
 261 * Get the name etc info from the --/+++ lines of a traditional patch header
 262 *
 263 * NOTE! This hardcodes "-p1" behaviour in filename detection.
 264 *
 265 * FIXME! The end-of-filename heuristics are kind of screwy. For existing
 266 * files, we can happily check the index for a match, but for creating a
 267 * new file we should try to match whatever "patch" does. I have no idea.
 268 */
 269static void parse_traditional_patch(const char *first, const char *second, struct patch *patch)
 270{
 271        char *name;
 272
 273        first += 4;     // skip "--- "
 274        second += 4;    // skip "+++ "
 275        if (is_dev_null(first)) {
 276                patch->is_new = 1;
 277                patch->is_delete = 0;
 278                name = find_name(second, NULL, p_value, TERM_SPACE | TERM_TAB);
 279                patch->new_name = name;
 280        } else if (is_dev_null(second)) {
 281                patch->is_new = 0;
 282                patch->is_delete = 1;
 283                name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
 284                patch->old_name = name;
 285        } else {
 286                name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
 287                name = find_name(second, name, p_value, TERM_SPACE | TERM_TAB);
 288                patch->old_name = patch->new_name = name;
 289        }
 290        if (!name)
 291                die("unable to find filename in patch at line %d", linenr);
 292}
 293
 294static int gitdiff_hdrend(const char *line, struct patch *patch)
 295{
 296        return -1;
 297}
 298
 299/*
 300 * We're anal about diff header consistency, to make
 301 * sure that we don't end up having strange ambiguous
 302 * patches floating around.
 303 *
 304 * As a result, gitdiff_{old|new}name() will check
 305 * their names against any previous information, just
 306 * to make sure..
 307 */
 308static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, const char *oldnew)
 309{
 310        if (!orig_name && !isnull)
 311                return find_name(line, NULL, 1, 0);
 312
 313        if (orig_name) {
 314                int len;
 315                const char *name;
 316                char *another;
 317                name = orig_name;
 318                len = strlen(name);
 319                if (isnull)
 320                        die("git-apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr);
 321                another = find_name(line, NULL, 1, 0);
 322                if (!another || memcmp(another, name, len))
 323                        die("git-apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr);
 324                free(another);
 325                return orig_name;
 326        }
 327        else {
 328                /* expect "/dev/null" */
 329                if (memcmp("/dev/null", line, 9) || line[9] != '\n')
 330                        die("git-apply: bad git-diff - expected /dev/null on line %d", linenr);
 331                return NULL;
 332        }
 333}
 334
 335static int gitdiff_oldname(const char *line, struct patch *patch)
 336{
 337        patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name, "old");
 338        return 0;
 339}
 340
 341static int gitdiff_newname(const char *line, struct patch *patch)
 342{
 343        patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name, "new");
 344        return 0;
 345}
 346
 347static int gitdiff_oldmode(const char *line, struct patch *patch)
 348{
 349        patch->old_mode = strtoul(line, NULL, 8);
 350        return 0;
 351}
 352
 353static int gitdiff_newmode(const char *line, struct patch *patch)
 354{
 355        patch->new_mode = strtoul(line, NULL, 8);
 356        return 0;
 357}
 358
 359static int gitdiff_delete(const char *line, struct patch *patch)
 360{
 361        patch->is_delete = 1;
 362        patch->old_name = patch->def_name;
 363        return gitdiff_oldmode(line, patch);
 364}
 365
 366static int gitdiff_newfile(const char *line, struct patch *patch)
 367{
 368        patch->is_new = 1;
 369        patch->new_name = patch->def_name;
 370        return gitdiff_newmode(line, patch);
 371}
 372
 373static int gitdiff_copysrc(const char *line, struct patch *patch)
 374{
 375        patch->is_copy = 1;
 376        patch->old_name = find_name(line, NULL, 0, 0);
 377        return 0;
 378}
 379
 380static int gitdiff_copydst(const char *line, struct patch *patch)
 381{
 382        patch->is_copy = 1;
 383        patch->new_name = find_name(line, NULL, 0, 0);
 384        return 0;
 385}
 386
 387static int gitdiff_renamesrc(const char *line, struct patch *patch)
 388{
 389        patch->is_rename = 1;
 390        patch->old_name = find_name(line, NULL, 0, 0);
 391        return 0;
 392}
 393
 394static int gitdiff_renamedst(const char *line, struct patch *patch)
 395{
 396        patch->is_rename = 1;
 397        patch->new_name = find_name(line, NULL, 0, 0);
 398        return 0;
 399}
 400
 401static int gitdiff_similarity(const char *line, struct patch *patch)
 402{
 403        if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
 404                patch->score = 0;
 405        return 0;
 406}
 407
 408static int gitdiff_dissimilarity(const char *line, struct patch *patch)
 409{
 410        if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
 411                patch->score = 0;
 412        return 0;
 413}
 414
 415static int gitdiff_index(const char *line, struct patch *patch)
 416{
 417        /* index line is N hexadecimal, "..", N hexadecimal,
 418         * and optional space with octal mode.
 419         */
 420        const char *ptr, *eol;
 421        int len;
 422
 423        ptr = strchr(line, '.');
 424        if (!ptr || ptr[1] != '.' || 40 < ptr - line)
 425                return 0;
 426        len = ptr - line;
 427        memcpy(patch->old_sha1_prefix, line, len);
 428        patch->old_sha1_prefix[len] = 0;
 429
 430        line = ptr + 2;
 431        ptr = strchr(line, ' ');
 432        eol = strchr(line, '\n');
 433
 434        if (!ptr || eol < ptr)
 435                ptr = eol;
 436        len = ptr - line;
 437
 438        if (40 < len)
 439                return 0;
 440        memcpy(patch->new_sha1_prefix, line, len);
 441        patch->new_sha1_prefix[len] = 0;
 442        if (*ptr == ' ')
 443                patch->new_mode = patch->old_mode = strtoul(ptr+1, NULL, 8);
 444        return 0;
 445}
 446
 447/*
 448 * This is normal for a diff that doesn't change anything: we'll fall through
 449 * into the next diff. Tell the parser to break out.
 450 */
 451static int gitdiff_unrecognized(const char *line, struct patch *patch)
 452{
 453        return -1;
 454}
 455
 456static const char *stop_at_slash(const char *line, int llen)
 457{
 458        int i;
 459
 460        for (i = 0; i < llen; i++) {
 461                int ch = line[i];
 462                if (ch == '/')
 463                        return line + i;
 464        }
 465        return NULL;
 466}
 467
 468/* This is to extract the same name that appears on "diff --git"
 469 * line.  We do not find and return anything if it is a rename
 470 * patch, and it is OK because we will find the name elsewhere.
 471 * We need to reliably find name only when it is mode-change only,
 472 * creation or deletion of an empty file.  In any of these cases,
 473 * both sides are the same name under a/ and b/ respectively.
 474 */
 475static char *git_header_name(char *line, int llen)
 476{
 477        int len;
 478        const char *name;
 479        const char *second = NULL;
 480
 481        line += strlen("diff --git ");
 482        llen -= strlen("diff --git ");
 483
 484        if (*line == '"') {
 485                const char *cp;
 486                char *first = unquote_c_style(line, &second);
 487                if (!first)
 488                        return NULL;
 489
 490                /* advance to the first slash */
 491                cp = stop_at_slash(first, strlen(first));
 492                if (!cp || cp == first) {
 493                        /* we do not accept absolute paths */
 494                free_first_and_fail:
 495                        free(first);
 496                        return NULL;
 497                }
 498                len = strlen(cp+1);
 499                memmove(first, cp+1, len+1); /* including NUL */
 500
 501                /* second points at one past closing dq of name.
 502                 * find the second name.
 503                 */
 504                while ((second < line + llen) && isspace(*second))
 505                        second++;
 506
 507                if (line + llen <= second)
 508                        goto free_first_and_fail;
 509                if (*second == '"') {
 510                        char *sp = unquote_c_style(second, NULL);
 511                        if (!sp)
 512                                goto free_first_and_fail;
 513                        cp = stop_at_slash(sp, strlen(sp));
 514                        if (!cp || cp == sp) {
 515                        free_both_and_fail:
 516                                free(sp);
 517                                goto free_first_and_fail;
 518                        }
 519                        /* They must match, otherwise ignore */
 520                        if (strcmp(cp+1, first))
 521                                goto free_both_and_fail;
 522                        free(sp);
 523                        return first;
 524                }
 525
 526                /* unquoted second */
 527                cp = stop_at_slash(second, line + llen - second);
 528                if (!cp || cp == second)
 529                        goto free_first_and_fail;
 530                cp++;
 531                if (line + llen - cp != len + 1 ||
 532                    memcmp(first, cp, len))
 533                        goto free_first_and_fail;
 534                return first;
 535        }
 536
 537        /* unquoted first name */
 538        name = stop_at_slash(line, llen);
 539        if (!name || name == line)
 540                return NULL;
 541
 542        name++;
 543
 544        /* since the first name is unquoted, a dq if exists must be
 545         * the beginning of the second name.
 546         */
 547        for (second = name; second < line + llen; second++) {
 548                if (*second == '"') {
 549                        const char *cp = second;
 550                        const char *np;
 551                        char *sp = unquote_c_style(second, NULL);
 552
 553                        if (!sp)
 554                                return NULL;
 555                        np = stop_at_slash(sp, strlen(sp));
 556                        if (!np || np == sp) {
 557                        free_second_and_fail:
 558                                free(sp);
 559                                return NULL;
 560                        }
 561                        np++;
 562                        len = strlen(np);
 563                        if (len < cp - name &&
 564                            !strncmp(np, name, len) &&
 565                            isspace(name[len])) {
 566                                /* Good */
 567                                memmove(sp, np, len + 1);
 568                                return sp;
 569                        }
 570                        goto free_second_and_fail;
 571                }
 572        }
 573
 574        /*
 575         * Accept a name only if it shows up twice, exactly the same
 576         * form.
 577         */
 578        for (len = 0 ; ; len++) {
 579                char c = name[len];
 580
 581                switch (c) {
 582                default:
 583                        continue;
 584                case '\n':
 585                        return NULL;
 586                case '\t': case ' ':
 587                        second = name+len;
 588                        for (;;) {
 589                                char c = *second++;
 590                                if (c == '\n')
 591                                        return NULL;
 592                                if (c == '/')
 593                                        break;
 594                        }
 595                        if (second[len] == '\n' && !memcmp(name, second, len)) {
 596                                char *ret = xmalloc(len + 1);
 597                                memcpy(ret, name, len);
 598                                ret[len] = 0;
 599                                return ret;
 600                        }
 601                }
 602        }
 603        return NULL;
 604}
 605
 606/* Verify that we recognize the lines following a git header */
 607static int parse_git_header(char *line, int len, unsigned int size, struct patch *patch)
 608{
 609        unsigned long offset;
 610
 611        /* A git diff has explicit new/delete information, so we don't guess */
 612        patch->is_new = 0;
 613        patch->is_delete = 0;
 614
 615        /*
 616         * Some things may not have the old name in the
 617         * rest of the headers anywhere (pure mode changes,
 618         * or removing or adding empty files), so we get
 619         * the default name from the header.
 620         */
 621        patch->def_name = git_header_name(line, len);
 622
 623        line += len;
 624        size -= len;
 625        linenr++;
 626        for (offset = len ; size > 0 ; offset += len, size -= len, line += len, linenr++) {
 627                static const struct opentry {
 628                        const char *str;
 629                        int (*fn)(const char *, struct patch *);
 630                } optable[] = {
 631                        { "@@ -", gitdiff_hdrend },
 632                        { "--- ", gitdiff_oldname },
 633                        { "+++ ", gitdiff_newname },
 634                        { "old mode ", gitdiff_oldmode },
 635                        { "new mode ", gitdiff_newmode },
 636                        { "deleted file mode ", gitdiff_delete },
 637                        { "new file mode ", gitdiff_newfile },
 638                        { "copy from ", gitdiff_copysrc },
 639                        { "copy to ", gitdiff_copydst },
 640                        { "rename old ", gitdiff_renamesrc },
 641                        { "rename new ", gitdiff_renamedst },
 642                        { "rename from ", gitdiff_renamesrc },
 643                        { "rename to ", gitdiff_renamedst },
 644                        { "similarity index ", gitdiff_similarity },
 645                        { "dissimilarity index ", gitdiff_dissimilarity },
 646                        { "index ", gitdiff_index },
 647                        { "", gitdiff_unrecognized },
 648                };
 649                int i;
 650
 651                len = linelen(line, size);
 652                if (!len || line[len-1] != '\n')
 653                        break;
 654                for (i = 0; i < sizeof(optable) / sizeof(optable[0]); i++) {
 655                        const struct opentry *p = optable + i;
 656                        int oplen = strlen(p->str);
 657                        if (len < oplen || memcmp(p->str, line, oplen))
 658                                continue;
 659                        if (p->fn(line + oplen, patch) < 0)
 660                                return offset;
 661                        break;
 662                }
 663        }
 664
 665        return offset;
 666}
 667
 668static int parse_num(const char *line, unsigned long *p)
 669{
 670        char *ptr;
 671
 672        if (!isdigit(*line))
 673                return 0;
 674        *p = strtoul(line, &ptr, 10);
 675        return ptr - line;
 676}
 677
 678static int parse_range(const char *line, int len, int offset, const char *expect,
 679                        unsigned long *p1, unsigned long *p2)
 680{
 681        int digits, ex;
 682
 683        if (offset < 0 || offset >= len)
 684                return -1;
 685        line += offset;
 686        len -= offset;
 687
 688        digits = parse_num(line, p1);
 689        if (!digits)
 690                return -1;
 691
 692        offset += digits;
 693        line += digits;
 694        len -= digits;
 695
 696        *p2 = *p1;
 697        if (*line == ',') {
 698                digits = parse_num(line+1, p2);
 699                if (!digits)
 700                        return -1;
 701
 702                offset += digits+1;
 703                line += digits+1;
 704                len -= digits+1;
 705        }
 706
 707        ex = strlen(expect);
 708        if (ex > len)
 709                return -1;
 710        if (memcmp(line, expect, ex))
 711                return -1;
 712
 713        return offset + ex;
 714}
 715
 716/*
 717 * Parse a unified diff fragment header of the
 718 * form "@@ -a,b +c,d @@"
 719 */
 720static int parse_fragment_header(char *line, int len, struct fragment *fragment)
 721{
 722        int offset;
 723
 724        if (!len || line[len-1] != '\n')
 725                return -1;
 726
 727        /* Figure out the number of lines in a fragment */
 728        offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);
 729        offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);
 730
 731        return offset;
 732}
 733
 734static int find_header(char *line, unsigned long size, int *hdrsize, struct patch *patch)
 735{
 736        unsigned long offset, len;
 737
 738        patch->is_rename = patch->is_copy = 0;
 739        patch->is_new = patch->is_delete = -1;
 740        patch->old_mode = patch->new_mode = 0;
 741        patch->old_name = patch->new_name = NULL;
 742        for (offset = 0; size > 0; offset += len, size -= len, line += len, linenr++) {
 743                unsigned long nextlen;
 744
 745                len = linelen(line, size);
 746                if (!len)
 747                        break;
 748
 749                /* Testing this early allows us to take a few shortcuts.. */
 750                if (len < 6)
 751                        continue;
 752
 753                /*
 754                 * Make sure we don't find any unconnected patch fragmants.
 755                 * That's a sign that we didn't find a header, and that a
 756                 * patch has become corrupted/broken up.
 757                 */
 758                if (!memcmp("@@ -", line, 4)) {
 759                        struct fragment dummy;
 760                        if (parse_fragment_header(line, len, &dummy) < 0)
 761                                continue;
 762                        error("patch fragment without header at line %d: %.*s", linenr, (int)len-1, line);
 763                }
 764
 765                if (size < len + 6)
 766                        break;
 767
 768                /*
 769                 * Git patch? It might not have a real patch, just a rename
 770                 * or mode change, so we handle that specially
 771                 */
 772                if (!memcmp("diff --git ", line, 11)) {
 773                        int git_hdr_len = parse_git_header(line, len, size, patch);
 774                        if (git_hdr_len <= len)
 775                                continue;
 776                        if (!patch->old_name && !patch->new_name) {
 777                                if (!patch->def_name)
 778                                        die("git diff header lacks filename information (line %d)", linenr);
 779                                patch->old_name = patch->new_name = patch->def_name;
 780                        }
 781                        *hdrsize = git_hdr_len;
 782                        return offset;
 783                }
 784
 785                /** --- followed by +++ ? */
 786                if (memcmp("--- ", line,  4) || memcmp("+++ ", line + len, 4))
 787                        continue;
 788
 789                /*
 790                 * We only accept unified patches, so we want it to
 791                 * at least have "@@ -a,b +c,d @@\n", which is 14 chars
 792                 * minimum
 793                 */
 794                nextlen = linelen(line + len, size - len);
 795                if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))
 796                        continue;
 797
 798                /* Ok, we'll consider it a patch */
 799                parse_traditional_patch(line, line+len, patch);
 800                *hdrsize = len + nextlen;
 801                linenr += 2;
 802                return offset;
 803        }
 804        return -1;
 805}
 806
 807/*
 808 * Parse a unified diff. Note that this really needs
 809 * to parse each fragment separately, since the only
 810 * way to know the difference between a "---" that is
 811 * part of a patch, and a "---" that starts the next
 812 * patch is to look at the line counts..
 813 */
 814static int parse_fragment(char *line, unsigned long size, struct patch *patch, struct fragment *fragment)
 815{
 816        int added, deleted;
 817        int len = linelen(line, size), offset;
 818        unsigned long oldlines, newlines;
 819
 820        offset = parse_fragment_header(line, len, fragment);
 821        if (offset < 0)
 822                return -1;
 823        oldlines = fragment->oldlines;
 824        newlines = fragment->newlines;
 825
 826        if (patch->is_new < 0) {
 827                patch->is_new =  !oldlines;
 828                if (!oldlines)
 829                        patch->old_name = NULL;
 830        }
 831        if (patch->is_delete < 0) {
 832                patch->is_delete = !newlines;
 833                if (!newlines)
 834                        patch->new_name = NULL;
 835        }
 836
 837        if (patch->is_new != !oldlines)
 838                return error("new file depends on old contents");
 839        if (patch->is_delete != !newlines) {
 840                if (newlines)
 841                        return error("deleted file still has contents");
 842                fprintf(stderr, "** warning: file %s becomes empty but is not deleted\n", patch->new_name);
 843        }
 844
 845        /* Parse the thing.. */
 846        line += len;
 847        size -= len;
 848        linenr++;
 849        added = deleted = 0;
 850        for (offset = len; size > 0; offset += len, size -= len, line += len, linenr++) {
 851                if (!oldlines && !newlines)
 852                        break;
 853                len = linelen(line, size);
 854                if (!len || line[len-1] != '\n')
 855                        return -1;
 856                switch (*line) {
 857                default:
 858                        return -1;
 859                case ' ':
 860                        oldlines--;
 861                        newlines--;
 862                        break;
 863                case '-':
 864                        deleted++;
 865                        oldlines--;
 866                        break;
 867                case '+':
 868                        /*
 869                         * We know len is at least two, since we have a '+' and
 870                         * we checked that the last character was a '\n' above.
 871                         * That is, an addition of an empty line would check
 872                         * the '+' here.  Sneaky...
 873                         */
 874                        if ((new_whitespace != nowarn_whitespace) &&
 875                            isspace(line[len-2])) {
 876                                whitespace_error++;
 877                                if (squelch_whitespace_errors &&
 878                                    squelch_whitespace_errors <
 879                                    whitespace_error)
 880                                        ;
 881                                else {
 882                                        fprintf(stderr, "Adds trailing whitespace.\n%s:%d:%.*s\n",
 883                                                patch_input_file,
 884                                                linenr, len-2, line+1);
 885                                }
 886                        }
 887                        added++;
 888                        newlines--;
 889                        break;
 890
 891                /* We allow "\ No newline at end of file". Depending
 892                 * on locale settings when the patch was produced we
 893                 * don't know what this line looks like. The only
 894                 * thing we do know is that it begins with "\ ".
 895                 * Checking for 12 is just for sanity check -- any
 896                 * l10n of "\ No newline..." is at least that long.
 897                 */
 898                case '\\':
 899                        if (len < 12 || memcmp(line, "\\ ", 2))
 900                                return -1;
 901                        break;
 902                }
 903        }
 904        /* If a fragment ends with an incomplete line, we failed to include
 905         * it in the above loop because we hit oldlines == newlines == 0
 906         * before seeing it.
 907         */
 908        if (12 < size && !memcmp(line, "\\ ", 2))
 909                offset += linelen(line, size);
 910
 911        patch->lines_added += added;
 912        patch->lines_deleted += deleted;
 913        return offset;
 914}
 915
 916static int parse_single_patch(char *line, unsigned long size, struct patch *patch)
 917{
 918        unsigned long offset = 0;
 919        struct fragment **fragp = &patch->fragments;
 920
 921        while (size > 4 && !memcmp(line, "@@ -", 4)) {
 922                struct fragment *fragment;
 923                int len;
 924
 925                fragment = xmalloc(sizeof(*fragment));
 926                memset(fragment, 0, sizeof(*fragment));
 927                len = parse_fragment(line, size, patch, fragment);
 928                if (len <= 0)
 929                        die("corrupt patch at line %d", linenr);
 930
 931                fragment->patch = line;
 932                fragment->size = len;
 933
 934                *fragp = fragment;
 935                fragp = &fragment->next;
 936
 937                offset += len;
 938                line += len;
 939                size -= len;
 940        }
 941        return offset;
 942}
 943
 944static inline int metadata_changes(struct patch *patch)
 945{
 946        return  patch->is_rename > 0 ||
 947                patch->is_copy > 0 ||
 948                patch->is_new > 0 ||
 949                patch->is_delete ||
 950                (patch->old_mode && patch->new_mode &&
 951                 patch->old_mode != patch->new_mode);
 952}
 953
 954static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
 955{
 956        int hdrsize, patchsize;
 957        int offset = find_header(buffer, size, &hdrsize, patch);
 958
 959        if (offset < 0)
 960                return offset;
 961
 962        patchsize = parse_single_patch(buffer + offset + hdrsize, size - offset - hdrsize, patch);
 963
 964        if (!patchsize) {
 965                static const char *binhdr[] = {
 966                        "Binary files ",
 967                        "Files ",
 968                        NULL,
 969                };
 970                int i;
 971                int hd = hdrsize + offset;
 972                unsigned long llen = linelen(buffer + hd, size - hd);
 973
 974                if (!memcmp(" differ\n", buffer + hd + llen - 8, 8))
 975                        for (i = 0; binhdr[i]; i++) {
 976                                int len = strlen(binhdr[i]);
 977                                if (len < size - hd &&
 978                                    !memcmp(binhdr[i], buffer + hd, len)) {
 979                                        patch->is_binary = 1;
 980                                        break;
 981                                }
 982                        }
 983
 984                /* Empty patch cannot be applied if:
 985                 * - it is a binary patch and we do not do binary_replace, or
 986                 * - text patch without metadata change
 987                 */
 988                if ((apply || check) &&
 989                    (patch->is_binary
 990                     ? !allow_binary_replacement
 991                     : !metadata_changes(patch)))
 992                        die("patch with only garbage at line %d", linenr);
 993        }
 994
 995        return offset + hdrsize + patchsize;
 996}
 997
 998static const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
 999static const char minuses[]= "----------------------------------------------------------------------";
1000
1001static void show_stats(struct patch *patch)
1002{
1003        const char *prefix = "";
1004        char *name = patch->new_name;
1005        char *qname = NULL;
1006        int len, max, add, del, total;
1007
1008        if (!name)
1009                name = patch->old_name;
1010
1011        if (0 < (len = quote_c_style(name, NULL, NULL, 0))) {
1012                qname = xmalloc(len + 1);
1013                quote_c_style(name, qname, NULL, 0);
1014                name = qname;
1015        }
1016
1017        /*
1018         * "scale" the filename
1019         */
1020        len = strlen(name);
1021        max = max_len;
1022        if (max > 50)
1023                max = 50;
1024        if (len > max) {
1025                char *slash;
1026                prefix = "...";
1027                max -= 3;
1028                name += len - max;
1029                slash = strchr(name, '/');
1030                if (slash)
1031                        name = slash;
1032        }
1033        len = max;
1034
1035        /*
1036         * scale the add/delete
1037         */
1038        max = max_change;
1039        if (max + len > 70)
1040                max = 70 - len;
1041
1042        add = patch->lines_added;
1043        del = patch->lines_deleted;
1044        total = add + del;
1045
1046        if (max_change > 0) {
1047                total = (total * max + max_change / 2) / max_change;
1048                add = (add * max + max_change / 2) / max_change;
1049                del = total - add;
1050        }
1051        if (patch->is_binary)
1052                printf(" %s%-*s |  Bin\n", prefix, len, name);
1053        else
1054                printf(" %s%-*s |%5d %.*s%.*s\n", prefix,
1055                       len, name, patch->lines_added + patch->lines_deleted,
1056                       add, pluses, del, minuses);
1057        if (qname)
1058                free(qname);
1059}
1060
1061static int read_old_data(struct stat *st, const char *path, void *buf, unsigned long size)
1062{
1063        int fd;
1064        unsigned long got;
1065
1066        switch (st->st_mode & S_IFMT) {
1067        case S_IFLNK:
1068                return readlink(path, buf, size);
1069        case S_IFREG:
1070                fd = open(path, O_RDONLY);
1071                if (fd < 0)
1072                        return error("unable to open %s", path);
1073                got = 0;
1074                for (;;) {
1075                        int ret = xread(fd, buf + got, size - got);
1076                        if (ret <= 0)
1077                                break;
1078                        got += ret;
1079                }
1080                close(fd);
1081                return got;
1082
1083        default:
1084                return -1;
1085        }
1086}
1087
1088static int find_offset(const char *buf, unsigned long size, const char *fragment, unsigned long fragsize, int line)
1089{
1090        int i;
1091        unsigned long start, backwards, forwards;
1092
1093        if (fragsize > size)
1094                return -1;
1095
1096        start = 0;
1097        if (line > 1) {
1098                unsigned long offset = 0;
1099                i = line-1;
1100                while (offset + fragsize <= size) {
1101                        if (buf[offset++] == '\n') {
1102                                start = offset;
1103                                if (!--i)
1104                                        break;
1105                        }
1106                }
1107        }
1108
1109        /* Exact line number? */
1110        if (!memcmp(buf + start, fragment, fragsize))
1111                return start;
1112
1113        /*
1114         * There's probably some smart way to do this, but I'll leave
1115         * that to the smart and beautiful people. I'm simple and stupid.
1116         */
1117        backwards = start;
1118        forwards = start;
1119        for (i = 0; ; i++) {
1120                unsigned long try;
1121                int n;
1122
1123                /* "backward" */
1124                if (i & 1) {
1125                        if (!backwards) {
1126                                if (forwards + fragsize > size)
1127                                        break;
1128                                continue;
1129                        }
1130                        do {
1131                                --backwards;
1132                        } while (backwards && buf[backwards-1] != '\n');
1133                        try = backwards;
1134                } else {
1135                        while (forwards + fragsize <= size) {
1136                                if (buf[forwards++] == '\n')
1137                                        break;
1138                        }
1139                        try = forwards;
1140                }
1141
1142                if (try + fragsize > size)
1143                        continue;
1144                if (memcmp(buf + try, fragment, fragsize))
1145                        continue;
1146                n = (i >> 1)+1;
1147                if (i & 1)
1148                        n = -n;
1149                return try;
1150        }
1151
1152        /*
1153         * We should start searching forward and backward.
1154         */
1155        return -1;
1156}
1157
1158struct buffer_desc {
1159        char *buffer;
1160        unsigned long size;
1161        unsigned long alloc;
1162};
1163
1164static int apply_line(char *output, const char *patch, int plen)
1165{
1166        /* plen is number of bytes to be copied from patch,
1167         * starting at patch+1 (patch[0] is '+').  Typically
1168         * patch[plen] is '\n'.
1169         */
1170        int add_nl_to_tail = 0;
1171        if ((new_whitespace == strip_whitespace) &&
1172            1 < plen && isspace(patch[plen-1])) {
1173                if (patch[plen] == '\n')
1174                        add_nl_to_tail = 1;
1175                plen--;
1176                while (0 < plen && isspace(patch[plen]))
1177                        plen--;
1178                applied_after_stripping++;
1179        }
1180        memcpy(output, patch + 1, plen);
1181        if (add_nl_to_tail)
1182                output[plen++] = '\n';
1183        return plen;
1184}
1185
1186static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag)
1187{
1188        char *buf = desc->buffer;
1189        const char *patch = frag->patch;
1190        int offset, size = frag->size;
1191        char *old = xmalloc(size);
1192        char *new = xmalloc(size);
1193        int oldsize = 0, newsize = 0;
1194
1195        while (size > 0) {
1196                int len = linelen(patch, size);
1197                int plen;
1198
1199                if (!len)
1200                        break;
1201
1202                /*
1203                 * "plen" is how much of the line we should use for
1204                 * the actual patch data. Normally we just remove the
1205                 * first character on the line, but if the line is
1206                 * followed by "\ No newline", then we also remove the
1207                 * last one (which is the newline, of course).
1208                 */
1209                plen = len-1;
1210                if (len < size && patch[len] == '\\')
1211                        plen--;
1212                switch (*patch) {
1213                case ' ':
1214                case '-':
1215                        memcpy(old + oldsize, patch + 1, plen);
1216                        oldsize += plen;
1217                        if (*patch == '-')
1218                                break;
1219                /* Fall-through for ' ' */
1220                case '+':
1221                        if (*patch != '+' || !no_add)
1222                                newsize += apply_line(new + newsize, patch,
1223                                                      plen);
1224                        break;
1225                case '@': case '\\':
1226                        /* Ignore it, we already handled it */
1227                        break;
1228                default:
1229                        return -1;
1230                }
1231                patch += len;
1232                size -= len;
1233        }
1234
1235#ifdef NO_ACCURATE_DIFF
1236        if (oldsize > 0 && old[oldsize - 1] == '\n' &&
1237                        newsize > 0 && new[newsize - 1] == '\n') {
1238                oldsize--;
1239                newsize--;
1240        }
1241#endif
1242                        
1243        offset = find_offset(buf, desc->size, old, oldsize, frag->newpos);
1244        if (offset >= 0) {
1245                int diff = newsize - oldsize;
1246                unsigned long size = desc->size + diff;
1247                unsigned long alloc = desc->alloc;
1248
1249                if (size > alloc) {
1250                        alloc = size + 8192;
1251                        desc->alloc = alloc;
1252                        buf = xrealloc(buf, alloc);
1253                        desc->buffer = buf;
1254                }
1255                desc->size = size;
1256                memmove(buf + offset + newsize, buf + offset + oldsize, size - offset - newsize);
1257                memcpy(buf + offset, new, newsize);
1258                offset = 0;
1259        }
1260
1261        free(old);
1262        free(new);
1263        return offset;
1264}
1265
1266static int apply_fragments(struct buffer_desc *desc, struct patch *patch)
1267{
1268        struct fragment *frag = patch->fragments;
1269        const char *name = patch->old_name ? patch->old_name : patch->new_name;
1270
1271        if (patch->is_binary) {
1272                unsigned char sha1[20];
1273
1274                if (!allow_binary_replacement)
1275                        return error("cannot apply binary patch to '%s' "
1276                                     "without --allow-binary-replacement",
1277                                     name);
1278
1279                /* For safety, we require patch index line to contain
1280                 * full 40-byte textual SHA1 for old and new, at least for now.
1281                 */
1282                if (strlen(patch->old_sha1_prefix) != 40 ||
1283                    strlen(patch->new_sha1_prefix) != 40 ||
1284                    get_sha1_hex(patch->old_sha1_prefix, sha1) ||
1285                    get_sha1_hex(patch->new_sha1_prefix, sha1))
1286                        return error("cannot apply binary patch to '%s' "
1287                                     "without full index line", name);
1288
1289                if (patch->old_name) {
1290                        unsigned char hdr[50];
1291                        int hdrlen;
1292
1293                        /* See if the old one matches what the patch
1294                         * applies to.
1295                         */
1296                        write_sha1_file_prepare(desc->buffer, desc->size,
1297                                                "blob", sha1, hdr, &hdrlen);
1298                        if (strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))
1299                                return error("the patch applies to '%s' (%s), "
1300                                             "which does not match the "
1301                                             "current contents.",
1302                                             name, sha1_to_hex(sha1));
1303                }
1304                else {
1305                        /* Otherwise, the old one must be empty. */
1306                        if (desc->size)
1307                                return error("the patch applies to an empty "
1308                                             "'%s' but it is not empty", name);
1309                }
1310
1311                /* For now, we do not record post-image data in the patch,
1312                 * and require the object already present in the recipient's
1313                 * object database.
1314                 */
1315                if (desc->buffer) {
1316                        free(desc->buffer);
1317                        desc->alloc = desc->size = 0;
1318                }
1319                get_sha1_hex(patch->new_sha1_prefix, sha1);
1320
1321                if (memcmp(sha1, null_sha1, 20)) {
1322                        char type[10];
1323                        unsigned long size;
1324
1325                        desc->buffer = read_sha1_file(sha1, type, &size);
1326                        if (!desc->buffer)
1327                                return error("the necessary postimage %s for "
1328                                             "'%s' does not exist",
1329                                             patch->new_sha1_prefix, name);
1330                        desc->alloc = desc->size = size;
1331                }
1332
1333                return 0;
1334        }
1335
1336        while (frag) {
1337                if (apply_one_fragment(desc, frag) < 0)
1338                        return error("patch failed: %s:%ld",
1339                                     name, frag->oldpos);
1340                frag = frag->next;
1341        }
1342        return 0;
1343}
1344
1345static int apply_data(struct patch *patch, struct stat *st)
1346{
1347        char *buf;
1348        unsigned long size, alloc;
1349        struct buffer_desc desc;
1350
1351        size = 0;
1352        alloc = 0;
1353        buf = NULL;
1354        if (patch->old_name) {
1355                size = st->st_size;
1356                alloc = size + 8192;
1357                buf = xmalloc(alloc);
1358                if (read_old_data(st, patch->old_name, buf, alloc) != size)
1359                        return error("read of %s failed", patch->old_name);
1360        }
1361
1362        desc.size = size;
1363        desc.alloc = alloc;
1364        desc.buffer = buf;
1365        if (apply_fragments(&desc, patch) < 0)
1366                return -1;
1367        patch->result = desc.buffer;
1368        patch->resultsize = desc.size;
1369
1370        if (patch->is_delete && patch->resultsize)
1371                return error("removal patch leaves file contents");
1372
1373        return 0;
1374}
1375
1376static int check_patch(struct patch *patch)
1377{
1378        struct stat st;
1379        const char *old_name = patch->old_name;
1380        const char *new_name = patch->new_name;
1381        const char *name = old_name ? old_name : new_name;
1382
1383        if (old_name) {
1384                int changed;
1385                int stat_ret = lstat(old_name, &st);
1386
1387                if (check_index) {
1388                        int pos = cache_name_pos(old_name, strlen(old_name));
1389                        if (pos < 0)
1390                                return error("%s: does not exist in index",
1391                                             old_name);
1392                        if (stat_ret < 0) {
1393                                struct checkout costate;
1394                                if (errno != ENOENT)
1395                                        return error("%s: %s", old_name,
1396                                                     strerror(errno));
1397                                /* checkout */
1398                                costate.base_dir = "";
1399                                costate.base_dir_len = 0;
1400                                costate.force = 0;
1401                                costate.quiet = 0;
1402                                costate.not_new = 0;
1403                                costate.refresh_cache = 1;
1404                                if (checkout_entry(active_cache[pos],
1405                                                   &costate) ||
1406                                    lstat(old_name, &st))
1407                                        return -1;
1408                        }
1409
1410                        changed = ce_match_stat(active_cache[pos], &st, 1);
1411                        if (changed)
1412                                return error("%s: does not match index",
1413                                             old_name);
1414                }
1415                else if (stat_ret < 0)
1416                        return error("%s: %s", old_name, strerror(errno));
1417
1418                if (patch->is_new < 0)
1419                        patch->is_new = 0;
1420                st.st_mode = ntohl(create_ce_mode(st.st_mode));
1421                if (!patch->old_mode)
1422                        patch->old_mode = st.st_mode;
1423                if ((st.st_mode ^ patch->old_mode) & S_IFMT)
1424                        return error("%s: wrong type", old_name);
1425                if (st.st_mode != patch->old_mode)
1426                        fprintf(stderr, "warning: %s has type %o, expected %o\n",
1427                                old_name, st.st_mode, patch->old_mode);
1428        }
1429
1430        if (new_name && (patch->is_new | patch->is_rename | patch->is_copy)) {
1431                if (check_index && cache_name_pos(new_name, strlen(new_name)) >= 0)
1432                        return error("%s: already exists in index", new_name);
1433                if (!lstat(new_name, &st))
1434                        return error("%s: already exists in working directory", new_name);
1435                if (errno != ENOENT)
1436                        return error("%s: %s", new_name, strerror(errno));
1437                if (!patch->new_mode) {
1438                        if (patch->is_new)
1439                                patch->new_mode = S_IFREG | 0644;
1440                        else
1441                                patch->new_mode = patch->old_mode;
1442                }
1443        }
1444
1445        if (new_name && old_name) {
1446                int same = !strcmp(old_name, new_name);
1447                if (!patch->new_mode)
1448                        patch->new_mode = patch->old_mode;
1449                if ((patch->old_mode ^ patch->new_mode) & S_IFMT)
1450                        return error("new mode (%o) of %s does not match old mode (%o)%s%s",
1451                                patch->new_mode, new_name, patch->old_mode,
1452                                same ? "" : " of ", same ? "" : old_name);
1453        }       
1454
1455        if (apply_data(patch, &st) < 0)
1456                return error("%s: patch does not apply", name);
1457        return 0;
1458}
1459
1460static int check_patch_list(struct patch *patch)
1461{
1462        int error = 0;
1463
1464        for (;patch ; patch = patch->next)
1465                error |= check_patch(patch);
1466        return error;
1467}
1468
1469static inline int is_null_sha1(const unsigned char *sha1)
1470{
1471        return !memcmp(sha1, null_sha1, 20);
1472}
1473
1474static void show_index_list(struct patch *list)
1475{
1476        struct patch *patch;
1477
1478        /* Once we start supporting the reverse patch, it may be
1479         * worth showing the new sha1 prefix, but until then...
1480         */
1481        for (patch = list; patch; patch = patch->next) {
1482                const unsigned char *sha1_ptr;
1483                unsigned char sha1[20];
1484                const char *name;
1485
1486                name = patch->old_name ? patch->old_name : patch->new_name;
1487                if (patch->is_new)
1488                        sha1_ptr = null_sha1;
1489                else if (get_sha1(patch->old_sha1_prefix, sha1))
1490                        die("sha1 information is lacking or useless (%s).",
1491                            name);
1492                else
1493                        sha1_ptr = sha1;
1494
1495                printf("%06o %s ",patch->old_mode, sha1_to_hex(sha1_ptr));
1496                if (line_termination && quote_c_style(name, NULL, NULL, 0))
1497                        quote_c_style(name, NULL, stdout, 0);
1498                else
1499                        fputs(name, stdout);
1500                putchar(line_termination);
1501        }
1502}
1503
1504static void stat_patch_list(struct patch *patch)
1505{
1506        int files, adds, dels;
1507
1508        for (files = adds = dels = 0 ; patch ; patch = patch->next) {
1509                files++;
1510                adds += patch->lines_added;
1511                dels += patch->lines_deleted;
1512                show_stats(patch);
1513        }
1514
1515        printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);
1516}
1517
1518static void numstat_patch_list(struct patch *patch)
1519{
1520        for ( ; patch; patch = patch->next) {
1521                const char *name;
1522                name = patch->old_name ? patch->old_name : patch->new_name;
1523                printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);
1524                if (line_termination && quote_c_style(name, NULL, NULL, 0))
1525                        quote_c_style(name, NULL, stdout, 0);
1526                else
1527                        fputs(name, stdout);
1528                putchar('\n');
1529        }
1530}
1531
1532static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)
1533{
1534        if (mode)
1535                printf(" %s mode %06o %s\n", newdelete, mode, name);
1536        else
1537                printf(" %s %s\n", newdelete, name);
1538}
1539
1540static void show_mode_change(struct patch *p, int show_name)
1541{
1542        if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {
1543                if (show_name)
1544                        printf(" mode change %06o => %06o %s\n",
1545                               p->old_mode, p->new_mode, p->new_name);
1546                else
1547                        printf(" mode change %06o => %06o\n",
1548                               p->old_mode, p->new_mode);
1549        }
1550}
1551
1552static void show_rename_copy(struct patch *p)
1553{
1554        const char *renamecopy = p->is_rename ? "rename" : "copy";
1555        const char *old, *new;
1556
1557        /* Find common prefix */
1558        old = p->old_name;
1559        new = p->new_name;
1560        while (1) {
1561                const char *slash_old, *slash_new;
1562                slash_old = strchr(old, '/');
1563                slash_new = strchr(new, '/');
1564                if (!slash_old ||
1565                    !slash_new ||
1566                    slash_old - old != slash_new - new ||
1567                    memcmp(old, new, slash_new - new))
1568                        break;
1569                old = slash_old + 1;
1570                new = slash_new + 1;
1571        }
1572        /* p->old_name thru old is the common prefix, and old and new
1573         * through the end of names are renames
1574         */
1575        if (old != p->old_name)
1576                printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,
1577                       (int)(old - p->old_name), p->old_name,
1578                       old, new, p->score);
1579        else
1580                printf(" %s %s => %s (%d%%)\n", renamecopy,
1581                       p->old_name, p->new_name, p->score);
1582        show_mode_change(p, 0);
1583}
1584
1585static void summary_patch_list(struct patch *patch)
1586{
1587        struct patch *p;
1588
1589        for (p = patch; p; p = p->next) {
1590                if (p->is_new)
1591                        show_file_mode_name("create", p->new_mode, p->new_name);
1592                else if (p->is_delete)
1593                        show_file_mode_name("delete", p->old_mode, p->old_name);
1594                else {
1595                        if (p->is_rename || p->is_copy)
1596                                show_rename_copy(p);
1597                        else {
1598                                if (p->score) {
1599                                        printf(" rewrite %s (%d%%)\n",
1600                                               p->new_name, p->score);
1601                                        show_mode_change(p, 0);
1602                                }
1603                                else
1604                                        show_mode_change(p, 1);
1605                        }
1606                }
1607        }
1608}
1609
1610static void patch_stats(struct patch *patch)
1611{
1612        int lines = patch->lines_added + patch->lines_deleted;
1613
1614        if (lines > max_change)
1615                max_change = lines;
1616        if (patch->old_name) {
1617                int len = quote_c_style(patch->old_name, NULL, NULL, 0);
1618                if (!len)
1619                        len = strlen(patch->old_name);
1620                if (len > max_len)
1621                        max_len = len;
1622        }
1623        if (patch->new_name) {
1624                int len = quote_c_style(patch->new_name, NULL, NULL, 0);
1625                if (!len)
1626                        len = strlen(patch->new_name);
1627                if (len > max_len)
1628                        max_len = len;
1629        }
1630}
1631
1632static void remove_file(struct patch *patch)
1633{
1634        if (write_index) {
1635                if (remove_file_from_cache(patch->old_name) < 0)
1636                        die("unable to remove %s from index", patch->old_name);
1637        }
1638        unlink(patch->old_name);
1639}
1640
1641static void add_index_file(const char *path, unsigned mode, void *buf, unsigned long size)
1642{
1643        struct stat st;
1644        struct cache_entry *ce;
1645        int namelen = strlen(path);
1646        unsigned ce_size = cache_entry_size(namelen);
1647
1648        if (!write_index)
1649                return;
1650
1651        ce = xmalloc(ce_size);
1652        memset(ce, 0, ce_size);
1653        memcpy(ce->name, path, namelen);
1654        ce->ce_mode = create_ce_mode(mode);
1655        ce->ce_flags = htons(namelen);
1656        if (lstat(path, &st) < 0)
1657                die("unable to stat newly created file %s", path);
1658        fill_stat_cache_info(ce, &st);
1659        if (write_sha1_file(buf, size, "blob", ce->sha1) < 0)
1660                die("unable to create backing store for newly created file %s", path);
1661        if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
1662                die("unable to add cache entry for %s", path);
1663}
1664
1665static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)
1666{
1667        int fd;
1668
1669        if (S_ISLNK(mode))
1670                return symlink(buf, path);
1671        fd = open(path, O_CREAT | O_EXCL | O_WRONLY, (mode & 0100) ? 0777 : 0666);
1672        if (fd < 0)
1673                return -1;
1674        while (size) {
1675                int written = xwrite(fd, buf, size);
1676                if (written < 0)
1677                        die("writing file %s: %s", path, strerror(errno));
1678                if (!written)
1679                        die("out of space writing file %s", path);
1680                buf += written;
1681                size -= written;
1682        }
1683        if (close(fd) < 0)
1684                die("closing file %s: %s", path, strerror(errno));
1685        return 0;
1686}
1687
1688/*
1689 * We optimistically assume that the directories exist,
1690 * which is true 99% of the time anyway. If they don't,
1691 * we create them and try again.
1692 */
1693static void create_one_file(char *path, unsigned mode, const char *buf, unsigned long size)
1694{
1695        if (!try_create_file(path, mode, buf, size))
1696                return;
1697
1698        if (errno == ENOENT) {
1699                if (safe_create_leading_directories(path))
1700                        return;
1701                if (!try_create_file(path, mode, buf, size))
1702                        return;
1703        }
1704
1705        if (errno == EEXIST) {
1706                unsigned int nr = getpid();
1707
1708                for (;;) {
1709                        const char *newpath;
1710                        newpath = mkpath("%s~%u", path, nr);
1711                        if (!try_create_file(newpath, mode, buf, size)) {
1712                                if (!rename(newpath, path))
1713                                        return;
1714                                unlink(newpath);
1715                                break;
1716                        }
1717                        if (errno != EEXIST)
1718                                break;
1719                        ++nr;
1720                }
1721        }
1722        die("unable to write file %s mode %o", path, mode);
1723}
1724
1725static void create_file(struct patch *patch)
1726{
1727        char *path = patch->new_name;
1728        unsigned mode = patch->new_mode;
1729        unsigned long size = patch->resultsize;
1730        char *buf = patch->result;
1731
1732        if (!mode)
1733                mode = S_IFREG | 0644;
1734        create_one_file(path, mode, buf, size); 
1735        add_index_file(path, mode, buf, size);
1736}
1737
1738static void write_out_one_result(struct patch *patch)
1739{
1740        if (patch->is_delete > 0) {
1741                remove_file(patch);
1742                return;
1743        }
1744        if (patch->is_new > 0 || patch->is_copy) {
1745                create_file(patch);
1746                return;
1747        }
1748        /*
1749         * Rename or modification boils down to the same
1750         * thing: remove the old, write the new
1751         */
1752        remove_file(patch);
1753        create_file(patch);
1754}
1755
1756static void write_out_results(struct patch *list, int skipped_patch)
1757{
1758        if (!list && !skipped_patch)
1759                die("No changes");
1760
1761        while (list) {
1762                write_out_one_result(list);
1763                list = list->next;
1764        }
1765}
1766
1767static struct cache_file cache_file;
1768
1769static struct excludes {
1770        struct excludes *next;
1771        const char *path;
1772} *excludes;
1773
1774static int use_patch(struct patch *p)
1775{
1776        const char *pathname = p->new_name ? p->new_name : p->old_name;
1777        struct excludes *x = excludes;
1778        while (x) {
1779                if (fnmatch(x->path, pathname, 0) == 0)
1780                        return 0;
1781                x = x->next;
1782        }
1783        if (0 < prefix_length) {
1784                int pathlen = strlen(pathname);
1785                if (pathlen <= prefix_length ||
1786                    memcmp(prefix, pathname, prefix_length))
1787                        return 0;
1788        }
1789        return 1;
1790}
1791
1792static int apply_patch(int fd, const char *filename)
1793{
1794        int newfd;
1795        unsigned long offset, size;
1796        char *buffer = read_patch_file(fd, &size);
1797        struct patch *list = NULL, **listp = &list;
1798        int skipped_patch = 0;
1799
1800        patch_input_file = filename;
1801        if (!buffer)
1802                return -1;
1803        offset = 0;
1804        while (size > 0) {
1805                struct patch *patch;
1806                int nr;
1807
1808                patch = xmalloc(sizeof(*patch));
1809                memset(patch, 0, sizeof(*patch));
1810                nr = parse_chunk(buffer + offset, size, patch);
1811                if (nr < 0)
1812                        break;
1813                if (use_patch(patch)) {
1814                        patch_stats(patch);
1815                        *listp = patch;
1816                        listp = &patch->next;
1817                } else {
1818                        /* perhaps free it a bit better? */
1819                        free(patch);
1820                        skipped_patch++;
1821                }
1822                offset += nr;
1823                size -= nr;
1824        }
1825
1826        newfd = -1;
1827        if (whitespace_error && (new_whitespace == error_on_whitespace))
1828                apply = 0;
1829
1830        write_index = check_index && apply;
1831        if (write_index)
1832                newfd = hold_index_file_for_update(&cache_file, get_index_file());
1833        if (check_index) {
1834                if (read_cache() < 0)
1835                        die("unable to read index file");
1836        }
1837
1838        if ((check || apply) && check_patch_list(list) < 0)
1839                exit(1);
1840
1841        if (apply)
1842                write_out_results(list, skipped_patch);
1843
1844        if (write_index) {
1845                if (write_cache(newfd, active_cache, active_nr) ||
1846                    commit_index_file(&cache_file))
1847                        die("Unable to write new cachefile");
1848        }
1849
1850        if (show_index_info)
1851                show_index_list(list);
1852
1853        if (diffstat)
1854                stat_patch_list(list);
1855
1856        if (numstat)
1857                numstat_patch_list(list);
1858
1859        if (summary)
1860                summary_patch_list(list);
1861
1862        free(buffer);
1863        return 0;
1864}
1865
1866static int git_apply_config(const char *var, const char *value)
1867{
1868        if (!strcmp(var, "apply.whitespace")) {
1869                apply_default_whitespace = strdup(value);
1870                return 0;
1871        }
1872        return git_default_config(var, value);
1873}
1874
1875
1876int main(int argc, char **argv)
1877{
1878        int i;
1879        int read_stdin = 1;
1880        const char *whitespace_option = NULL;
1881
1882        for (i = 1; i < argc; i++) {
1883                const char *arg = argv[i];
1884                int fd;
1885
1886                if (!strcmp(arg, "-")) {
1887                        apply_patch(0, "<stdin>");
1888                        read_stdin = 0;
1889                        continue;
1890                }
1891                if (!strncmp(arg, "--exclude=", 10)) {
1892                        struct excludes *x = xmalloc(sizeof(*x));
1893                        x->path = arg + 10;
1894                        x->next = excludes;
1895                        excludes = x;
1896                        continue;
1897                }
1898                if (!strncmp(arg, "-p", 2)) {
1899                        p_value = atoi(arg + 2);
1900                        continue;
1901                }
1902                if (!strcmp(arg, "--no-add")) {
1903                        no_add = 1;
1904                        continue;
1905                }
1906                if (!strcmp(arg, "--stat")) {
1907                        apply = 0;
1908                        diffstat = 1;
1909                        continue;
1910                }
1911                if (!strcmp(arg, "--allow-binary-replacement")) {
1912                        allow_binary_replacement = 1;
1913                        continue;
1914                }
1915                if (!strcmp(arg, "--numstat")) {
1916                        apply = 0;
1917                        numstat = 1;
1918                        continue;
1919                }
1920                if (!strcmp(arg, "--summary")) {
1921                        apply = 0;
1922                        summary = 1;
1923                        continue;
1924                }
1925                if (!strcmp(arg, "--check")) {
1926                        apply = 0;
1927                        check = 1;
1928                        continue;
1929                }
1930                if (!strcmp(arg, "--index")) {
1931                        check_index = 1;
1932                        continue;
1933                }
1934                if (!strcmp(arg, "--apply")) {
1935                        apply = 1;
1936                        continue;
1937                }
1938                if (!strcmp(arg, "--index-info")) {
1939                        apply = 0;
1940                        show_index_info = 1;
1941                        continue;
1942                }
1943                if (!strcmp(arg, "-z")) {
1944                        line_termination = 0;
1945                        continue;
1946                }
1947                if (!strncmp(arg, "--whitespace=", 13)) {
1948                        whitespace_option = arg + 13;
1949                        parse_whitespace_option(arg + 13);
1950                        continue;
1951                }
1952
1953                if (check_index && prefix_length < 0) {
1954                        prefix = setup_git_directory();
1955                        prefix_length = prefix ? strlen(prefix) : 0;
1956                        git_config(git_apply_config);
1957                        if (!whitespace_option && apply_default_whitespace)
1958                                parse_whitespace_option(apply_default_whitespace);
1959                }
1960                if (0 < prefix_length)
1961                        arg = prefix_filename(prefix, prefix_length, arg);
1962
1963                fd = open(arg, O_RDONLY);
1964                if (fd < 0)
1965                        usage(apply_usage);
1966                read_stdin = 0;
1967                set_default_whitespace_mode(whitespace_option);
1968                apply_patch(fd, arg);
1969                close(fd);
1970        }
1971        set_default_whitespace_mode(whitespace_option);
1972        if (read_stdin)
1973                apply_patch(0, "<stdin>");
1974        if (whitespace_error) {
1975                if (squelch_whitespace_errors &&
1976                    squelch_whitespace_errors < whitespace_error) {
1977                        int squelched =
1978                                whitespace_error - squelch_whitespace_errors;
1979                        fprintf(stderr, "warning: squelched %d whitespace error%s\n",
1980                                squelched,
1981                                squelched == 1 ? "" : "s");
1982                }
1983                if (new_whitespace == error_on_whitespace)
1984                        die("%d line%s add%s trailing whitespaces.",
1985                            whitespace_error,
1986                            whitespace_error == 1 ? "" : "s",
1987                            whitespace_error == 1 ? "s" : "");
1988                if (applied_after_stripping)
1989                        fprintf(stderr, "warning: %d line%s applied after"
1990                                " stripping trailing whitespaces.\n",
1991                                applied_after_stripping,
1992                                applied_after_stripping == 1 ? "" : "s");
1993                else if (whitespace_error)
1994                        fprintf(stderr, "warning: %d line%s add%s trailing"
1995                                " whitespaces.\n",
1996                                whitespace_error,
1997                                whitespace_error == 1 ? "" : "s",
1998                                whitespace_error == 1 ? "s" : "");
1999        }
2000        return 0;
2001}