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