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 "cache.h" 10#include "cache-tree.h" 11#include "quote.h" 12#include "blob.h" 13#include "delta.h" 14#include "builtin.h" 15#include "string-list.h" 16#include "dir.h" 17#include "parse-options.h" 18 19/* 20 * --check turns on checking that the working tree matches the 21 * files that are being modified, but doesn't apply the patch 22 * --stat does just a diffstat, and doesn't actually apply 23 * --numstat does numeric diffstat, and doesn't actually apply 24 * --index-info shows the old and new index info for paths if available. 25 * --index updates the cache as well. 26 * --cached updates only the cache without ever touching the working tree. 27 */ 28static const char *prefix; 29static int prefix_length = -1; 30static int newfd = -1; 31 32static int unidiff_zero; 33static int p_value = 1; 34static int p_value_known; 35static int check_index; 36static int update_index; 37static int cached; 38static int diffstat; 39static int numstat; 40static int summary; 41static int check; 42static int apply = 1; 43static int apply_in_reverse; 44static int apply_with_reject; 45static int apply_verbosely; 46static int no_add; 47static const char *fake_ancestor; 48static int line_termination = '\n'; 49static unsigned int p_context = UINT_MAX; 50static const char * const apply_usage[] = { 51 "git apply [options] [<patch>...]", 52 NULL 53}; 54 55static enum ws_error_action { 56 nowarn_ws_error, 57 warn_on_ws_error, 58 die_on_ws_error, 59 correct_ws_error, 60} ws_error_action = warn_on_ws_error; 61static int whitespace_error; 62static int squelch_whitespace_errors = 5; 63static int applied_after_fixing_ws; 64static const char *patch_input_file; 65static const char *root; 66static int root_len; 67static int read_stdin = 1; 68static int options; 69 70static void parse_whitespace_option(const char *option) 71{ 72 if (!option) { 73 ws_error_action = warn_on_ws_error; 74 return; 75 } 76 if (!strcmp(option, "warn")) { 77 ws_error_action = warn_on_ws_error; 78 return; 79 } 80 if (!strcmp(option, "nowarn")) { 81 ws_error_action = nowarn_ws_error; 82 return; 83 } 84 if (!strcmp(option, "error")) { 85 ws_error_action = die_on_ws_error; 86 return; 87 } 88 if (!strcmp(option, "error-all")) { 89 ws_error_action = die_on_ws_error; 90 squelch_whitespace_errors = 0; 91 return; 92 } 93 if (!strcmp(option, "strip") || !strcmp(option, "fix")) { 94 ws_error_action = correct_ws_error; 95 return; 96 } 97 die("unrecognized whitespace option '%s'", option); 98} 99 100static void set_default_whitespace_mode(const char *whitespace_option) 101{ 102 if (!whitespace_option && !apply_default_whitespace) 103 ws_error_action = (apply ? warn_on_ws_error : nowarn_ws_error); 104} 105 106/* 107 * For "diff-stat" like behaviour, we keep track of the biggest change 108 * we've seen, and the longest filename. That allows us to do simple 109 * scaling. 110 */ 111static int max_change, max_len; 112 113/* 114 * Various "current state", notably line numbers and what 115 * file (and how) we're patching right now.. The "is_xxxx" 116 * things are flags, where -1 means "don't know yet". 117 */ 118static int linenr = 1; 119 120/* 121 * This represents one "hunk" from a patch, starting with 122 * "@@ -oldpos,oldlines +newpos,newlines @@" marker. The 123 * patch text is pointed at by patch, and its byte length 124 * is stored in size. leading and trailing are the number 125 * of context lines. 126 */ 127struct fragment { 128 unsigned long leading, trailing; 129 unsigned long oldpos, oldlines; 130 unsigned long newpos, newlines; 131 const char *patch; 132 int size; 133 int rejected; 134 struct fragment *next; 135}; 136 137/* 138 * When dealing with a binary patch, we reuse "leading" field 139 * to store the type of the binary hunk, either deflated "delta" 140 * or deflated "literal". 141 */ 142#define binary_patch_method leading 143#define BINARY_DELTA_DEFLATED 1 144#define BINARY_LITERAL_DEFLATED 2 145 146/* 147 * This represents a "patch" to a file, both metainfo changes 148 * such as creation/deletion, filemode and content changes represented 149 * as a series of fragments. 150 */ 151struct patch { 152 char *new_name, *old_name, *def_name; 153 unsigned int old_mode, new_mode; 154 int is_new, is_delete; /* -1 = unknown, 0 = false, 1 = true */ 155 int rejected; 156 unsigned ws_rule; 157 unsigned long deflate_origlen; 158 int lines_added, lines_deleted; 159 int score; 160 unsigned int is_toplevel_relative:1; 161 unsigned int inaccurate_eof:1; 162 unsigned int is_binary:1; 163 unsigned int is_copy:1; 164 unsigned int is_rename:1; 165 unsigned int recount:1; 166 struct fragment *fragments; 167 char *result; 168 size_t resultsize; 169 char old_sha1_prefix[41]; 170 char new_sha1_prefix[41]; 171 struct patch *next; 172}; 173 174/* 175 * A line in a file, len-bytes long (includes the terminating LF, 176 * except for an incomplete line at the end if the file ends with 177 * one), and its contents hashes to 'hash'. 178 */ 179struct line { 180 size_t len; 181 unsigned hash : 24; 182 unsigned flag : 8; 183#define LINE_COMMON 1 184}; 185 186/* 187 * This represents a "file", which is an array of "lines". 188 */ 189struct image { 190 char *buf; 191 size_t len; 192 size_t nr; 193 size_t alloc; 194 struct line *line_allocated; 195 struct line *line; 196}; 197 198/* 199 * Records filenames that have been touched, in order to handle 200 * the case where more than one patches touch the same file. 201 */ 202 203static struct string_list fn_table; 204 205static uint32_t hash_line(const char *cp, size_t len) 206{ 207 size_t i; 208 uint32_t h; 209 for (i = 0, h = 0; i < len; i++) { 210 if (!isspace(cp[i])) { 211 h = h * 3 + (cp[i] & 0xff); 212 } 213 } 214 return h; 215} 216 217static void add_line_info(struct image *img, const char *bol, size_t len, unsigned flag) 218{ 219 ALLOC_GROW(img->line_allocated, img->nr + 1, img->alloc); 220 img->line_allocated[img->nr].len = len; 221 img->line_allocated[img->nr].hash = hash_line(bol, len); 222 img->line_allocated[img->nr].flag = flag; 223 img->nr++; 224} 225 226static void prepare_image(struct image *image, char *buf, size_t len, 227 int prepare_linetable) 228{ 229 const char *cp, *ep; 230 231 memset(image, 0, sizeof(*image)); 232 image->buf = buf; 233 image->len = len; 234 235 if (!prepare_linetable) 236 return; 237 238 ep = image->buf + image->len; 239 cp = image->buf; 240 while (cp < ep) { 241 const char *next; 242 for (next = cp; next < ep && *next != '\n'; next++) 243 ; 244 if (next < ep) 245 next++; 246 add_line_info(image, cp, next - cp, 0); 247 cp = next; 248 } 249 image->line = image->line_allocated; 250} 251 252static void clear_image(struct image *image) 253{ 254 free(image->buf); 255 image->buf = NULL; 256 image->len = 0; 257} 258 259static void say_patch_name(FILE *output, const char *pre, 260 struct patch *patch, const char *post) 261{ 262 fputs(pre, output); 263 if (patch->old_name && patch->new_name && 264 strcmp(patch->old_name, patch->new_name)) { 265 quote_c_style(patch->old_name, NULL, output, 0); 266 fputs(" => ", output); 267 quote_c_style(patch->new_name, NULL, output, 0); 268 } else { 269 const char *n = patch->new_name; 270 if (!n) 271 n = patch->old_name; 272 quote_c_style(n, NULL, output, 0); 273 } 274 fputs(post, output); 275} 276 277#define CHUNKSIZE (8192) 278#define SLOP (16) 279 280static void read_patch_file(struct strbuf *sb, int fd) 281{ 282 if (strbuf_read(sb, fd, 0) < 0) 283 die_errno("git apply: failed to read"); 284 285 /* 286 * Make sure that we have some slop in the buffer 287 * so that we can do speculative "memcmp" etc, and 288 * see to it that it is NUL-filled. 289 */ 290 strbuf_grow(sb, SLOP); 291 memset(sb->buf + sb->len, 0, SLOP); 292} 293 294static unsigned long linelen(const char *buffer, unsigned long size) 295{ 296 unsigned long len = 0; 297 while (size--) { 298 len++; 299 if (*buffer++ == '\n') 300 break; 301 } 302 return len; 303} 304 305static int is_dev_null(const char *str) 306{ 307 return !memcmp("/dev/null", str, 9) && isspace(str[9]); 308} 309 310#define TERM_SPACE 1 311#define TERM_TAB 2 312 313static int name_terminate(const char *name, int namelen, int c, int terminate) 314{ 315 if (c == ' ' && !(terminate & TERM_SPACE)) 316 return 0; 317 if (c == '\t' && !(terminate & TERM_TAB)) 318 return 0; 319 320 return 1; 321} 322 323/* remove double slashes to make --index work with such filenames */ 324static char *squash_slash(char *name) 325{ 326 int i = 0, j = 0; 327 328 while (name[i]) { 329 if ((name[j++] = name[i++]) == '/') 330 while (name[i] == '/') 331 i++; 332 } 333 name[j] = '\0'; 334 return name; 335} 336 337static char *find_name(const char *line, char *def, int p_value, int terminate) 338{ 339 int len; 340 const char *start = line; 341 342 if (*line == '"') { 343 struct strbuf name = STRBUF_INIT; 344 345 /* 346 * Proposed "new-style" GNU patch/diff format; see 347 * http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2 348 */ 349 if (!unquote_c_style(&name, line, NULL)) { 350 char *cp; 351 352 for (cp = name.buf; p_value; p_value--) { 353 cp = strchr(cp, '/'); 354 if (!cp) 355 break; 356 cp++; 357 } 358 if (cp) { 359 /* name can later be freed, so we need 360 * to memmove, not just return cp 361 */ 362 strbuf_remove(&name, 0, cp - name.buf); 363 free(def); 364 if (root) 365 strbuf_insert(&name, 0, root, root_len); 366 return squash_slash(strbuf_detach(&name, NULL)); 367 } 368 } 369 strbuf_release(&name); 370 } 371 372 for (;;) { 373 char c = *line; 374 375 if (isspace(c)) { 376 if (c == '\n') 377 break; 378 if (name_terminate(start, line-start, c, terminate)) 379 break; 380 } 381 line++; 382 if (c == '/' && !--p_value) 383 start = line; 384 } 385 if (!start) 386 return squash_slash(def); 387 len = line - start; 388 if (!len) 389 return squash_slash(def); 390 391 /* 392 * Generally we prefer the shorter name, especially 393 * if the other one is just a variation of that with 394 * something else tacked on to the end (ie "file.orig" 395 * or "file~"). 396 */ 397 if (def) { 398 int deflen = strlen(def); 399 if (deflen < len && !strncmp(start, def, deflen)) 400 return squash_slash(def); 401 free(def); 402 } 403 404 if (root) { 405 char *ret = xmalloc(root_len + len + 1); 406 strcpy(ret, root); 407 memcpy(ret + root_len, start, len); 408 ret[root_len + len] = '\0'; 409 return squash_slash(ret); 410 } 411 412 return squash_slash(xmemdupz(start, len)); 413} 414 415static int count_slashes(const char *cp) 416{ 417 int cnt = 0; 418 char ch; 419 420 while ((ch = *cp++)) 421 if (ch == '/') 422 cnt++; 423 return cnt; 424} 425 426/* 427 * Given the string after "--- " or "+++ ", guess the appropriate 428 * p_value for the given patch. 429 */ 430static int guess_p_value(const char *nameline) 431{ 432 char *name, *cp; 433 int val = -1; 434 435 if (is_dev_null(nameline)) 436 return -1; 437 name = find_name(nameline, NULL, 0, TERM_SPACE | TERM_TAB); 438 if (!name) 439 return -1; 440 cp = strchr(name, '/'); 441 if (!cp) 442 val = 0; 443 else if (prefix) { 444 /* 445 * Does it begin with "a/$our-prefix" and such? Then this is 446 * very likely to apply to our directory. 447 */ 448 if (!strncmp(name, prefix, prefix_length)) 449 val = count_slashes(prefix); 450 else { 451 cp++; 452 if (!strncmp(cp, prefix, prefix_length)) 453 val = count_slashes(prefix) + 1; 454 } 455 } 456 free(name); 457 return val; 458} 459 460/* 461 * Does the ---/+++ line has the POSIX timestamp after the last HT? 462 * GNU diff puts epoch there to signal a creation/deletion event. Is 463 * this such a timestamp? 464 */ 465static int has_epoch_timestamp(const char *nameline) 466{ 467 /* 468 * We are only interested in epoch timestamp; any non-zero 469 * fraction cannot be one, hence "(\.0+)?" in the regexp below. 470 * For the same reason, the date must be either 1969-12-31 or 471 * 1970-01-01, and the seconds part must be "00". 472 */ 473 const char stamp_regexp[] = 474 "^(1969-12-31|1970-01-01)" 475 " " 476 "[0-2][0-9]:[0-5][0-9]:00(\\.0+)?" 477 " " 478 "([-+][0-2][0-9][0-5][0-9])\n"; 479 const char *timestamp = NULL, *cp; 480 static regex_t *stamp; 481 regmatch_t m[10]; 482 int zoneoffset; 483 int hourminute; 484 int status; 485 486 for (cp = nameline; *cp != '\n'; cp++) { 487 if (*cp == '\t') 488 timestamp = cp + 1; 489 } 490 if (!timestamp) 491 return 0; 492 if (!stamp) { 493 stamp = xmalloc(sizeof(*stamp)); 494 if (regcomp(stamp, stamp_regexp, REG_EXTENDED)) { 495 warning("Cannot prepare timestamp regexp %s", 496 stamp_regexp); 497 return 0; 498 } 499 } 500 501 status = regexec(stamp, timestamp, ARRAY_SIZE(m), m, 0); 502 if (status) { 503 if (status != REG_NOMATCH) 504 warning("regexec returned %d for input: %s", 505 status, timestamp); 506 return 0; 507 } 508 509 zoneoffset = strtol(timestamp + m[3].rm_so + 1, NULL, 10); 510 zoneoffset = (zoneoffset / 100) * 60 + (zoneoffset % 100); 511 if (timestamp[m[3].rm_so] == '-') 512 zoneoffset = -zoneoffset; 513 514 /* 515 * YYYY-MM-DD hh:mm:ss must be from either 1969-12-31 516 * (west of GMT) or 1970-01-01 (east of GMT) 517 */ 518 if ((zoneoffset < 0 && memcmp(timestamp, "1969-12-31", 10)) || 519 (0 <= zoneoffset && memcmp(timestamp, "1970-01-01", 10))) 520 return 0; 521 522 hourminute = (strtol(timestamp + 11, NULL, 10) * 60 + 523 strtol(timestamp + 14, NULL, 10) - 524 zoneoffset); 525 526 return ((zoneoffset < 0 && hourminute == 1440) || 527 (0 <= zoneoffset && !hourminute)); 528} 529 530/* 531 * Get the name etc info from the ---/+++ lines of a traditional patch header 532 * 533 * FIXME! The end-of-filename heuristics are kind of screwy. For existing 534 * files, we can happily check the index for a match, but for creating a 535 * new file we should try to match whatever "patch" does. I have no idea. 536 */ 537static void parse_traditional_patch(const char *first, const char *second, struct patch *patch) 538{ 539 char *name; 540 541 first += 4; /* skip "--- " */ 542 second += 4; /* skip "+++ " */ 543 if (!p_value_known) { 544 int p, q; 545 p = guess_p_value(first); 546 q = guess_p_value(second); 547 if (p < 0) p = q; 548 if (0 <= p && p == q) { 549 p_value = p; 550 p_value_known = 1; 551 } 552 } 553 if (is_dev_null(first)) { 554 patch->is_new = 1; 555 patch->is_delete = 0; 556 name = find_name(second, NULL, p_value, TERM_SPACE | TERM_TAB); 557 patch->new_name = name; 558 } else if (is_dev_null(second)) { 559 patch->is_new = 0; 560 patch->is_delete = 1; 561 name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB); 562 patch->old_name = name; 563 } else { 564 name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB); 565 name = find_name(second, name, p_value, TERM_SPACE | TERM_TAB); 566 if (has_epoch_timestamp(first)) { 567 patch->is_new = 1; 568 patch->is_delete = 0; 569 patch->new_name = name; 570 } else if (has_epoch_timestamp(second)) { 571 patch->is_new = 0; 572 patch->is_delete = 1; 573 patch->old_name = name; 574 } else { 575 patch->old_name = patch->new_name = name; 576 } 577 } 578 if (!name) 579 die("unable to find filename in patch at line %d", linenr); 580} 581 582static int gitdiff_hdrend(const char *line, struct patch *patch) 583{ 584 return -1; 585} 586 587/* 588 * We're anal about diff header consistency, to make 589 * sure that we don't end up having strange ambiguous 590 * patches floating around. 591 * 592 * As a result, gitdiff_{old|new}name() will check 593 * their names against any previous information, just 594 * to make sure.. 595 */ 596static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, const char *oldnew) 597{ 598 if (!orig_name && !isnull) 599 return find_name(line, NULL, p_value, TERM_TAB); 600 601 if (orig_name) { 602 int len; 603 const char *name; 604 char *another; 605 name = orig_name; 606 len = strlen(name); 607 if (isnull) 608 die("git apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr); 609 another = find_name(line, NULL, p_value, TERM_TAB); 610 if (!another || memcmp(another, name, len)) 611 die("git apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr); 612 free(another); 613 return orig_name; 614 } 615 else { 616 /* expect "/dev/null" */ 617 if (memcmp("/dev/null", line, 9) || line[9] != '\n') 618 die("git apply: bad git-diff - expected /dev/null on line %d", linenr); 619 return NULL; 620 } 621} 622 623static int gitdiff_oldname(const char *line, struct patch *patch) 624{ 625 patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name, "old"); 626 return 0; 627} 628 629static int gitdiff_newname(const char *line, struct patch *patch) 630{ 631 patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name, "new"); 632 return 0; 633} 634 635static int gitdiff_oldmode(const char *line, struct patch *patch) 636{ 637 patch->old_mode = strtoul(line, NULL, 8); 638 return 0; 639} 640 641static int gitdiff_newmode(const char *line, struct patch *patch) 642{ 643 patch->new_mode = strtoul(line, NULL, 8); 644 return 0; 645} 646 647static int gitdiff_delete(const char *line, struct patch *patch) 648{ 649 patch->is_delete = 1; 650 patch->old_name = patch->def_name; 651 return gitdiff_oldmode(line, patch); 652} 653 654static int gitdiff_newfile(const char *line, struct patch *patch) 655{ 656 patch->is_new = 1; 657 patch->new_name = patch->def_name; 658 return gitdiff_newmode(line, patch); 659} 660 661static int gitdiff_copysrc(const char *line, struct patch *patch) 662{ 663 patch->is_copy = 1; 664 patch->old_name = find_name(line, NULL, 0, 0); 665 return 0; 666} 667 668static int gitdiff_copydst(const char *line, struct patch *patch) 669{ 670 patch->is_copy = 1; 671 patch->new_name = find_name(line, NULL, 0, 0); 672 return 0; 673} 674 675static int gitdiff_renamesrc(const char *line, struct patch *patch) 676{ 677 patch->is_rename = 1; 678 patch->old_name = find_name(line, NULL, 0, 0); 679 return 0; 680} 681 682static int gitdiff_renamedst(const char *line, struct patch *patch) 683{ 684 patch->is_rename = 1; 685 patch->new_name = find_name(line, NULL, 0, 0); 686 return 0; 687} 688 689static int gitdiff_similarity(const char *line, struct patch *patch) 690{ 691 if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX) 692 patch->score = 0; 693 return 0; 694} 695 696static int gitdiff_dissimilarity(const char *line, struct patch *patch) 697{ 698 if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX) 699 patch->score = 0; 700 return 0; 701} 702 703static int gitdiff_index(const char *line, struct patch *patch) 704{ 705 /* 706 * index line is N hexadecimal, "..", N hexadecimal, 707 * and optional space with octal mode. 708 */ 709 const char *ptr, *eol; 710 int len; 711 712 ptr = strchr(line, '.'); 713 if (!ptr || ptr[1] != '.' || 40 < ptr - line) 714 return 0; 715 len = ptr - line; 716 memcpy(patch->old_sha1_prefix, line, len); 717 patch->old_sha1_prefix[len] = 0; 718 719 line = ptr + 2; 720 ptr = strchr(line, ' '); 721 eol = strchr(line, '\n'); 722 723 if (!ptr || eol < ptr) 724 ptr = eol; 725 len = ptr - line; 726 727 if (40 < len) 728 return 0; 729 memcpy(patch->new_sha1_prefix, line, len); 730 patch->new_sha1_prefix[len] = 0; 731 if (*ptr == ' ') 732 patch->old_mode = strtoul(ptr+1, NULL, 8); 733 return 0; 734} 735 736/* 737 * This is normal for a diff that doesn't change anything: we'll fall through 738 * into the next diff. Tell the parser to break out. 739 */ 740static int gitdiff_unrecognized(const char *line, struct patch *patch) 741{ 742 return -1; 743} 744 745static const char *stop_at_slash(const char *line, int llen) 746{ 747 int i; 748 749 for (i = 0; i < llen; i++) { 750 int ch = line[i]; 751 if (ch == '/') 752 return line + i; 753 } 754 return NULL; 755} 756 757/* 758 * This is to extract the same name that appears on "diff --git" 759 * line. We do not find and return anything if it is a rename 760 * patch, and it is OK because we will find the name elsewhere. 761 * We need to reliably find name only when it is mode-change only, 762 * creation or deletion of an empty file. In any of these cases, 763 * both sides are the same name under a/ and b/ respectively. 764 */ 765static char *git_header_name(char *line, int llen) 766{ 767 const char *name; 768 const char *second = NULL; 769 size_t len; 770 771 line += strlen("diff --git "); 772 llen -= strlen("diff --git "); 773 774 if (*line == '"') { 775 const char *cp; 776 struct strbuf first = STRBUF_INIT; 777 struct strbuf sp = STRBUF_INIT; 778 779 if (unquote_c_style(&first, line, &second)) 780 goto free_and_fail1; 781 782 /* advance to the first slash */ 783 cp = stop_at_slash(first.buf, first.len); 784 /* we do not accept absolute paths */ 785 if (!cp || cp == first.buf) 786 goto free_and_fail1; 787 strbuf_remove(&first, 0, cp + 1 - first.buf); 788 789 /* 790 * second points at one past closing dq of name. 791 * find the second name. 792 */ 793 while ((second < line + llen) && isspace(*second)) 794 second++; 795 796 if (line + llen <= second) 797 goto free_and_fail1; 798 if (*second == '"') { 799 if (unquote_c_style(&sp, second, NULL)) 800 goto free_and_fail1; 801 cp = stop_at_slash(sp.buf, sp.len); 802 if (!cp || cp == sp.buf) 803 goto free_and_fail1; 804 /* They must match, otherwise ignore */ 805 if (strcmp(cp + 1, first.buf)) 806 goto free_and_fail1; 807 strbuf_release(&sp); 808 return strbuf_detach(&first, NULL); 809 } 810 811 /* unquoted second */ 812 cp = stop_at_slash(second, line + llen - second); 813 if (!cp || cp == second) 814 goto free_and_fail1; 815 cp++; 816 if (line + llen - cp != first.len + 1 || 817 memcmp(first.buf, cp, first.len)) 818 goto free_and_fail1; 819 return strbuf_detach(&first, NULL); 820 821 free_and_fail1: 822 strbuf_release(&first); 823 strbuf_release(&sp); 824 return NULL; 825 } 826 827 /* unquoted first name */ 828 name = stop_at_slash(line, llen); 829 if (!name || name == line) 830 return NULL; 831 name++; 832 833 /* 834 * since the first name is unquoted, a dq if exists must be 835 * the beginning of the second name. 836 */ 837 for (second = name; second < line + llen; second++) { 838 if (*second == '"') { 839 struct strbuf sp = STRBUF_INIT; 840 const char *np; 841 842 if (unquote_c_style(&sp, second, NULL)) 843 goto free_and_fail2; 844 845 np = stop_at_slash(sp.buf, sp.len); 846 if (!np || np == sp.buf) 847 goto free_and_fail2; 848 np++; 849 850 len = sp.buf + sp.len - np; 851 if (len < second - name && 852 !strncmp(np, name, len) && 853 isspace(name[len])) { 854 /* Good */ 855 strbuf_remove(&sp, 0, np - sp.buf); 856 return strbuf_detach(&sp, NULL); 857 } 858 859 free_and_fail2: 860 strbuf_release(&sp); 861 return NULL; 862 } 863 } 864 865 /* 866 * Accept a name only if it shows up twice, exactly the same 867 * form. 868 */ 869 for (len = 0 ; ; len++) { 870 switch (name[len]) { 871 default: 872 continue; 873 case '\n': 874 return NULL; 875 case '\t': case ' ': 876 second = name+len; 877 for (;;) { 878 char c = *second++; 879 if (c == '\n') 880 return NULL; 881 if (c == '/') 882 break; 883 } 884 if (second[len] == '\n' && !memcmp(name, second, len)) { 885 return xmemdupz(name, len); 886 } 887 } 888 } 889} 890 891/* Verify that we recognize the lines following a git header */ 892static int parse_git_header(char *line, int len, unsigned int size, struct patch *patch) 893{ 894 unsigned long offset; 895 896 /* A git diff has explicit new/delete information, so we don't guess */ 897 patch->is_new = 0; 898 patch->is_delete = 0; 899 900 /* 901 * Some things may not have the old name in the 902 * rest of the headers anywhere (pure mode changes, 903 * or removing or adding empty files), so we get 904 * the default name from the header. 905 */ 906 patch->def_name = git_header_name(line, len); 907 if (patch->def_name && root) { 908 char *s = xmalloc(root_len + strlen(patch->def_name) + 1); 909 strcpy(s, root); 910 strcpy(s + root_len, patch->def_name); 911 free(patch->def_name); 912 patch->def_name = s; 913 } 914 915 line += len; 916 size -= len; 917 linenr++; 918 for (offset = len ; size > 0 ; offset += len, size -= len, line += len, linenr++) { 919 static const struct opentry { 920 const char *str; 921 int (*fn)(const char *, struct patch *); 922 } optable[] = { 923 { "@@ -", gitdiff_hdrend }, 924 { "--- ", gitdiff_oldname }, 925 { "+++ ", gitdiff_newname }, 926 { "old mode ", gitdiff_oldmode }, 927 { "new mode ", gitdiff_newmode }, 928 { "deleted file mode ", gitdiff_delete }, 929 { "new file mode ", gitdiff_newfile }, 930 { "copy from ", gitdiff_copysrc }, 931 { "copy to ", gitdiff_copydst }, 932 { "rename old ", gitdiff_renamesrc }, 933 { "rename new ", gitdiff_renamedst }, 934 { "rename from ", gitdiff_renamesrc }, 935 { "rename to ", gitdiff_renamedst }, 936 { "similarity index ", gitdiff_similarity }, 937 { "dissimilarity index ", gitdiff_dissimilarity }, 938 { "index ", gitdiff_index }, 939 { "", gitdiff_unrecognized }, 940 }; 941 int i; 942 943 len = linelen(line, size); 944 if (!len || line[len-1] != '\n') 945 break; 946 for (i = 0; i < ARRAY_SIZE(optable); i++) { 947 const struct opentry *p = optable + i; 948 int oplen = strlen(p->str); 949 if (len < oplen || memcmp(p->str, line, oplen)) 950 continue; 951 if (p->fn(line + oplen, patch) < 0) 952 return offset; 953 break; 954 } 955 } 956 957 return offset; 958} 959 960static int parse_num(const char *line, unsigned long *p) 961{ 962 char *ptr; 963 964 if (!isdigit(*line)) 965 return 0; 966 *p = strtoul(line, &ptr, 10); 967 return ptr - line; 968} 969 970static int parse_range(const char *line, int len, int offset, const char *expect, 971 unsigned long *p1, unsigned long *p2) 972{ 973 int digits, ex; 974 975 if (offset < 0 || offset >= len) 976 return -1; 977 line += offset; 978 len -= offset; 979 980 digits = parse_num(line, p1); 981 if (!digits) 982 return -1; 983 984 offset += digits; 985 line += digits; 986 len -= digits; 987 988 *p2 = 1; 989 if (*line == ',') { 990 digits = parse_num(line+1, p2); 991 if (!digits) 992 return -1; 993 994 offset += digits+1; 995 line += digits+1; 996 len -= digits+1; 997 } 998 999 ex = strlen(expect);1000 if (ex > len)1001 return -1;1002 if (memcmp(line, expect, ex))1003 return -1;10041005 return offset + ex;1006}10071008static void recount_diff(char *line, int size, struct fragment *fragment)1009{1010 int oldlines = 0, newlines = 0, ret = 0;10111012 if (size < 1) {1013 warning("recount: ignore empty hunk");1014 return;1015 }10161017 for (;;) {1018 int len = linelen(line, size);1019 size -= len;1020 line += len;10211022 if (size < 1)1023 break;10241025 switch (*line) {1026 case ' ': case '\n':1027 newlines++;1028 /* fall through */1029 case '-':1030 oldlines++;1031 continue;1032 case '+':1033 newlines++;1034 continue;1035 case '\\':1036 continue;1037 case '@':1038 ret = size < 3 || prefixcmp(line, "@@ ");1039 break;1040 case 'd':1041 ret = size < 5 || prefixcmp(line, "diff ");1042 break;1043 default:1044 ret = -1;1045 break;1046 }1047 if (ret) {1048 warning("recount: unexpected line: %.*s",1049 (int)linelen(line, size), line);1050 return;1051 }1052 break;1053 }1054 fragment->oldlines = oldlines;1055 fragment->newlines = newlines;1056}10571058/*1059 * Parse a unified diff fragment header of the1060 * form "@@ -a,b +c,d @@"1061 */1062static int parse_fragment_header(char *line, int len, struct fragment *fragment)1063{1064 int offset;10651066 if (!len || line[len-1] != '\n')1067 return -1;10681069 /* Figure out the number of lines in a fragment */1070 offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);1071 offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);10721073 return offset;1074}10751076static int find_header(char *line, unsigned long size, int *hdrsize, struct patch *patch)1077{1078 unsigned long offset, len;10791080 patch->is_toplevel_relative = 0;1081 patch->is_rename = patch->is_copy = 0;1082 patch->is_new = patch->is_delete = -1;1083 patch->old_mode = patch->new_mode = 0;1084 patch->old_name = patch->new_name = NULL;1085 for (offset = 0; size > 0; offset += len, size -= len, line += len, linenr++) {1086 unsigned long nextlen;10871088 len = linelen(line, size);1089 if (!len)1090 break;10911092 /* Testing this early allows us to take a few shortcuts.. */1093 if (len < 6)1094 continue;10951096 /*1097 * Make sure we don't find any unconnected patch fragments.1098 * That's a sign that we didn't find a header, and that a1099 * patch has become corrupted/broken up.1100 */1101 if (!memcmp("@@ -", line, 4)) {1102 struct fragment dummy;1103 if (parse_fragment_header(line, len, &dummy) < 0)1104 continue;1105 die("patch fragment without header at line %d: %.*s",1106 linenr, (int)len-1, line);1107 }11081109 if (size < len + 6)1110 break;11111112 /*1113 * Git patch? It might not have a real patch, just a rename1114 * or mode change, so we handle that specially1115 */1116 if (!memcmp("diff --git ", line, 11)) {1117 int git_hdr_len = parse_git_header(line, len, size, patch);1118 if (git_hdr_len <= len)1119 continue;1120 if (!patch->old_name && !patch->new_name) {1121 if (!patch->def_name)1122 die("git diff header lacks filename information (line %d)", linenr);1123 patch->old_name = patch->new_name = patch->def_name;1124 }1125 patch->is_toplevel_relative = 1;1126 *hdrsize = git_hdr_len;1127 return offset;1128 }11291130 /* --- followed by +++ ? */1131 if (memcmp("--- ", line, 4) || memcmp("+++ ", line + len, 4))1132 continue;11331134 /*1135 * We only accept unified patches, so we want it to1136 * at least have "@@ -a,b +c,d @@\n", which is 14 chars1137 * minimum ("@@ -0,0 +1 @@\n" is the shortest).1138 */1139 nextlen = linelen(line + len, size - len);1140 if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))1141 continue;11421143 /* Ok, we'll consider it a patch */1144 parse_traditional_patch(line, line+len, patch);1145 *hdrsize = len + nextlen;1146 linenr += 2;1147 return offset;1148 }1149 return -1;1150}11511152static void check_whitespace(const char *line, int len, unsigned ws_rule)1153{1154 char *err;1155 unsigned result = ws_check(line + 1, len - 1, ws_rule);1156 if (!result)1157 return;11581159 whitespace_error++;1160 if (squelch_whitespace_errors &&1161 squelch_whitespace_errors < whitespace_error)1162 ;1163 else {1164 err = whitespace_error_string(result);1165 fprintf(stderr, "%s:%d: %s.\n%.*s\n",1166 patch_input_file, linenr, err, len - 2, line + 1);1167 free(err);1168 }1169}11701171/*1172 * Parse a unified diff. Note that this really needs to parse each1173 * fragment separately, since the only way to know the difference1174 * between a "---" that is part of a patch, and a "---" that starts1175 * the next patch is to look at the line counts..1176 */1177static int parse_fragment(char *line, unsigned long size,1178 struct patch *patch, struct fragment *fragment)1179{1180 int added, deleted;1181 int len = linelen(line, size), offset;1182 unsigned long oldlines, newlines;1183 unsigned long leading, trailing;11841185 offset = parse_fragment_header(line, len, fragment);1186 if (offset < 0)1187 return -1;1188 if (offset > 0 && patch->recount)1189 recount_diff(line + offset, size - offset, fragment);1190 oldlines = fragment->oldlines;1191 newlines = fragment->newlines;1192 leading = 0;1193 trailing = 0;11941195 /* Parse the thing.. */1196 line += len;1197 size -= len;1198 linenr++;1199 added = deleted = 0;1200 for (offset = len;1201 0 < size;1202 offset += len, size -= len, line += len, linenr++) {1203 if (!oldlines && !newlines)1204 break;1205 len = linelen(line, size);1206 if (!len || line[len-1] != '\n')1207 return -1;1208 switch (*line) {1209 default:1210 return -1;1211 case '\n': /* newer GNU diff, an empty context line */1212 case ' ':1213 oldlines--;1214 newlines--;1215 if (!deleted && !added)1216 leading++;1217 trailing++;1218 break;1219 case '-':1220 if (apply_in_reverse &&1221 ws_error_action != nowarn_ws_error)1222 check_whitespace(line, len, patch->ws_rule);1223 deleted++;1224 oldlines--;1225 trailing = 0;1226 break;1227 case '+':1228 if (!apply_in_reverse &&1229 ws_error_action != nowarn_ws_error)1230 check_whitespace(line, len, patch->ws_rule);1231 added++;1232 newlines--;1233 trailing = 0;1234 break;12351236 /*1237 * We allow "\ No newline at end of file". Depending1238 * on locale settings when the patch was produced we1239 * don't know what this line looks like. The only1240 * thing we do know is that it begins with "\ ".1241 * Checking for 12 is just for sanity check -- any1242 * l10n of "\ No newline..." is at least that long.1243 */1244 case '\\':1245 if (len < 12 || memcmp(line, "\\ ", 2))1246 return -1;1247 break;1248 }1249 }1250 if (oldlines || newlines)1251 return -1;1252 fragment->leading = leading;1253 fragment->trailing = trailing;12541255 /*1256 * If a fragment ends with an incomplete line, we failed to include1257 * it in the above loop because we hit oldlines == newlines == 01258 * before seeing it.1259 */1260 if (12 < size && !memcmp(line, "\\ ", 2))1261 offset += linelen(line, size);12621263 patch->lines_added += added;1264 patch->lines_deleted += deleted;12651266 if (0 < patch->is_new && oldlines)1267 return error("new file depends on old contents");1268 if (0 < patch->is_delete && newlines)1269 return error("deleted file still has contents");1270 return offset;1271}12721273static int parse_single_patch(char *line, unsigned long size, struct patch *patch)1274{1275 unsigned long offset = 0;1276 unsigned long oldlines = 0, newlines = 0, context = 0;1277 struct fragment **fragp = &patch->fragments;12781279 while (size > 4 && !memcmp(line, "@@ -", 4)) {1280 struct fragment *fragment;1281 int len;12821283 fragment = xcalloc(1, sizeof(*fragment));1284 len = parse_fragment(line, size, patch, fragment);1285 if (len <= 0)1286 die("corrupt patch at line %d", linenr);1287 fragment->patch = line;1288 fragment->size = len;1289 oldlines += fragment->oldlines;1290 newlines += fragment->newlines;1291 context += fragment->leading + fragment->trailing;12921293 *fragp = fragment;1294 fragp = &fragment->next;12951296 offset += len;1297 line += len;1298 size -= len;1299 }13001301 /*1302 * If something was removed (i.e. we have old-lines) it cannot1303 * be creation, and if something was added it cannot be1304 * deletion. However, the reverse is not true; --unified=01305 * patches that only add are not necessarily creation even1306 * though they do not have any old lines, and ones that only1307 * delete are not necessarily deletion.1308 *1309 * Unfortunately, a real creation/deletion patch do _not_ have1310 * any context line by definition, so we cannot safely tell it1311 * apart with --unified=0 insanity. At least if the patch has1312 * more than one hunk it is not creation or deletion.1313 */1314 if (patch->is_new < 0 &&1315 (oldlines || (patch->fragments && patch->fragments->next)))1316 patch->is_new = 0;1317 if (patch->is_delete < 0 &&1318 (newlines || (patch->fragments && patch->fragments->next)))1319 patch->is_delete = 0;13201321 if (0 < patch->is_new && oldlines)1322 die("new file %s depends on old contents", patch->new_name);1323 if (0 < patch->is_delete && newlines)1324 die("deleted file %s still has contents", patch->old_name);1325 if (!patch->is_delete && !newlines && context)1326 fprintf(stderr, "** warning: file %s becomes empty but "1327 "is not deleted\n", patch->new_name);13281329 return offset;1330}13311332static inline int metadata_changes(struct patch *patch)1333{1334 return patch->is_rename > 0 ||1335 patch->is_copy > 0 ||1336 patch->is_new > 0 ||1337 patch->is_delete ||1338 (patch->old_mode && patch->new_mode &&1339 patch->old_mode != patch->new_mode);1340}13411342static char *inflate_it(const void *data, unsigned long size,1343 unsigned long inflated_size)1344{1345 z_stream stream;1346 void *out;1347 int st;13481349 memset(&stream, 0, sizeof(stream));13501351 stream.next_in = (unsigned char *)data;1352 stream.avail_in = size;1353 stream.next_out = out = xmalloc(inflated_size);1354 stream.avail_out = inflated_size;1355 git_inflate_init(&stream);1356 st = git_inflate(&stream, Z_FINISH);1357 git_inflate_end(&stream);1358 if ((st != Z_STREAM_END) || stream.total_out != inflated_size) {1359 free(out);1360 return NULL;1361 }1362 return out;1363}13641365static struct fragment *parse_binary_hunk(char **buf_p,1366 unsigned long *sz_p,1367 int *status_p,1368 int *used_p)1369{1370 /*1371 * Expect a line that begins with binary patch method ("literal"1372 * or "delta"), followed by the length of data before deflating.1373 * a sequence of 'length-byte' followed by base-85 encoded data1374 * should follow, terminated by a newline.1375 *1376 * Each 5-byte sequence of base-85 encodes up to 4 bytes,1377 * and we would limit the patch line to 66 characters,1378 * so one line can fit up to 13 groups that would decode1379 * to 52 bytes max. The length byte 'A'-'Z' corresponds1380 * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.1381 */1382 int llen, used;1383 unsigned long size = *sz_p;1384 char *buffer = *buf_p;1385 int patch_method;1386 unsigned long origlen;1387 char *data = NULL;1388 int hunk_size = 0;1389 struct fragment *frag;13901391 llen = linelen(buffer, size);1392 used = llen;13931394 *status_p = 0;13951396 if (!prefixcmp(buffer, "delta ")) {1397 patch_method = BINARY_DELTA_DEFLATED;1398 origlen = strtoul(buffer + 6, NULL, 10);1399 }1400 else if (!prefixcmp(buffer, "literal ")) {1401 patch_method = BINARY_LITERAL_DEFLATED;1402 origlen = strtoul(buffer + 8, NULL, 10);1403 }1404 else1405 return NULL;14061407 linenr++;1408 buffer += llen;1409 while (1) {1410 int byte_length, max_byte_length, newsize;1411 llen = linelen(buffer, size);1412 used += llen;1413 linenr++;1414 if (llen == 1) {1415 /* consume the blank line */1416 buffer++;1417 size--;1418 break;1419 }1420 /*1421 * Minimum line is "A00000\n" which is 7-byte long,1422 * and the line length must be multiple of 5 plus 2.1423 */1424 if ((llen < 7) || (llen-2) % 5)1425 goto corrupt;1426 max_byte_length = (llen - 2) / 5 * 4;1427 byte_length = *buffer;1428 if ('A' <= byte_length && byte_length <= 'Z')1429 byte_length = byte_length - 'A' + 1;1430 else if ('a' <= byte_length && byte_length <= 'z')1431 byte_length = byte_length - 'a' + 27;1432 else1433 goto corrupt;1434 /* if the input length was not multiple of 4, we would1435 * have filler at the end but the filler should never1436 * exceed 3 bytes1437 */1438 if (max_byte_length < byte_length ||1439 byte_length <= max_byte_length - 4)1440 goto corrupt;1441 newsize = hunk_size + byte_length;1442 data = xrealloc(data, newsize);1443 if (decode_85(data + hunk_size, buffer + 1, byte_length))1444 goto corrupt;1445 hunk_size = newsize;1446 buffer += llen;1447 size -= llen;1448 }14491450 frag = xcalloc(1, sizeof(*frag));1451 frag->patch = inflate_it(data, hunk_size, origlen);1452 if (!frag->patch)1453 goto corrupt;1454 free(data);1455 frag->size = origlen;1456 *buf_p = buffer;1457 *sz_p = size;1458 *used_p = used;1459 frag->binary_patch_method = patch_method;1460 return frag;14611462 corrupt:1463 free(data);1464 *status_p = -1;1465 error("corrupt binary patch at line %d: %.*s",1466 linenr-1, llen-1, buffer);1467 return NULL;1468}14691470static int parse_binary(char *buffer, unsigned long size, struct patch *patch)1471{1472 /*1473 * We have read "GIT binary patch\n"; what follows is a line1474 * that says the patch method (currently, either "literal" or1475 * "delta") and the length of data before deflating; a1476 * sequence of 'length-byte' followed by base-85 encoded data1477 * follows.1478 *1479 * When a binary patch is reversible, there is another binary1480 * hunk in the same format, starting with patch method (either1481 * "literal" or "delta") with the length of data, and a sequence1482 * of length-byte + base-85 encoded data, terminated with another1483 * empty line. This data, when applied to the postimage, produces1484 * the preimage.1485 */1486 struct fragment *forward;1487 struct fragment *reverse;1488 int status;1489 int used, used_1;14901491 forward = parse_binary_hunk(&buffer, &size, &status, &used);1492 if (!forward && !status)1493 /* there has to be one hunk (forward hunk) */1494 return error("unrecognized binary patch at line %d", linenr-1);1495 if (status)1496 /* otherwise we already gave an error message */1497 return status;14981499 reverse = parse_binary_hunk(&buffer, &size, &status, &used_1);1500 if (reverse)1501 used += used_1;1502 else if (status) {1503 /*1504 * Not having reverse hunk is not an error, but having1505 * a corrupt reverse hunk is.1506 */1507 free((void*) forward->patch);1508 free(forward);1509 return status;1510 }1511 forward->next = reverse;1512 patch->fragments = forward;1513 patch->is_binary = 1;1514 return used;1515}15161517static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)1518{1519 int hdrsize, patchsize;1520 int offset = find_header(buffer, size, &hdrsize, patch);15211522 if (offset < 0)1523 return offset;15241525 patch->ws_rule = whitespace_rule(patch->new_name1526 ? patch->new_name1527 : patch->old_name);15281529 patchsize = parse_single_patch(buffer + offset + hdrsize,1530 size - offset - hdrsize, patch);15311532 if (!patchsize) {1533 static const char *binhdr[] = {1534 "Binary files ",1535 "Files ",1536 NULL,1537 };1538 static const char git_binary[] = "GIT binary patch\n";1539 int i;1540 int hd = hdrsize + offset;1541 unsigned long llen = linelen(buffer + hd, size - hd);15421543 if (llen == sizeof(git_binary) - 1 &&1544 !memcmp(git_binary, buffer + hd, llen)) {1545 int used;1546 linenr++;1547 used = parse_binary(buffer + hd + llen,1548 size - hd - llen, patch);1549 if (used)1550 patchsize = used + llen;1551 else1552 patchsize = 0;1553 }1554 else if (!memcmp(" differ\n", buffer + hd + llen - 8, 8)) {1555 for (i = 0; binhdr[i]; i++) {1556 int len = strlen(binhdr[i]);1557 if (len < size - hd &&1558 !memcmp(binhdr[i], buffer + hd, len)) {1559 linenr++;1560 patch->is_binary = 1;1561 patchsize = llen;1562 break;1563 }1564 }1565 }15661567 /* Empty patch cannot be applied if it is a text patch1568 * without metadata change. A binary patch appears1569 * empty to us here.1570 */1571 if ((apply || check) &&1572 (!patch->is_binary && !metadata_changes(patch)))1573 die("patch with only garbage at line %d", linenr);1574 }15751576 return offset + hdrsize + patchsize;1577}15781579#define swap(a,b) myswap((a),(b),sizeof(a))15801581#define myswap(a, b, size) do { \1582 unsigned char mytmp[size]; \1583 memcpy(mytmp, &a, size); \1584 memcpy(&a, &b, size); \1585 memcpy(&b, mytmp, size); \1586} while (0)15871588static void reverse_patches(struct patch *p)1589{1590 for (; p; p = p->next) {1591 struct fragment *frag = p->fragments;15921593 swap(p->new_name, p->old_name);1594 swap(p->new_mode, p->old_mode);1595 swap(p->is_new, p->is_delete);1596 swap(p->lines_added, p->lines_deleted);1597 swap(p->old_sha1_prefix, p->new_sha1_prefix);15981599 for (; frag; frag = frag->next) {1600 swap(frag->newpos, frag->oldpos);1601 swap(frag->newlines, frag->oldlines);1602 }1603 }1604}16051606static const char pluses[] =1607"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";1608static const char minuses[]=1609"----------------------------------------------------------------------";16101611static void show_stats(struct patch *patch)1612{1613 struct strbuf qname = STRBUF_INIT;1614 char *cp = patch->new_name ? patch->new_name : patch->old_name;1615 int max, add, del;16161617 quote_c_style(cp, &qname, NULL, 0);16181619 /*1620 * "scale" the filename1621 */1622 max = max_len;1623 if (max > 50)1624 max = 50;16251626 if (qname.len > max) {1627 cp = strchr(qname.buf + qname.len + 3 - max, '/');1628 if (!cp)1629 cp = qname.buf + qname.len + 3 - max;1630 strbuf_splice(&qname, 0, cp - qname.buf, "...", 3);1631 }16321633 if (patch->is_binary) {1634 printf(" %-*s | Bin\n", max, qname.buf);1635 strbuf_release(&qname);1636 return;1637 }16381639 printf(" %-*s |", max, qname.buf);1640 strbuf_release(&qname);16411642 /*1643 * scale the add/delete1644 */1645 max = max + max_change > 70 ? 70 - max : max_change;1646 add = patch->lines_added;1647 del = patch->lines_deleted;16481649 if (max_change > 0) {1650 int total = ((add + del) * max + max_change / 2) / max_change;1651 add = (add * max + max_change / 2) / max_change;1652 del = total - add;1653 }1654 printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,1655 add, pluses, del, minuses);1656}16571658static int read_old_data(struct stat *st, const char *path, struct strbuf *buf)1659{1660 switch (st->st_mode & S_IFMT) {1661 case S_IFLNK:1662 if (strbuf_readlink(buf, path, st->st_size) < 0)1663 return error("unable to read symlink %s", path);1664 return 0;1665 case S_IFREG:1666 if (strbuf_read_file(buf, path, st->st_size) != st->st_size)1667 return error("unable to open or read %s", path);1668 convert_to_git(path, buf->buf, buf->len, buf, 0);1669 return 0;1670 default:1671 return -1;1672 }1673}16741675static void update_pre_post_images(struct image *preimage,1676 struct image *postimage,1677 char *buf,1678 size_t len)1679{1680 int i, ctx;1681 char *new, *old, *fixed;1682 struct image fixed_preimage;16831684 /*1685 * Update the preimage with whitespace fixes. Note that we1686 * are not losing preimage->buf -- apply_one_fragment() will1687 * free "oldlines".1688 */1689 prepare_image(&fixed_preimage, buf, len, 1);1690 assert(fixed_preimage.nr == preimage->nr);1691 for (i = 0; i < preimage->nr; i++)1692 fixed_preimage.line[i].flag = preimage->line[i].flag;1693 free(preimage->line_allocated);1694 *preimage = fixed_preimage;16951696 /*1697 * Adjust the common context lines in postimage, in place.1698 * This is possible because whitespace fixing does not make1699 * the string grow.1700 */1701 new = old = postimage->buf;1702 fixed = preimage->buf;1703 for (i = ctx = 0; i < postimage->nr; i++) {1704 size_t len = postimage->line[i].len;1705 if (!(postimage->line[i].flag & LINE_COMMON)) {1706 /* an added line -- no counterparts in preimage */1707 memmove(new, old, len);1708 old += len;1709 new += len;1710 continue;1711 }17121713 /* a common context -- skip it in the original postimage */1714 old += len;17151716 /* and find the corresponding one in the fixed preimage */1717 while (ctx < preimage->nr &&1718 !(preimage->line[ctx].flag & LINE_COMMON)) {1719 fixed += preimage->line[ctx].len;1720 ctx++;1721 }1722 if (preimage->nr <= ctx)1723 die("oops");17241725 /* and copy it in, while fixing the line length */1726 len = preimage->line[ctx].len;1727 memcpy(new, fixed, len);1728 new += len;1729 fixed += len;1730 postimage->line[i].len = len;1731 ctx++;1732 }17331734 /* Fix the length of the whole thing */1735 postimage->len = new - postimage->buf;1736}17371738static int match_fragment(struct image *img,1739 struct image *preimage,1740 struct image *postimage,1741 unsigned long try,1742 int try_lno,1743 unsigned ws_rule,1744 int match_beginning, int match_end)1745{1746 int i;1747 char *fixed_buf, *buf, *orig, *target;17481749 if (preimage->nr + try_lno > img->nr)1750 return 0;17511752 if (match_beginning && try_lno)1753 return 0;17541755 if (match_end && preimage->nr + try_lno != img->nr)1756 return 0;17571758 /* Quick hash check */1759 for (i = 0; i < preimage->nr; i++)1760 if (preimage->line[i].hash != img->line[try_lno + i].hash)1761 return 0;17621763 /*1764 * Do we have an exact match? If we were told to match1765 * at the end, size must be exactly at try+fragsize,1766 * otherwise try+fragsize must be still within the preimage,1767 * and either case, the old piece should match the preimage1768 * exactly.1769 */1770 if ((match_end1771 ? (try + preimage->len == img->len)1772 : (try + preimage->len <= img->len)) &&1773 !memcmp(img->buf + try, preimage->buf, preimage->len))1774 return 1;17751776 if (ws_error_action != correct_ws_error)1777 return 0;17781779 /*1780 * The hunk does not apply byte-by-byte, but the hash says1781 * it might with whitespace fuzz.1782 */1783 fixed_buf = xmalloc(preimage->len + 1);1784 buf = fixed_buf;1785 orig = preimage->buf;1786 target = img->buf + try;1787 for (i = 0; i < preimage->nr; i++) {1788 size_t fixlen; /* length after fixing the preimage */1789 size_t oldlen = preimage->line[i].len;1790 size_t tgtlen = img->line[try_lno + i].len;1791 size_t tgtfixlen; /* length after fixing the target line */1792 char tgtfixbuf[1024], *tgtfix;1793 int match;17941795 /* Try fixing the line in the preimage */1796 fixlen = ws_fix_copy(buf, orig, oldlen, ws_rule, NULL);17971798 /* Try fixing the line in the target */1799 if (sizeof(tgtfixbuf) > tgtlen)1800 tgtfix = tgtfixbuf;1801 else1802 tgtfix = xmalloc(tgtlen);1803 tgtfixlen = ws_fix_copy(tgtfix, target, tgtlen, ws_rule, NULL);18041805 /*1806 * If they match, either the preimage was based on1807 * a version before our tree fixed whitespace breakage,1808 * or we are lacking a whitespace-fix patch the tree1809 * the preimage was based on already had (i.e. target1810 * has whitespace breakage, the preimage doesn't).1811 * In either case, we are fixing the whitespace breakages1812 * so we might as well take the fix together with their1813 * real change.1814 */1815 match = (tgtfixlen == fixlen && !memcmp(tgtfix, buf, fixlen));18161817 if (tgtfix != tgtfixbuf)1818 free(tgtfix);1819 if (!match)1820 goto unmatch_exit;18211822 orig += oldlen;1823 buf += fixlen;1824 target += tgtlen;1825 }18261827 /*1828 * Yes, the preimage is based on an older version that still1829 * has whitespace breakages unfixed, and fixing them makes the1830 * hunk match. Update the context lines in the postimage.1831 */1832 update_pre_post_images(preimage, postimage,1833 fixed_buf, buf - fixed_buf);1834 return 1;18351836 unmatch_exit:1837 free(fixed_buf);1838 return 0;1839}18401841static int find_pos(struct image *img,1842 struct image *preimage,1843 struct image *postimage,1844 int line,1845 unsigned ws_rule,1846 int match_beginning, int match_end)1847{1848 int i;1849 unsigned long backwards, forwards, try;1850 int backwards_lno, forwards_lno, try_lno;18511852 if (preimage->nr > img->nr)1853 return -1;18541855 /*1856 * If match_begining or match_end is specified, there is no1857 * point starting from a wrong line that will never match and1858 * wander around and wait for a match at the specified end.1859 */1860 if (match_beginning)1861 line = 0;1862 else if (match_end)1863 line = img->nr - preimage->nr;18641865 if (line > img->nr)1866 line = img->nr;18671868 try = 0;1869 for (i = 0; i < line; i++)1870 try += img->line[i].len;18711872 /*1873 * There's probably some smart way to do this, but I'll leave1874 * that to the smart and beautiful people. I'm simple and stupid.1875 */1876 backwards = try;1877 backwards_lno = line;1878 forwards = try;1879 forwards_lno = line;1880 try_lno = line;18811882 for (i = 0; ; i++) {1883 if (match_fragment(img, preimage, postimage,1884 try, try_lno, ws_rule,1885 match_beginning, match_end))1886 return try_lno;18871888 again:1889 if (backwards_lno == 0 && forwards_lno == img->nr)1890 break;18911892 if (i & 1) {1893 if (backwards_lno == 0) {1894 i++;1895 goto again;1896 }1897 backwards_lno--;1898 backwards -= img->line[backwards_lno].len;1899 try = backwards;1900 try_lno = backwards_lno;1901 } else {1902 if (forwards_lno == img->nr) {1903 i++;1904 goto again;1905 }1906 forwards += img->line[forwards_lno].len;1907 forwards_lno++;1908 try = forwards;1909 try_lno = forwards_lno;1910 }19111912 }1913 return -1;1914}19151916static void remove_first_line(struct image *img)1917{1918 img->buf += img->line[0].len;1919 img->len -= img->line[0].len;1920 img->line++;1921 img->nr--;1922}19231924static void remove_last_line(struct image *img)1925{1926 img->len -= img->line[--img->nr].len;1927}19281929static void update_image(struct image *img,1930 int applied_pos,1931 struct image *preimage,1932 struct image *postimage)1933{1934 /*1935 * remove the copy of preimage at offset in img1936 * and replace it with postimage1937 */1938 int i, nr;1939 size_t remove_count, insert_count, applied_at = 0;1940 char *result;19411942 for (i = 0; i < applied_pos; i++)1943 applied_at += img->line[i].len;19441945 remove_count = 0;1946 for (i = 0; i < preimage->nr; i++)1947 remove_count += img->line[applied_pos + i].len;1948 insert_count = postimage->len;19491950 /* Adjust the contents */1951 result = xmalloc(img->len + insert_count - remove_count + 1);1952 memcpy(result, img->buf, applied_at);1953 memcpy(result + applied_at, postimage->buf, postimage->len);1954 memcpy(result + applied_at + postimage->len,1955 img->buf + (applied_at + remove_count),1956 img->len - (applied_at + remove_count));1957 free(img->buf);1958 img->buf = result;1959 img->len += insert_count - remove_count;1960 result[img->len] = '\0';19611962 /* Adjust the line table */1963 nr = img->nr + postimage->nr - preimage->nr;1964 if (preimage->nr < postimage->nr) {1965 /*1966 * NOTE: this knows that we never call remove_first_line()1967 * on anything other than pre/post image.1968 */1969 img->line = xrealloc(img->line, nr * sizeof(*img->line));1970 img->line_allocated = img->line;1971 }1972 if (preimage->nr != postimage->nr)1973 memmove(img->line + applied_pos + postimage->nr,1974 img->line + applied_pos + preimage->nr,1975 (img->nr - (applied_pos + preimage->nr)) *1976 sizeof(*img->line));1977 memcpy(img->line + applied_pos,1978 postimage->line,1979 postimage->nr * sizeof(*img->line));1980 img->nr = nr;1981}19821983static int apply_one_fragment(struct image *img, struct fragment *frag,1984 int inaccurate_eof, unsigned ws_rule)1985{1986 int match_beginning, match_end;1987 const char *patch = frag->patch;1988 int size = frag->size;1989 char *old, *new, *oldlines, *newlines;1990 int new_blank_lines_at_end = 0;1991 unsigned long leading, trailing;1992 int pos, applied_pos;1993 struct image preimage;1994 struct image postimage;19951996 memset(&preimage, 0, sizeof(preimage));1997 memset(&postimage, 0, sizeof(postimage));1998 oldlines = xmalloc(size);1999 newlines = xmalloc(size);20002001 old = oldlines;2002 new = newlines;2003 while (size > 0) {2004 char first;2005 int len = linelen(patch, size);2006 int plen, added;2007 int added_blank_line = 0;20082009 if (!len)2010 break;20112012 /*2013 * "plen" is how much of the line we should use for2014 * the actual patch data. Normally we just remove the2015 * first character on the line, but if the line is2016 * followed by "\ No newline", then we also remove the2017 * last one (which is the newline, of course).2018 */2019 plen = len - 1;2020 if (len < size && patch[len] == '\\')2021 plen--;2022 first = *patch;2023 if (apply_in_reverse) {2024 if (first == '-')2025 first = '+';2026 else if (first == '+')2027 first = '-';2028 }20292030 switch (first) {2031 case '\n':2032 /* Newer GNU diff, empty context line */2033 if (plen < 0)2034 /* ... followed by '\No newline'; nothing */2035 break;2036 *old++ = '\n';2037 *new++ = '\n';2038 add_line_info(&preimage, "\n", 1, LINE_COMMON);2039 add_line_info(&postimage, "\n", 1, LINE_COMMON);2040 break;2041 case ' ':2042 case '-':2043 memcpy(old, patch + 1, plen);2044 add_line_info(&preimage, old, plen,2045 (first == ' ' ? LINE_COMMON : 0));2046 old += plen;2047 if (first == '-')2048 break;2049 /* Fall-through for ' ' */2050 case '+':2051 /* --no-add does not add new lines */2052 if (first == '+' && no_add)2053 break;20542055 if (first != '+' ||2056 !whitespace_error ||2057 ws_error_action != correct_ws_error) {2058 memcpy(new, patch + 1, plen);2059 added = plen;2060 }2061 else {2062 added = ws_fix_copy(new, patch + 1, plen, ws_rule, &applied_after_fixing_ws);2063 }2064 add_line_info(&postimage, new, added,2065 (first == '+' ? 0 : LINE_COMMON));2066 new += added;2067 if (first == '+' &&2068 added == 1 && new[-1] == '\n')2069 added_blank_line = 1;2070 break;2071 case '@': case '\\':2072 /* Ignore it, we already handled it */2073 break;2074 default:2075 if (apply_verbosely)2076 error("invalid start of line: '%c'", first);2077 return -1;2078 }2079 if (added_blank_line)2080 new_blank_lines_at_end++;2081 else2082 new_blank_lines_at_end = 0;2083 patch += len;2084 size -= len;2085 }2086 if (inaccurate_eof &&2087 old > oldlines && old[-1] == '\n' &&2088 new > newlines && new[-1] == '\n') {2089 old--;2090 new--;2091 }20922093 leading = frag->leading;2094 trailing = frag->trailing;20952096 /*2097 * A hunk to change lines at the beginning would begin with2098 * @@ -1,L +N,M @@2099 * but we need to be careful. -U0 that inserts before the second2100 * line also has this pattern.2101 *2102 * And a hunk to add to an empty file would begin with2103 * @@ -0,0 +N,M @@2104 *2105 * In other words, a hunk that is (frag->oldpos <= 1) with or2106 * without leading context must match at the beginning.2107 */2108 match_beginning = (!frag->oldpos ||2109 (frag->oldpos == 1 && !unidiff_zero));21102111 /*2112 * A hunk without trailing lines must match at the end.2113 * However, we simply cannot tell if a hunk must match end2114 * from the lack of trailing lines if the patch was generated2115 * with unidiff without any context.2116 */2117 match_end = !unidiff_zero && !trailing;21182119 pos = frag->newpos ? (frag->newpos - 1) : 0;2120 preimage.buf = oldlines;2121 preimage.len = old - oldlines;2122 postimage.buf = newlines;2123 postimage.len = new - newlines;2124 preimage.line = preimage.line_allocated;2125 postimage.line = postimage.line_allocated;21262127 for (;;) {21282129 applied_pos = find_pos(img, &preimage, &postimage, pos,2130 ws_rule, match_beginning, match_end);21312132 if (applied_pos >= 0)2133 break;21342135 /* Am I at my context limits? */2136 if ((leading <= p_context) && (trailing <= p_context))2137 break;2138 if (match_beginning || match_end) {2139 match_beginning = match_end = 0;2140 continue;2141 }21422143 /*2144 * Reduce the number of context lines; reduce both2145 * leading and trailing if they are equal otherwise2146 * just reduce the larger context.2147 */2148 if (leading >= trailing) {2149 remove_first_line(&preimage);2150 remove_first_line(&postimage);2151 pos--;2152 leading--;2153 }2154 if (trailing > leading) {2155 remove_last_line(&preimage);2156 remove_last_line(&postimage);2157 trailing--;2158 }2159 }21602161 if (applied_pos >= 0) {2162 if (ws_error_action == correct_ws_error &&2163 new_blank_lines_at_end &&2164 postimage.nr + applied_pos == img->nr) {2165 /*2166 * If the patch application adds blank lines2167 * at the end, and if the patch applies at the2168 * end of the image, remove those added blank2169 * lines.2170 */2171 while (new_blank_lines_at_end--)2172 remove_last_line(&postimage);2173 }21742175 /*2176 * Warn if it was necessary to reduce the number2177 * of context lines.2178 */2179 if ((leading != frag->leading) ||2180 (trailing != frag->trailing))2181 fprintf(stderr, "Context reduced to (%ld/%ld)"2182 " to apply fragment at %d\n",2183 leading, trailing, applied_pos+1);2184 update_image(img, applied_pos, &preimage, &postimage);2185 } else {2186 if (apply_verbosely)2187 error("while searching for:\n%.*s",2188 (int)(old - oldlines), oldlines);2189 }21902191 free(oldlines);2192 free(newlines);2193 free(preimage.line_allocated);2194 free(postimage.line_allocated);21952196 return (applied_pos < 0);2197}21982199static int apply_binary_fragment(struct image *img, struct patch *patch)2200{2201 struct fragment *fragment = patch->fragments;2202 unsigned long len;2203 void *dst;22042205 /* Binary patch is irreversible without the optional second hunk */2206 if (apply_in_reverse) {2207 if (!fragment->next)2208 return error("cannot reverse-apply a binary patch "2209 "without the reverse hunk to '%s'",2210 patch->new_name2211 ? patch->new_name : patch->old_name);2212 fragment = fragment->next;2213 }2214 switch (fragment->binary_patch_method) {2215 case BINARY_DELTA_DEFLATED:2216 dst = patch_delta(img->buf, img->len, fragment->patch,2217 fragment->size, &len);2218 if (!dst)2219 return -1;2220 clear_image(img);2221 img->buf = dst;2222 img->len = len;2223 return 0;2224 case BINARY_LITERAL_DEFLATED:2225 clear_image(img);2226 img->len = fragment->size;2227 img->buf = xmalloc(img->len+1);2228 memcpy(img->buf, fragment->patch, img->len);2229 img->buf[img->len] = '\0';2230 return 0;2231 }2232 return -1;2233}22342235static int apply_binary(struct image *img, struct patch *patch)2236{2237 const char *name = patch->old_name ? patch->old_name : patch->new_name;2238 unsigned char sha1[20];22392240 /*2241 * For safety, we require patch index line to contain2242 * full 40-byte textual SHA1 for old and new, at least for now.2243 */2244 if (strlen(patch->old_sha1_prefix) != 40 ||2245 strlen(patch->new_sha1_prefix) != 40 ||2246 get_sha1_hex(patch->old_sha1_prefix, sha1) ||2247 get_sha1_hex(patch->new_sha1_prefix, sha1))2248 return error("cannot apply binary patch to '%s' "2249 "without full index line", name);22502251 if (patch->old_name) {2252 /*2253 * See if the old one matches what the patch2254 * applies to.2255 */2256 hash_sha1_file(img->buf, img->len, blob_type, sha1);2257 if (strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))2258 return error("the patch applies to '%s' (%s), "2259 "which does not match the "2260 "current contents.",2261 name, sha1_to_hex(sha1));2262 }2263 else {2264 /* Otherwise, the old one must be empty. */2265 if (img->len)2266 return error("the patch applies to an empty "2267 "'%s' but it is not empty", name);2268 }22692270 get_sha1_hex(patch->new_sha1_prefix, sha1);2271 if (is_null_sha1(sha1)) {2272 clear_image(img);2273 return 0; /* deletion patch */2274 }22752276 if (has_sha1_file(sha1)) {2277 /* We already have the postimage */2278 enum object_type type;2279 unsigned long size;2280 char *result;22812282 result = read_sha1_file(sha1, &type, &size);2283 if (!result)2284 return error("the necessary postimage %s for "2285 "'%s' cannot be read",2286 patch->new_sha1_prefix, name);2287 clear_image(img);2288 img->buf = result;2289 img->len = size;2290 } else {2291 /*2292 * We have verified buf matches the preimage;2293 * apply the patch data to it, which is stored2294 * in the patch->fragments->{patch,size}.2295 */2296 if (apply_binary_fragment(img, patch))2297 return error("binary patch does not apply to '%s'",2298 name);22992300 /* verify that the result matches */2301 hash_sha1_file(img->buf, img->len, blob_type, sha1);2302 if (strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))2303 return error("binary patch to '%s' creates incorrect result (expecting %s, got %s)",2304 name, patch->new_sha1_prefix, sha1_to_hex(sha1));2305 }23062307 return 0;2308}23092310static int apply_fragments(struct image *img, struct patch *patch)2311{2312 struct fragment *frag = patch->fragments;2313 const char *name = patch->old_name ? patch->old_name : patch->new_name;2314 unsigned ws_rule = patch->ws_rule;2315 unsigned inaccurate_eof = patch->inaccurate_eof;23162317 if (patch->is_binary)2318 return apply_binary(img, patch);23192320 while (frag) {2321 if (apply_one_fragment(img, frag, inaccurate_eof, ws_rule)) {2322 error("patch failed: %s:%ld", name, frag->oldpos);2323 if (!apply_with_reject)2324 return -1;2325 frag->rejected = 1;2326 }2327 frag = frag->next;2328 }2329 return 0;2330}23312332static int read_file_or_gitlink(struct cache_entry *ce, struct strbuf *buf)2333{2334 if (!ce)2335 return 0;23362337 if (S_ISGITLINK(ce->ce_mode)) {2338 strbuf_grow(buf, 100);2339 strbuf_addf(buf, "Subproject commit %s\n", sha1_to_hex(ce->sha1));2340 } else {2341 enum object_type type;2342 unsigned long sz;2343 char *result;23442345 result = read_sha1_file(ce->sha1, &type, &sz);2346 if (!result)2347 return -1;2348 /* XXX read_sha1_file NUL-terminates */2349 strbuf_attach(buf, result, sz, sz + 1);2350 }2351 return 0;2352}23532354static struct patch *in_fn_table(const char *name)2355{2356 struct string_list_item *item;23572358 if (name == NULL)2359 return NULL;23602361 item = string_list_lookup(name, &fn_table);2362 if (item != NULL)2363 return (struct patch *)item->util;23642365 return NULL;2366}23672368/*2369 * item->util in the filename table records the status of the path.2370 * Usually it points at a patch (whose result records the contents2371 * of it after applying it), but it could be PATH_WAS_DELETED for a2372 * path that a previously applied patch has already removed.2373 */2374 #define PATH_TO_BE_DELETED ((struct patch *) -2)2375#define PATH_WAS_DELETED ((struct patch *) -1)23762377static int to_be_deleted(struct patch *patch)2378{2379 return patch == PATH_TO_BE_DELETED;2380}23812382static int was_deleted(struct patch *patch)2383{2384 return patch == PATH_WAS_DELETED;2385}23862387static void add_to_fn_table(struct patch *patch)2388{2389 struct string_list_item *item;23902391 /*2392 * Always add new_name unless patch is a deletion2393 * This should cover the cases for normal diffs,2394 * file creations and copies2395 */2396 if (patch->new_name != NULL) {2397 item = string_list_insert(patch->new_name, &fn_table);2398 item->util = patch;2399 }24002401 /*2402 * store a failure on rename/deletion cases because2403 * later chunks shouldn't patch old names2404 */2405 if ((patch->new_name == NULL) || (patch->is_rename)) {2406 item = string_list_insert(patch->old_name, &fn_table);2407 item->util = PATH_WAS_DELETED;2408 }2409}24102411static void prepare_fn_table(struct patch *patch)2412{2413 /*2414 * store information about incoming file deletion2415 */2416 while (patch) {2417 if ((patch->new_name == NULL) || (patch->is_rename)) {2418 struct string_list_item *item;2419 item = string_list_insert(patch->old_name, &fn_table);2420 item->util = PATH_TO_BE_DELETED;2421 }2422 patch = patch->next;2423 }2424}24252426static int apply_data(struct patch *patch, struct stat *st, struct cache_entry *ce)2427{2428 struct strbuf buf = STRBUF_INIT;2429 struct image image;2430 size_t len;2431 char *img;2432 struct patch *tpatch;24332434 if (!(patch->is_copy || patch->is_rename) &&2435 (tpatch = in_fn_table(patch->old_name)) != NULL && !to_be_deleted(tpatch)) {2436 if (was_deleted(tpatch)) {2437 return error("patch %s has been renamed/deleted",2438 patch->old_name);2439 }2440 /* We have a patched copy in memory use that */2441 strbuf_add(&buf, tpatch->result, tpatch->resultsize);2442 } else if (cached) {2443 if (read_file_or_gitlink(ce, &buf))2444 return error("read of %s failed", patch->old_name);2445 } else if (patch->old_name) {2446 if (S_ISGITLINK(patch->old_mode)) {2447 if (ce) {2448 read_file_or_gitlink(ce, &buf);2449 } else {2450 /*2451 * There is no way to apply subproject2452 * patch without looking at the index.2453 */2454 patch->fragments = NULL;2455 }2456 } else {2457 if (read_old_data(st, patch->old_name, &buf))2458 return error("read of %s failed", patch->old_name);2459 }2460 }24612462 img = strbuf_detach(&buf, &len);2463 prepare_image(&image, img, len, !patch->is_binary);24642465 if (apply_fragments(&image, patch) < 0)2466 return -1; /* note with --reject this succeeds. */2467 patch->result = image.buf;2468 patch->resultsize = image.len;2469 add_to_fn_table(patch);2470 free(image.line_allocated);24712472 if (0 < patch->is_delete && patch->resultsize)2473 return error("removal patch leaves file contents");24742475 return 0;2476}24772478static int check_to_create_blob(const char *new_name, int ok_if_exists)2479{2480 struct stat nst;2481 if (!lstat(new_name, &nst)) {2482 if (S_ISDIR(nst.st_mode) || ok_if_exists)2483 return 0;2484 /*2485 * A leading component of new_name might be a symlink2486 * that is going to be removed with this patch, but2487 * still pointing at somewhere that has the path.2488 * In such a case, path "new_name" does not exist as2489 * far as git is concerned.2490 */2491 if (has_symlink_leading_path(new_name, strlen(new_name)))2492 return 0;24932494 return error("%s: already exists in working directory", new_name);2495 }2496 else if ((errno != ENOENT) && (errno != ENOTDIR))2497 return error("%s: %s", new_name, strerror(errno));2498 return 0;2499}25002501static int verify_index_match(struct cache_entry *ce, struct stat *st)2502{2503 if (S_ISGITLINK(ce->ce_mode)) {2504 if (!S_ISDIR(st->st_mode))2505 return -1;2506 return 0;2507 }2508 return ce_match_stat(ce, st, CE_MATCH_IGNORE_VALID);2509}25102511static int check_preimage(struct patch *patch, struct cache_entry **ce, struct stat *st)2512{2513 const char *old_name = patch->old_name;2514 struct patch *tpatch = NULL;2515 int stat_ret = 0;2516 unsigned st_mode = 0;25172518 /*2519 * Make sure that we do not have local modifications from the2520 * index when we are looking at the index. Also make sure2521 * we have the preimage file to be patched in the work tree,2522 * unless --cached, which tells git to apply only in the index.2523 */2524 if (!old_name)2525 return 0;25262527 assert(patch->is_new <= 0);25282529 if (!(patch->is_copy || patch->is_rename) &&2530 (tpatch = in_fn_table(old_name)) != NULL && !to_be_deleted(tpatch)) {2531 if (was_deleted(tpatch))2532 return error("%s: has been deleted/renamed", old_name);2533 st_mode = tpatch->new_mode;2534 } else if (!cached) {2535 stat_ret = lstat(old_name, st);2536 if (stat_ret && errno != ENOENT)2537 return error("%s: %s", old_name, strerror(errno));2538 }25392540 if (to_be_deleted(tpatch))2541 tpatch = NULL;25422543 if (check_index && !tpatch) {2544 int pos = cache_name_pos(old_name, strlen(old_name));2545 if (pos < 0) {2546 if (patch->is_new < 0)2547 goto is_new;2548 return error("%s: does not exist in index", old_name);2549 }2550 *ce = active_cache[pos];2551 if (stat_ret < 0) {2552 struct checkout costate;2553 /* checkout */2554 costate.base_dir = "";2555 costate.base_dir_len = 0;2556 costate.force = 0;2557 costate.quiet = 0;2558 costate.not_new = 0;2559 costate.refresh_cache = 1;2560 if (checkout_entry(*ce, &costate, NULL) ||2561 lstat(old_name, st))2562 return -1;2563 }2564 if (!cached && verify_index_match(*ce, st))2565 return error("%s: does not match index", old_name);2566 if (cached)2567 st_mode = (*ce)->ce_mode;2568 } else if (stat_ret < 0) {2569 if (patch->is_new < 0)2570 goto is_new;2571 return error("%s: %s", old_name, strerror(errno));2572 }25732574 if (!cached && !tpatch)2575 st_mode = ce_mode_from_stat(*ce, st->st_mode);25762577 if (patch->is_new < 0)2578 patch->is_new = 0;2579 if (!patch->old_mode)2580 patch->old_mode = st_mode;2581 if ((st_mode ^ patch->old_mode) & S_IFMT)2582 return error("%s: wrong type", old_name);2583 if (st_mode != patch->old_mode)2584 warning("%s has type %o, expected %o",2585 old_name, st_mode, patch->old_mode);2586 if (!patch->new_mode && !patch->is_delete)2587 patch->new_mode = st_mode;2588 return 0;25892590 is_new:2591 patch->is_new = 1;2592 patch->is_delete = 0;2593 patch->old_name = NULL;2594 return 0;2595}25962597static int check_patch(struct patch *patch)2598{2599 struct stat st;2600 const char *old_name = patch->old_name;2601 const char *new_name = patch->new_name;2602 const char *name = old_name ? old_name : new_name;2603 struct cache_entry *ce = NULL;2604 struct patch *tpatch;2605 int ok_if_exists;2606 int status;26072608 patch->rejected = 1; /* we will drop this after we succeed */26092610 status = check_preimage(patch, &ce, &st);2611 if (status)2612 return status;2613 old_name = patch->old_name;26142615 if ((tpatch = in_fn_table(new_name)) &&2616 (was_deleted(tpatch) || to_be_deleted(tpatch)))2617 /*2618 * A type-change diff is always split into a patch to2619 * delete old, immediately followed by a patch to2620 * create new (see diff.c::run_diff()); in such a case2621 * it is Ok that the entry to be deleted by the2622 * previous patch is still in the working tree and in2623 * the index.2624 */2625 ok_if_exists = 1;2626 else2627 ok_if_exists = 0;26282629 if (new_name &&2630 ((0 < patch->is_new) | (0 < patch->is_rename) | patch->is_copy)) {2631 if (check_index &&2632 cache_name_pos(new_name, strlen(new_name)) >= 0 &&2633 !ok_if_exists)2634 return error("%s: already exists in index", new_name);2635 if (!cached) {2636 int err = check_to_create_blob(new_name, ok_if_exists);2637 if (err)2638 return err;2639 }2640 if (!patch->new_mode) {2641 if (0 < patch->is_new)2642 patch->new_mode = S_IFREG | 0644;2643 else2644 patch->new_mode = patch->old_mode;2645 }2646 }26472648 if (new_name && old_name) {2649 int same = !strcmp(old_name, new_name);2650 if (!patch->new_mode)2651 patch->new_mode = patch->old_mode;2652 if ((patch->old_mode ^ patch->new_mode) & S_IFMT)2653 return error("new mode (%o) of %s does not match old mode (%o)%s%s",2654 patch->new_mode, new_name, patch->old_mode,2655 same ? "" : " of ", same ? "" : old_name);2656 }26572658 if (apply_data(patch, &st, ce) < 0)2659 return error("%s: patch does not apply", name);2660 patch->rejected = 0;2661 return 0;2662}26632664static int check_patch_list(struct patch *patch)2665{2666 int err = 0;26672668 prepare_fn_table(patch);2669 while (patch) {2670 if (apply_verbosely)2671 say_patch_name(stderr,2672 "Checking patch ", patch, "...\n");2673 err |= check_patch(patch);2674 patch = patch->next;2675 }2676 return err;2677}26782679/* This function tries to read the sha1 from the current index */2680static int get_current_sha1(const char *path, unsigned char *sha1)2681{2682 int pos;26832684 if (read_cache() < 0)2685 return -1;2686 pos = cache_name_pos(path, strlen(path));2687 if (pos < 0)2688 return -1;2689 hashcpy(sha1, active_cache[pos]->sha1);2690 return 0;2691}26922693/* Build an index that contains the just the files needed for a 3way merge */2694static void build_fake_ancestor(struct patch *list, const char *filename)2695{2696 struct patch *patch;2697 struct index_state result = { NULL };2698 int fd;26992700 /* Once we start supporting the reverse patch, it may be2701 * worth showing the new sha1 prefix, but until then...2702 */2703 for (patch = list; patch; patch = patch->next) {2704 const unsigned char *sha1_ptr;2705 unsigned char sha1[20];2706 struct cache_entry *ce;2707 const char *name;27082709 name = patch->old_name ? patch->old_name : patch->new_name;2710 if (0 < patch->is_new)2711 continue;2712 else if (get_sha1(patch->old_sha1_prefix, sha1))2713 /* git diff has no index line for mode/type changes */2714 if (!patch->lines_added && !patch->lines_deleted) {2715 if (get_current_sha1(patch->new_name, sha1) ||2716 get_current_sha1(patch->old_name, sha1))2717 die("mode change for %s, which is not "2718 "in current HEAD", name);2719 sha1_ptr = sha1;2720 } else2721 die("sha1 information is lacking or useless "2722 "(%s).", name);2723 else2724 sha1_ptr = sha1;27252726 ce = make_cache_entry(patch->old_mode, sha1_ptr, name, 0, 0);2727 if (!ce)2728 die("make_cache_entry failed for path '%s'", name);2729 if (add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))2730 die ("Could not add %s to temporary index", name);2731 }27322733 fd = open(filename, O_WRONLY | O_CREAT, 0666);2734 if (fd < 0 || write_index(&result, fd) || close(fd))2735 die ("Could not write temporary index to %s", filename);27362737 discard_index(&result);2738}27392740static void stat_patch_list(struct patch *patch)2741{2742 int files, adds, dels;27432744 for (files = adds = dels = 0 ; patch ; patch = patch->next) {2745 files++;2746 adds += patch->lines_added;2747 dels += patch->lines_deleted;2748 show_stats(patch);2749 }27502751 printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);2752}27532754static void numstat_patch_list(struct patch *patch)2755{2756 for ( ; patch; patch = patch->next) {2757 const char *name;2758 name = patch->new_name ? patch->new_name : patch->old_name;2759 if (patch->is_binary)2760 printf("-\t-\t");2761 else2762 printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);2763 write_name_quoted(name, stdout, line_termination);2764 }2765}27662767static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)2768{2769 if (mode)2770 printf(" %s mode %06o %s\n", newdelete, mode, name);2771 else2772 printf(" %s %s\n", newdelete, name);2773}27742775static void show_mode_change(struct patch *p, int show_name)2776{2777 if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {2778 if (show_name)2779 printf(" mode change %06o => %06o %s\n",2780 p->old_mode, p->new_mode, p->new_name);2781 else2782 printf(" mode change %06o => %06o\n",2783 p->old_mode, p->new_mode);2784 }2785}27862787static void show_rename_copy(struct patch *p)2788{2789 const char *renamecopy = p->is_rename ? "rename" : "copy";2790 const char *old, *new;27912792 /* Find common prefix */2793 old = p->old_name;2794 new = p->new_name;2795 while (1) {2796 const char *slash_old, *slash_new;2797 slash_old = strchr(old, '/');2798 slash_new = strchr(new, '/');2799 if (!slash_old ||2800 !slash_new ||2801 slash_old - old != slash_new - new ||2802 memcmp(old, new, slash_new - new))2803 break;2804 old = slash_old + 1;2805 new = slash_new + 1;2806 }2807 /* p->old_name thru old is the common prefix, and old and new2808 * through the end of names are renames2809 */2810 if (old != p->old_name)2811 printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,2812 (int)(old - p->old_name), p->old_name,2813 old, new, p->score);2814 else2815 printf(" %s %s => %s (%d%%)\n", renamecopy,2816 p->old_name, p->new_name, p->score);2817 show_mode_change(p, 0);2818}28192820static void summary_patch_list(struct patch *patch)2821{2822 struct patch *p;28232824 for (p = patch; p; p = p->next) {2825 if (p->is_new)2826 show_file_mode_name("create", p->new_mode, p->new_name);2827 else if (p->is_delete)2828 show_file_mode_name("delete", p->old_mode, p->old_name);2829 else {2830 if (p->is_rename || p->is_copy)2831 show_rename_copy(p);2832 else {2833 if (p->score) {2834 printf(" rewrite %s (%d%%)\n",2835 p->new_name, p->score);2836 show_mode_change(p, 0);2837 }2838 else2839 show_mode_change(p, 1);2840 }2841 }2842 }2843}28442845static void patch_stats(struct patch *patch)2846{2847 int lines = patch->lines_added + patch->lines_deleted;28482849 if (lines > max_change)2850 max_change = lines;2851 if (patch->old_name) {2852 int len = quote_c_style(patch->old_name, NULL, NULL, 0);2853 if (!len)2854 len = strlen(patch->old_name);2855 if (len > max_len)2856 max_len = len;2857 }2858 if (patch->new_name) {2859 int len = quote_c_style(patch->new_name, NULL, NULL, 0);2860 if (!len)2861 len = strlen(patch->new_name);2862 if (len > max_len)2863 max_len = len;2864 }2865}28662867static void remove_file(struct patch *patch, int rmdir_empty)2868{2869 if (update_index) {2870 if (remove_file_from_cache(patch->old_name) < 0)2871 die("unable to remove %s from index", patch->old_name);2872 }2873 if (!cached) {2874 if (S_ISGITLINK(patch->old_mode)) {2875 if (rmdir(patch->old_name))2876 warning("unable to remove submodule %s",2877 patch->old_name);2878 } else if (!unlink_or_warn(patch->old_name) && rmdir_empty) {2879 remove_path(patch->old_name);2880 }2881 }2882}28832884static void add_index_file(const char *path, unsigned mode, void *buf, unsigned long size)2885{2886 struct stat st;2887 struct cache_entry *ce;2888 int namelen = strlen(path);2889 unsigned ce_size = cache_entry_size(namelen);28902891 if (!update_index)2892 return;28932894 ce = xcalloc(1, ce_size);2895 memcpy(ce->name, path, namelen);2896 ce->ce_mode = create_ce_mode(mode);2897 ce->ce_flags = namelen;2898 if (S_ISGITLINK(mode)) {2899 const char *s = buf;29002901 if (get_sha1_hex(s + strlen("Subproject commit "), ce->sha1))2902 die("corrupt patch for subproject %s", path);2903 } else {2904 if (!cached) {2905 if (lstat(path, &st) < 0)2906 die_errno("unable to stat newly created file '%s'",2907 path);2908 fill_stat_cache_info(ce, &st);2909 }2910 if (write_sha1_file(buf, size, blob_type, ce->sha1) < 0)2911 die("unable to create backing store for newly created file %s", path);2912 }2913 if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)2914 die("unable to add cache entry for %s", path);2915}29162917static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)2918{2919 int fd;2920 struct strbuf nbuf = STRBUF_INIT;29212922 if (S_ISGITLINK(mode)) {2923 struct stat st;2924 if (!lstat(path, &st) && S_ISDIR(st.st_mode))2925 return 0;2926 return mkdir(path, 0777);2927 }29282929 if (has_symlinks && S_ISLNK(mode))2930 /* Although buf:size is counted string, it also is NUL2931 * terminated.2932 */2933 return symlink(buf, path);29342935 fd = open(path, O_CREAT | O_EXCL | O_WRONLY, (mode & 0100) ? 0777 : 0666);2936 if (fd < 0)2937 return -1;29382939 if (convert_to_working_tree(path, buf, size, &nbuf)) {2940 size = nbuf.len;2941 buf = nbuf.buf;2942 }2943 write_or_die(fd, buf, size);2944 strbuf_release(&nbuf);29452946 if (close(fd) < 0)2947 die_errno("closing file '%s'", path);2948 return 0;2949}29502951/*2952 * We optimistically assume that the directories exist,2953 * which is true 99% of the time anyway. If they don't,2954 * we create them and try again.2955 */2956static void create_one_file(char *path, unsigned mode, const char *buf, unsigned long size)2957{2958 if (cached)2959 return;2960 if (!try_create_file(path, mode, buf, size))2961 return;29622963 if (errno == ENOENT) {2964 if (safe_create_leading_directories(path))2965 return;2966 if (!try_create_file(path, mode, buf, size))2967 return;2968 }29692970 if (errno == EEXIST || errno == EACCES) {2971 /* We may be trying to create a file where a directory2972 * used to be.2973 */2974 struct stat st;2975 if (!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))2976 errno = EEXIST;2977 }29782979 if (errno == EEXIST) {2980 unsigned int nr = getpid();29812982 for (;;) {2983 char newpath[PATH_MAX];2984 mksnpath(newpath, sizeof(newpath), "%s~%u", path, nr);2985 if (!try_create_file(newpath, mode, buf, size)) {2986 if (!rename(newpath, path))2987 return;2988 unlink_or_warn(newpath);2989 break;2990 }2991 if (errno != EEXIST)2992 break;2993 ++nr;2994 }2995 }2996 die_errno("unable to write file '%s' mode %o", path, mode);2997}29982999static void create_file(struct patch *patch)3000{3001 char *path = patch->new_name;3002 unsigned mode = patch->new_mode;3003 unsigned long size = patch->resultsize;3004 char *buf = patch->result;30053006 if (!mode)3007 mode = S_IFREG | 0644;3008 create_one_file(path, mode, buf, size);3009 add_index_file(path, mode, buf, size);3010}30113012/* phase zero is to remove, phase one is to create */3013static void write_out_one_result(struct patch *patch, int phase)3014{3015 if (patch->is_delete > 0) {3016 if (phase == 0)3017 remove_file(patch, 1);3018 return;3019 }3020 if (patch->is_new > 0 || patch->is_copy) {3021 if (phase == 1)3022 create_file(patch);3023 return;3024 }3025 /*3026 * Rename or modification boils down to the same3027 * thing: remove the old, write the new3028 */3029 if (phase == 0)3030 remove_file(patch, patch->is_rename);3031 if (phase == 1)3032 create_file(patch);3033}30343035static int write_out_one_reject(struct patch *patch)3036{3037 FILE *rej;3038 char namebuf[PATH_MAX];3039 struct fragment *frag;3040 int cnt = 0;30413042 for (cnt = 0, frag = patch->fragments; frag; frag = frag->next) {3043 if (!frag->rejected)3044 continue;3045 cnt++;3046 }30473048 if (!cnt) {3049 if (apply_verbosely)3050 say_patch_name(stderr,3051 "Applied patch ", patch, " cleanly.\n");3052 return 0;3053 }30543055 /* This should not happen, because a removal patch that leaves3056 * contents are marked "rejected" at the patch level.3057 */3058 if (!patch->new_name)3059 die("internal error");30603061 /* Say this even without --verbose */3062 say_patch_name(stderr, "Applying patch ", patch, " with");3063 fprintf(stderr, " %d rejects...\n", cnt);30643065 cnt = strlen(patch->new_name);3066 if (ARRAY_SIZE(namebuf) <= cnt + 5) {3067 cnt = ARRAY_SIZE(namebuf) - 5;3068 warning("truncating .rej filename to %.*s.rej",3069 cnt - 1, patch->new_name);3070 }3071 memcpy(namebuf, patch->new_name, cnt);3072 memcpy(namebuf + cnt, ".rej", 5);30733074 rej = fopen(namebuf, "w");3075 if (!rej)3076 return error("cannot open %s: %s", namebuf, strerror(errno));30773078 /* Normal git tools never deal with .rej, so do not pretend3079 * this is a git patch by saying --git nor give extended3080 * headers. While at it, maybe please "kompare" that wants3081 * the trailing TAB and some garbage at the end of line ;-).3082 */3083 fprintf(rej, "diff a/%s b/%s\t(rejected hunks)\n",3084 patch->new_name, patch->new_name);3085 for (cnt = 1, frag = patch->fragments;3086 frag;3087 cnt++, frag = frag->next) {3088 if (!frag->rejected) {3089 fprintf(stderr, "Hunk #%d applied cleanly.\n", cnt);3090 continue;3091 }3092 fprintf(stderr, "Rejected hunk #%d.\n", cnt);3093 fprintf(rej, "%.*s", frag->size, frag->patch);3094 if (frag->patch[frag->size-1] != '\n')3095 fputc('\n', rej);3096 }3097 fclose(rej);3098 return -1;3099}31003101static int write_out_results(struct patch *list, int skipped_patch)3102{3103 int phase;3104 int errs = 0;3105 struct patch *l;31063107 if (!list && !skipped_patch)3108 return error("No changes");31093110 for (phase = 0; phase < 2; phase++) {3111 l = list;3112 while (l) {3113 if (l->rejected)3114 errs = 1;3115 else {3116 write_out_one_result(l, phase);3117 if (phase == 1 && write_out_one_reject(l))3118 errs = 1;3119 }3120 l = l->next;3121 }3122 }3123 return errs;3124}31253126static struct lock_file lock_file;31273128static struct string_list limit_by_name;3129static int has_include;3130static void add_name_limit(const char *name, int exclude)3131{3132 struct string_list_item *it;31333134 it = string_list_append(name, &limit_by_name);3135 it->util = exclude ? NULL : (void *) 1;3136}31373138static int use_patch(struct patch *p)3139{3140 const char *pathname = p->new_name ? p->new_name : p->old_name;3141 int i;31423143 /* Paths outside are not touched regardless of "--include" */3144 if (0 < prefix_length) {3145 int pathlen = strlen(pathname);3146 if (pathlen <= prefix_length ||3147 memcmp(prefix, pathname, prefix_length))3148 return 0;3149 }31503151 /* See if it matches any of exclude/include rule */3152 for (i = 0; i < limit_by_name.nr; i++) {3153 struct string_list_item *it = &limit_by_name.items[i];3154 if (!fnmatch(it->string, pathname, 0))3155 return (it->util != NULL);3156 }31573158 /*3159 * If we had any include, a path that does not match any rule is3160 * not used. Otherwise, we saw bunch of exclude rules (or none)3161 * and such a path is used.3162 */3163 return !has_include;3164}316531663167static void prefix_one(char **name)3168{3169 char *old_name = *name;3170 if (!old_name)3171 return;3172 *name = xstrdup(prefix_filename(prefix, prefix_length, *name));3173 free(old_name);3174}31753176static void prefix_patches(struct patch *p)3177{3178 if (!prefix || p->is_toplevel_relative)3179 return;3180 for ( ; p; p = p->next) {3181 if (p->new_name == p->old_name) {3182 char *prefixed = p->new_name;3183 prefix_one(&prefixed);3184 p->new_name = p->old_name = prefixed;3185 }3186 else {3187 prefix_one(&p->new_name);3188 prefix_one(&p->old_name);3189 }3190 }3191}31923193#define INACCURATE_EOF (1<<0)3194#define RECOUNT (1<<1)31953196static int apply_patch(int fd, const char *filename, int options)3197{3198 size_t offset;3199 struct strbuf buf = STRBUF_INIT;3200 struct patch *list = NULL, **listp = &list;3201 int skipped_patch = 0;32023203 /* FIXME - memory leak when using multiple patch files as inputs */3204 memset(&fn_table, 0, sizeof(struct string_list));3205 patch_input_file = filename;3206 read_patch_file(&buf, fd);3207 offset = 0;3208 while (offset < buf.len) {3209 struct patch *patch;3210 int nr;32113212 patch = xcalloc(1, sizeof(*patch));3213 patch->inaccurate_eof = !!(options & INACCURATE_EOF);3214 patch->recount = !!(options & RECOUNT);3215 nr = parse_chunk(buf.buf + offset, buf.len - offset, patch);3216 if (nr < 0)3217 break;3218 if (apply_in_reverse)3219 reverse_patches(patch);3220 if (prefix)3221 prefix_patches(patch);3222 if (use_patch(patch)) {3223 patch_stats(patch);3224 *listp = patch;3225 listp = &patch->next;3226 }3227 else {3228 /* perhaps free it a bit better? */3229 free(patch);3230 skipped_patch++;3231 }3232 offset += nr;3233 }32343235 if (whitespace_error && (ws_error_action == die_on_ws_error))3236 apply = 0;32373238 update_index = check_index && apply;3239 if (update_index && newfd < 0)3240 newfd = hold_locked_index(&lock_file, 1);32413242 if (check_index) {3243 if (read_cache() < 0)3244 die("unable to read index file");3245 }32463247 if ((check || apply) &&3248 check_patch_list(list) < 0 &&3249 !apply_with_reject)3250 exit(1);32513252 if (apply && write_out_results(list, skipped_patch))3253 exit(1);32543255 if (fake_ancestor)3256 build_fake_ancestor(list, fake_ancestor);32573258 if (diffstat)3259 stat_patch_list(list);32603261 if (numstat)3262 numstat_patch_list(list);32633264 if (summary)3265 summary_patch_list(list);32663267 strbuf_release(&buf);3268 return 0;3269}32703271static int git_apply_config(const char *var, const char *value, void *cb)3272{3273 if (!strcmp(var, "apply.whitespace"))3274 return git_config_string(&apply_default_whitespace, var, value);3275 return git_default_config(var, value, cb);3276}32773278static int option_parse_exclude(const struct option *opt,3279 const char *arg, int unset)3280{3281 add_name_limit(arg, 1);3282 return 0;3283}32843285static int option_parse_include(const struct option *opt,3286 const char *arg, int unset)3287{3288 add_name_limit(arg, 0);3289 has_include = 1;3290 return 0;3291}32923293static int option_parse_p(const struct option *opt,3294 const char *arg, int unset)3295{3296 p_value = atoi(arg);3297 p_value_known = 1;3298 return 0;3299}33003301static int option_parse_z(const struct option *opt,3302 const char *arg, int unset)3303{3304 if (unset)3305 line_termination = '\n';3306 else3307 line_termination = 0;3308 return 0;3309}33103311static int option_parse_whitespace(const struct option *opt,3312 const char *arg, int unset)3313{3314 const char **whitespace_option = opt->value;33153316 *whitespace_option = arg;3317 parse_whitespace_option(arg);3318 return 0;3319}33203321static int option_parse_directory(const struct option *opt,3322 const char *arg, int unset)3323{3324 root_len = strlen(arg);3325 if (root_len && arg[root_len - 1] != '/') {3326 char *new_root;3327 root = new_root = xmalloc(root_len + 2);3328 strcpy(new_root, arg);3329 strcpy(new_root + root_len++, "/");3330 } else3331 root = arg;3332 return 0;3333}33343335int cmd_apply(int argc, const char **argv, const char *unused_prefix)3336{3337 int i;3338 int errs = 0;3339 int is_not_gitdir;3340 int binary;3341 int force_apply = 0;33423343 const char *whitespace_option = NULL;33443345 struct option builtin_apply_options[] = {3346 { OPTION_CALLBACK, 0, "exclude", NULL, "path",3347 "don't apply changes matching the given path",3348 0, option_parse_exclude },3349 { OPTION_CALLBACK, 0, "include", NULL, "path",3350 "apply changes matching the given path",3351 0, option_parse_include },3352 { OPTION_CALLBACK, 'p', NULL, NULL, "num",3353 "remove <num> leading slashes from traditional diff paths",3354 0, option_parse_p },3355 OPT_BOOLEAN(0, "no-add", &no_add,3356 "ignore additions made by the patch"),3357 OPT_BOOLEAN(0, "stat", &diffstat,3358 "instead of applying the patch, output diffstat for the input"),3359 { OPTION_BOOLEAN, 0, "allow-binary-replacement", &binary,3360 NULL, "old option, now no-op",3361 PARSE_OPT_HIDDEN | PARSE_OPT_NOARG },3362 { OPTION_BOOLEAN, 0, "binary", &binary,3363 NULL, "old option, now no-op",3364 PARSE_OPT_HIDDEN | PARSE_OPT_NOARG },3365 OPT_BOOLEAN(0, "numstat", &numstat,3366 "shows number of added and deleted lines in decimal notation"),3367 OPT_BOOLEAN(0, "summary", &summary,3368 "instead of applying the patch, output a summary for the input"),3369 OPT_BOOLEAN(0, "check", &check,3370 "instead of applying the patch, see if the patch is applicable"),3371 OPT_BOOLEAN(0, "index", &check_index,3372 "make sure the patch is applicable to the current index"),3373 OPT_BOOLEAN(0, "cached", &cached,3374 "apply a patch without touching the working tree"),3375 OPT_BOOLEAN(0, "apply", &force_apply,3376 "also apply the patch (use with --stat/--summary/--check)"),3377 OPT_FILENAME(0, "build-fake-ancestor", &fake_ancestor,3378 "build a temporary index based on embedded index information"),3379 { OPTION_CALLBACK, 'z', NULL, NULL, NULL,3380 "paths are separated with NUL character",3381 PARSE_OPT_NOARG, option_parse_z },3382 OPT_INTEGER('C', NULL, &p_context,3383 "ensure at least <n> lines of context match"),3384 { OPTION_CALLBACK, 0, "whitespace", &whitespace_option, "action",3385 "detect new or modified lines that have whitespace errors",3386 0, option_parse_whitespace },3387 OPT_BOOLEAN('R', "reverse", &apply_in_reverse,3388 "apply the patch in reverse"),3389 OPT_BOOLEAN(0, "unidiff-zero", &unidiff_zero,3390 "don't expect at least one line of context"),3391 OPT_BOOLEAN(0, "reject", &apply_with_reject,3392 "leave the rejected hunks in corresponding *.rej files"),3393 OPT__VERBOSE(&apply_verbosely),3394 OPT_BIT(0, "inaccurate-eof", &options,3395 "tolerate incorrectly detected missing new-line at the end of file",3396 INACCURATE_EOF),3397 OPT_BIT(0, "recount", &options,3398 "do not trust the line counts in the hunk headers",3399 RECOUNT),3400 { OPTION_CALLBACK, 0, "directory", NULL, "root",3401 "prepend <root> to all filenames",3402 0, option_parse_directory },3403 OPT_END()3404 };34053406 prefix = setup_git_directory_gently(&is_not_gitdir);3407 prefix_length = prefix ? strlen(prefix) : 0;3408 git_config(git_apply_config, NULL);3409 if (apply_default_whitespace)3410 parse_whitespace_option(apply_default_whitespace);34113412 argc = parse_options(argc, argv, prefix, builtin_apply_options,3413 apply_usage, 0);34143415 if (apply_with_reject)3416 apply = apply_verbosely = 1;3417 if (!force_apply && (diffstat || numstat || summary || check || fake_ancestor))3418 apply = 0;3419 if (check_index && is_not_gitdir)3420 die("--index outside a repository");3421 if (cached) {3422 if (is_not_gitdir)3423 die("--cached outside a repository");3424 check_index = 1;3425 }3426 for (i = 0; i < argc; i++) {3427 const char *arg = argv[i];3428 int fd;34293430 if (!strcmp(arg, "-")) {3431 errs |= apply_patch(0, "<stdin>", options);3432 read_stdin = 0;3433 continue;3434 } else if (0 < prefix_length)3435 arg = prefix_filename(prefix, prefix_length, arg);34363437 fd = open(arg, O_RDONLY);3438 if (fd < 0)3439 die_errno("can't open patch '%s'", arg);3440 read_stdin = 0;3441 set_default_whitespace_mode(whitespace_option);3442 errs |= apply_patch(fd, arg, options);3443 close(fd);3444 }3445 set_default_whitespace_mode(whitespace_option);3446 if (read_stdin)3447 errs |= apply_patch(0, "<stdin>", options);3448 if (whitespace_error) {3449 if (squelch_whitespace_errors &&3450 squelch_whitespace_errors < whitespace_error) {3451 int squelched =3452 whitespace_error - squelch_whitespace_errors;3453 warning("squelched %d "3454 "whitespace error%s",3455 squelched,3456 squelched == 1 ? "" : "s");3457 }3458 if (ws_error_action == die_on_ws_error)3459 die("%d line%s add%s whitespace errors.",3460 whitespace_error,3461 whitespace_error == 1 ? "" : "s",3462 whitespace_error == 1 ? "s" : "");3463 if (applied_after_fixing_ws && apply)3464 warning("%d line%s applied after"3465 " fixing whitespace errors.",3466 applied_after_fixing_ws,3467 applied_after_fixing_ws == 1 ? "" : "s");3468 else if (whitespace_error)3469 warning("%d line%s add%s whitespace errors.",3470 whitespace_error,3471 whitespace_error == 1 ? "" : "s",3472 whitespace_error == 1 ? "s" : "");3473 }34743475 if (update_index) {3476 if (write_cache(newfd, active_cache, active_nr) ||3477 commit_locked_index(&lock_file))3478 die("Unable to write new index file");3479 }34803481 return !!errs;3482}