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