apply.c

   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 //
  19 static const char *prefix;
  20 static int prefix_length = -1;
  21
  22 static int p_value = 1;
  23 static int allow_binary_replacement = 0;
  24 static int check_index = 0;
  25 static int write_index = 0;
  26 static int diffstat = 0;
  27 static int numstat = 0;
  28 static int summary = 0;
  29 static int check = 0;
  30 static int apply = 1;
  31 static int no_add = 0;
  32 static int show_index_info = 0;
  33 static int line_termination = '\n';
  34 static const char apply_usage[] =
  35 "git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [-z] [-pNUM] <patch>...";
  36
  37 static enum whitespace_eol {
  38         nowarn,
  39         warn_on_whitespace,
  40         error_on_whitespace,
  41         strip_and_apply,
  42 } new_whitespace = nowarn;
  43 static int whitespace_error = 0;
  44 static int squelch_whitespace_errors = 5;
  45 static int applied_after_stripping = 0;
  46 static 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  */
  53 static 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  */
  60 static int linenr = 1;
  61
  62 struct fragment {
  63         unsigned long oldpos, oldlines;
  64         unsigned long newpos, newlines;
  65         const char *patch;
  66         int size;
  67         struct fragment *next;
  68 };
  69
  70 struct 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
  87 static 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
 119 static 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
 130 static 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
 138 static 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
 148 static 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  */
 230 static 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
 255 static 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  */
 269 static 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
 296 static 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
 302 static 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
 308 static int gitdiff_oldmode(const char *line, struct patch *patch)
 309 {
 310         patch->old_mode = strtoul(line, NULL, 8);
 311         return 0;
 312 }
 313
 314 static int gitdiff_newmode(const char *line, struct patch *patch)
 315 {
 316         patch->new_mode = strtoul(line, NULL, 8);
 317         return 0;
 318 }
 319
 320 static 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
 327 static 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
 334 static 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
 341 static 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
 348 static 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
 355 static 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
 362 static 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
 369 static 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
 376 static 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  */
 412 static int gitdiff_unrecognized(const char *line, struct patch *patch)
 413 {
 414         return -1;
 415 }
 416
 417 static 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  */
 436 static 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 */
 568 static 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
 629 static 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
 639 static 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  */
 681 static 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
 695 static 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  */
 775 static 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
 877 static 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
 905 static 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
 915 static 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
 959 static const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
 960 static const char minuses[]= "----------------------------------------------------------------------";
 961
 962 static 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
1022 static 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
1049 static 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
1119 struct buffer_desc {
1120         char *buffer;
1121         unsigned long size;
1122         unsigned long alloc;
1123 };
1124
1125 static 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
1147 static 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
1219 static 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
1298 static 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
1329 static 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
1413 static 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
1422 static inline int is_null_sha1(const unsigned char *sha1)
1423 {
1424         return !memcmp(sha1, null_sha1, 20);
1425 }
1426
1427 static 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
1457 static 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
1471 static 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
1485 static 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
1493 static 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
1505 static 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
1538 static 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
1563 static 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
1585 static 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
1594 static 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
1618 static 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  */
1646 static 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
1678 static 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
1691 static 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
1709 static 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
1720 static struct cache_file cache_file;
1721
1722 static struct excludes {
1723         struct excludes *next;
1724         const char *path;
1725 } *excludes;
1726
1727 static 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
1745 static 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
1819 int 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 }