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