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 16/* 17 * --check turns on checking that the working tree matches the 18 * files that are being modified, but doesn't apply the patch 19 * --stat does just a diffstat, and doesn't actually apply 20 * --numstat does numeric diffstat, and doesn't actually apply 21 * --index-info shows the old and new index info for paths if available. 22 * --index updates the cache as well. 23 * --cached updates only the cache without ever touching the working tree. 24 */ 25static const char*prefix; 26static int prefix_length = -1; 27static int newfd = -1; 28 29static int unidiff_zero; 30static int p_value =1; 31static int p_value_known; 32static int check_index; 33static int update_index; 34static int cached; 35static int diffstat; 36static int numstat; 37static int summary; 38static int check; 39static int apply =1; 40static int apply_in_reverse; 41static int apply_with_reject; 42static int apply_verbosely; 43static int no_add; 44static const char*fake_ancestor; 45static int line_termination ='\n'; 46static unsigned long p_context = ULONG_MAX; 47static const char apply_usage[] = 48"git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--cached] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [--reverse] [--reject] [--verbose] [-z] [-pNUM] [-CNUM] [--whitespace=<nowarn|warn|fix|error|error-all>] <patch>..."; 49 50static enum ws_error_action { 51 nowarn_ws_error, 52 warn_on_ws_error, 53 die_on_ws_error, 54 correct_ws_error, 55} ws_error_action = warn_on_ws_error; 56static int whitespace_error; 57static int squelch_whitespace_errors =5; 58static int applied_after_fixing_ws; 59static const char*patch_input_file; 60 61static voidparse_whitespace_option(const char*option) 62{ 63if(!option) { 64 ws_error_action = warn_on_ws_error; 65return; 66} 67if(!strcmp(option,"warn")) { 68 ws_error_action = warn_on_ws_error; 69return; 70} 71if(!strcmp(option,"nowarn")) { 72 ws_error_action = nowarn_ws_error; 73return; 74} 75if(!strcmp(option,"error")) { 76 ws_error_action = die_on_ws_error; 77return; 78} 79if(!strcmp(option,"error-all")) { 80 ws_error_action = die_on_ws_error; 81 squelch_whitespace_errors =0; 82return; 83} 84if(!strcmp(option,"strip") || !strcmp(option,"fix")) { 85 ws_error_action = correct_ws_error; 86return; 87} 88die("unrecognized whitespace option '%s'", option); 89} 90 91static voidset_default_whitespace_mode(const char*whitespace_option) 92{ 93if(!whitespace_option && !apply_default_whitespace) 94 ws_error_action = (apply ? warn_on_ws_error : nowarn_ws_error); 95} 96 97/* 98 * For "diff-stat" like behaviour, we keep track of the biggest change 99 * we've seen, and the longest filename. That allows us to do simple 100 * scaling. 101 */ 102static int max_change, max_len; 103 104/* 105 * Various "current state", notably line numbers and what 106 * file (and how) we're patching right now.. The "is_xxxx" 107 * things are flags, where -1 means "don't know yet". 108 */ 109static int linenr =1; 110 111/* 112 * This represents one "hunk" from a patch, starting with 113 * "@@ -oldpos,oldlines +newpos,newlines @@" marker. The 114 * patch text is pointed at by patch, and its byte length 115 * is stored in size. leading and trailing are the number 116 * of context lines. 117 */ 118struct fragment { 119unsigned long leading, trailing; 120unsigned long oldpos, oldlines; 121unsigned long newpos, newlines; 122const char*patch; 123int size; 124int rejected; 125struct fragment *next; 126}; 127 128/* 129 * When dealing with a binary patch, we reuse "leading" field 130 * to store the type of the binary hunk, either deflated "delta" 131 * or deflated "literal". 132 */ 133#define binary_patch_method leading 134#define BINARY_DELTA_DEFLATED 1 135#define BINARY_LITERAL_DEFLATED 2 136 137/* 138 * This represents a "patch" to a file, both metainfo changes 139 * such as creation/deletion, filemode and content changes represented 140 * as a series of fragments. 141 */ 142struct patch { 143char*new_name, *old_name, *def_name; 144unsigned int old_mode, new_mode; 145int is_new, is_delete;/* -1 = unknown, 0 = false, 1 = true */ 146int rejected; 147unsigned ws_rule; 148unsigned long deflate_origlen; 149int lines_added, lines_deleted; 150int score; 151unsigned int is_toplevel_relative:1; 152unsigned int inaccurate_eof:1; 153unsigned int is_binary:1; 154unsigned int is_copy:1; 155unsigned int is_rename:1; 156struct fragment *fragments; 157char*result; 158size_t resultsize; 159char old_sha1_prefix[41]; 160char new_sha1_prefix[41]; 161struct patch *next; 162}; 163 164/* 165 * A line in a file, len-bytes long (includes the terminating LF, 166 * except for an incomplete line at the end if the file ends with 167 * one), and its contents hashes to 'hash'. 168 */ 169struct line { 170size_t len; 171unsigned hash :24; 172unsigned flag :8; 173#define LINE_COMMON 1 174}; 175 176/* 177 * This represents a "file", which is an array of "lines". 178 */ 179struct image { 180char*buf; 181size_t len; 182size_t nr; 183size_t alloc; 184struct line *line_allocated; 185struct line *line; 186}; 187 188static uint32_thash_line(const char*cp,size_t len) 189{ 190size_t i; 191uint32_t h; 192for(i =0, h =0; i < len; i++) { 193if(!isspace(cp[i])) { 194 h = h *3+ (cp[i] &0xff); 195} 196} 197return h; 198} 199 200static voidadd_line_info(struct image *img,const char*bol,size_t len,unsigned flag) 201{ 202ALLOC_GROW(img->line_allocated, img->nr +1, img->alloc); 203 img->line_allocated[img->nr].len = len; 204 img->line_allocated[img->nr].hash =hash_line(bol, len); 205 img->line_allocated[img->nr].flag = flag; 206 img->nr++; 207} 208 209static voidprepare_image(struct image *image,char*buf,size_t len, 210int prepare_linetable) 211{ 212const char*cp, *ep; 213 214memset(image,0,sizeof(*image)); 215 image->buf = buf; 216 image->len = len; 217 218if(!prepare_linetable) 219return; 220 221 ep = image->buf + image->len; 222 cp = image->buf; 223while(cp < ep) { 224const char*next; 225for(next = cp; next < ep && *next !='\n'; next++) 226; 227if(next < ep) 228 next++; 229add_line_info(image, cp, next - cp,0); 230 cp = next; 231} 232 image->line = image->line_allocated; 233} 234 235static voidclear_image(struct image *image) 236{ 237free(image->buf); 238 image->buf = NULL; 239 image->len =0; 240} 241 242static voidsay_patch_name(FILE*output,const char*pre, 243struct patch *patch,const char*post) 244{ 245fputs(pre, output); 246if(patch->old_name && patch->new_name && 247strcmp(patch->old_name, patch->new_name)) { 248quote_c_style(patch->old_name, NULL, output,0); 249fputs(" => ", output); 250quote_c_style(patch->new_name, NULL, output,0); 251}else{ 252const char*n = patch->new_name; 253if(!n) 254 n = patch->old_name; 255quote_c_style(n, NULL, output,0); 256} 257fputs(post, output); 258} 259 260#define CHUNKSIZE (8192) 261#define SLOP (16) 262 263static voidread_patch_file(struct strbuf *sb,int fd) 264{ 265if(strbuf_read(sb, fd,0) <0) 266die("git-apply: read returned%s",strerror(errno)); 267 268/* 269 * Make sure that we have some slop in the buffer 270 * so that we can do speculative "memcmp" etc, and 271 * see to it that it is NUL-filled. 272 */ 273strbuf_grow(sb, SLOP); 274memset(sb->buf + sb->len,0, SLOP); 275} 276 277static unsigned longlinelen(const char*buffer,unsigned long size) 278{ 279unsigned long len =0; 280while(size--) { 281 len++; 282if(*buffer++ =='\n') 283break; 284} 285return len; 286} 287 288static intis_dev_null(const char*str) 289{ 290return!memcmp("/dev/null", str,9) &&isspace(str[9]); 291} 292 293#define TERM_SPACE 1 294#define TERM_TAB 2 295 296static intname_terminate(const char*name,int namelen,int c,int terminate) 297{ 298if(c ==' '&& !(terminate & TERM_SPACE)) 299return0; 300if(c =='\t'&& !(terminate & TERM_TAB)) 301return0; 302 303return1; 304} 305 306static char*find_name(const char*line,char*def,int p_value,int terminate) 307{ 308int len; 309const char*start = line; 310 311if(*line =='"') { 312struct strbuf name; 313 314/* 315 * Proposed "new-style" GNU patch/diff format; see 316 * http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2 317 */ 318strbuf_init(&name,0); 319if(!unquote_c_style(&name, line, NULL)) { 320char*cp; 321 322for(cp = name.buf; p_value; p_value--) { 323 cp =strchr(cp,'/'); 324if(!cp) 325break; 326 cp++; 327} 328if(cp) { 329/* name can later be freed, so we need 330 * to memmove, not just return cp 331 */ 332strbuf_remove(&name,0, cp - name.buf); 333free(def); 334returnstrbuf_detach(&name, NULL); 335} 336} 337strbuf_release(&name); 338} 339 340for(;;) { 341char c = *line; 342 343if(isspace(c)) { 344if(c =='\n') 345break; 346if(name_terminate(start, line-start, c, terminate)) 347break; 348} 349 line++; 350if(c =='/'&& !--p_value) 351 start = line; 352} 353if(!start) 354return def; 355 len = line - start; 356if(!len) 357return def; 358 359/* 360 * Generally we prefer the shorter name, especially 361 * if the other one is just a variation of that with 362 * something else tacked on to the end (ie "file.orig" 363 * or "file~"). 364 */ 365if(def) { 366int deflen =strlen(def); 367if(deflen < len && !strncmp(start, def, deflen)) 368return def; 369free(def); 370} 371 372returnxmemdupz(start, len); 373} 374 375static intcount_slashes(const char*cp) 376{ 377int cnt =0; 378char ch; 379 380while((ch = *cp++)) 381if(ch =='/') 382 cnt++; 383return cnt; 384} 385 386/* 387 * Given the string after "--- " or "+++ ", guess the appropriate 388 * p_value for the given patch. 389 */ 390static intguess_p_value(const char*nameline) 391{ 392char*name, *cp; 393int val = -1; 394 395if(is_dev_null(nameline)) 396return-1; 397 name =find_name(nameline, NULL,0, TERM_SPACE | TERM_TAB); 398if(!name) 399return-1; 400 cp =strchr(name,'/'); 401if(!cp) 402 val =0; 403else if(prefix) { 404/* 405 * Does it begin with "a/$our-prefix" and such? Then this is 406 * very likely to apply to our directory. 407 */ 408if(!strncmp(name, prefix, prefix_length)) 409 val =count_slashes(prefix); 410else{ 411 cp++; 412if(!strncmp(cp, prefix, prefix_length)) 413 val =count_slashes(prefix) +1; 414} 415} 416free(name); 417return val; 418} 419 420/* 421 * Get the name etc info from the --/+++ lines of a traditional patch header 422 * 423 * FIXME! The end-of-filename heuristics are kind of screwy. For existing 424 * files, we can happily check the index for a match, but for creating a 425 * new file we should try to match whatever "patch" does. I have no idea. 426 */ 427static voidparse_traditional_patch(const char*first,const char*second,struct patch *patch) 428{ 429char*name; 430 431 first +=4;/* skip "--- " */ 432 second +=4;/* skip "+++ " */ 433if(!p_value_known) { 434int p, q; 435 p =guess_p_value(first); 436 q =guess_p_value(second); 437if(p <0) p = q; 438if(0<= p && p == q) { 439 p_value = p; 440 p_value_known =1; 441} 442} 443if(is_dev_null(first)) { 444 patch->is_new =1; 445 patch->is_delete =0; 446 name =find_name(second, NULL, p_value, TERM_SPACE | TERM_TAB); 447 patch->new_name = name; 448}else if(is_dev_null(second)) { 449 patch->is_new =0; 450 patch->is_delete =1; 451 name =find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB); 452 patch->old_name = name; 453}else{ 454 name =find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB); 455 name =find_name(second, name, p_value, TERM_SPACE | TERM_TAB); 456 patch->old_name = patch->new_name = name; 457} 458if(!name) 459die("unable to find filename in patch at line%d", linenr); 460} 461 462static intgitdiff_hdrend(const char*line,struct patch *patch) 463{ 464return-1; 465} 466 467/* 468 * We're anal about diff header consistency, to make 469 * sure that we don't end up having strange ambiguous 470 * patches floating around. 471 * 472 * As a result, gitdiff_{old|new}name() will check 473 * their names against any previous information, just 474 * to make sure.. 475 */ 476static char*gitdiff_verify_name(const char*line,int isnull,char*orig_name,const char*oldnew) 477{ 478if(!orig_name && !isnull) 479returnfind_name(line, NULL, p_value, TERM_TAB); 480 481if(orig_name) { 482int len; 483const char*name; 484char*another; 485 name = orig_name; 486 len =strlen(name); 487if(isnull) 488die("git-apply: bad git-diff - expected /dev/null, got%son line%d", name, linenr); 489 another =find_name(line, NULL, p_value, TERM_TAB); 490if(!another ||memcmp(another, name, len)) 491die("git-apply: bad git-diff - inconsistent%sfilename on line%d", oldnew, linenr); 492free(another); 493return orig_name; 494} 495else{ 496/* expect "/dev/null" */ 497if(memcmp("/dev/null", line,9) || line[9] !='\n') 498die("git-apply: bad git-diff - expected /dev/null on line%d", linenr); 499return NULL; 500} 501} 502 503static intgitdiff_oldname(const char*line,struct patch *patch) 504{ 505 patch->old_name =gitdiff_verify_name(line, patch->is_new, patch->old_name,"old"); 506return0; 507} 508 509static intgitdiff_newname(const char*line,struct patch *patch) 510{ 511 patch->new_name =gitdiff_verify_name(line, patch->is_delete, patch->new_name,"new"); 512return0; 513} 514 515static intgitdiff_oldmode(const char*line,struct patch *patch) 516{ 517 patch->old_mode =strtoul(line, NULL,8); 518return0; 519} 520 521static intgitdiff_newmode(const char*line,struct patch *patch) 522{ 523 patch->new_mode =strtoul(line, NULL,8); 524return0; 525} 526 527static intgitdiff_delete(const char*line,struct patch *patch) 528{ 529 patch->is_delete =1; 530 patch->old_name = patch->def_name; 531returngitdiff_oldmode(line, patch); 532} 533 534static intgitdiff_newfile(const char*line,struct patch *patch) 535{ 536 patch->is_new =1; 537 patch->new_name = patch->def_name; 538returngitdiff_newmode(line, patch); 539} 540 541static intgitdiff_copysrc(const char*line,struct patch *patch) 542{ 543 patch->is_copy =1; 544 patch->old_name =find_name(line, NULL,0,0); 545return0; 546} 547 548static intgitdiff_copydst(const char*line,struct patch *patch) 549{ 550 patch->is_copy =1; 551 patch->new_name =find_name(line, NULL,0,0); 552return0; 553} 554 555static intgitdiff_renamesrc(const char*line,struct patch *patch) 556{ 557 patch->is_rename =1; 558 patch->old_name =find_name(line, NULL,0,0); 559return0; 560} 561 562static intgitdiff_renamedst(const char*line,struct patch *patch) 563{ 564 patch->is_rename =1; 565 patch->new_name =find_name(line, NULL,0,0); 566return0; 567} 568 569static intgitdiff_similarity(const char*line,struct patch *patch) 570{ 571if((patch->score =strtoul(line, NULL,10)) == ULONG_MAX) 572 patch->score =0; 573return0; 574} 575 576static intgitdiff_dissimilarity(const char*line,struct patch *patch) 577{ 578if((patch->score =strtoul(line, NULL,10)) == ULONG_MAX) 579 patch->score =0; 580return0; 581} 582 583static intgitdiff_index(const char*line,struct patch *patch) 584{ 585/* 586 * index line is N hexadecimal, "..", N hexadecimal, 587 * and optional space with octal mode. 588 */ 589const char*ptr, *eol; 590int len; 591 592 ptr =strchr(line,'.'); 593if(!ptr || ptr[1] !='.'||40< ptr - line) 594return0; 595 len = ptr - line; 596memcpy(patch->old_sha1_prefix, line, len); 597 patch->old_sha1_prefix[len] =0; 598 599 line = ptr +2; 600 ptr =strchr(line,' '); 601 eol =strchr(line,'\n'); 602 603if(!ptr || eol < ptr) 604 ptr = eol; 605 len = ptr - line; 606 607if(40< len) 608return0; 609memcpy(patch->new_sha1_prefix, line, len); 610 patch->new_sha1_prefix[len] =0; 611if(*ptr ==' ') 612 patch->new_mode = patch->old_mode =strtoul(ptr+1, NULL,8); 613return0; 614} 615 616/* 617 * This is normal for a diff that doesn't change anything: we'll fall through 618 * into the next diff. Tell the parser to break out. 619 */ 620static intgitdiff_unrecognized(const char*line,struct patch *patch) 621{ 622return-1; 623} 624 625static const char*stop_at_slash(const char*line,int llen) 626{ 627int i; 628 629for(i =0; i < llen; i++) { 630int ch = line[i]; 631if(ch =='/') 632return line + i; 633} 634return NULL; 635} 636 637/* 638 * This is to extract the same name that appears on "diff --git" 639 * line. We do not find and return anything if it is a rename 640 * patch, and it is OK because we will find the name elsewhere. 641 * We need to reliably find name only when it is mode-change only, 642 * creation or deletion of an empty file. In any of these cases, 643 * both sides are the same name under a/ and b/ respectively. 644 */ 645static char*git_header_name(char*line,int llen) 646{ 647const char*name; 648const char*second = NULL; 649size_t len; 650 651 line +=strlen("diff --git "); 652 llen -=strlen("diff --git "); 653 654if(*line =='"') { 655const char*cp; 656struct strbuf first; 657struct strbuf sp; 658 659strbuf_init(&first,0); 660strbuf_init(&sp,0); 661 662if(unquote_c_style(&first, line, &second)) 663goto free_and_fail1; 664 665/* advance to the first slash */ 666 cp =stop_at_slash(first.buf, first.len); 667/* we do not accept absolute paths */ 668if(!cp || cp == first.buf) 669goto free_and_fail1; 670strbuf_remove(&first,0, cp +1- first.buf); 671 672/* 673 * second points at one past closing dq of name. 674 * find the second name. 675 */ 676while((second < line + llen) &&isspace(*second)) 677 second++; 678 679if(line + llen <= second) 680goto free_and_fail1; 681if(*second =='"') { 682if(unquote_c_style(&sp, second, NULL)) 683goto free_and_fail1; 684 cp =stop_at_slash(sp.buf, sp.len); 685if(!cp || cp == sp.buf) 686goto free_and_fail1; 687/* They must match, otherwise ignore */ 688if(strcmp(cp +1, first.buf)) 689goto free_and_fail1; 690strbuf_release(&sp); 691returnstrbuf_detach(&first, NULL); 692} 693 694/* unquoted second */ 695 cp =stop_at_slash(second, line + llen - second); 696if(!cp || cp == second) 697goto free_and_fail1; 698 cp++; 699if(line + llen - cp != first.len +1|| 700memcmp(first.buf, cp, first.len)) 701goto free_and_fail1; 702returnstrbuf_detach(&first, NULL); 703 704 free_and_fail1: 705strbuf_release(&first); 706strbuf_release(&sp); 707return NULL; 708} 709 710/* unquoted first name */ 711 name =stop_at_slash(line, llen); 712if(!name || name == line) 713return NULL; 714 name++; 715 716/* 717 * since the first name is unquoted, a dq if exists must be 718 * the beginning of the second name. 719 */ 720for(second = name; second < line + llen; second++) { 721if(*second =='"') { 722struct strbuf sp; 723const char*np; 724 725strbuf_init(&sp,0); 726if(unquote_c_style(&sp, second, NULL)) 727goto free_and_fail2; 728 729 np =stop_at_slash(sp.buf, sp.len); 730if(!np || np == sp.buf) 731goto free_and_fail2; 732 np++; 733 734 len = sp.buf + sp.len - np; 735if(len < second - name && 736!strncmp(np, name, len) && 737isspace(name[len])) { 738/* Good */ 739strbuf_remove(&sp,0, np - sp.buf); 740returnstrbuf_detach(&sp, NULL); 741} 742 743 free_and_fail2: 744strbuf_release(&sp); 745return NULL; 746} 747} 748 749/* 750 * Accept a name only if it shows up twice, exactly the same 751 * form. 752 */ 753for(len =0; ; len++) { 754switch(name[len]) { 755default: 756continue; 757case'\n': 758return NULL; 759case'\t':case' ': 760 second = name+len; 761for(;;) { 762char c = *second++; 763if(c =='\n') 764return NULL; 765if(c =='/') 766break; 767} 768if(second[len] =='\n'&& !memcmp(name, second, len)) { 769returnxmemdupz(name, len); 770} 771} 772} 773} 774 775/* Verify that we recognize the lines following a git header */ 776static intparse_git_header(char*line,int len,unsigned int size,struct patch *patch) 777{ 778unsigned long offset; 779 780/* A git diff has explicit new/delete information, so we don't guess */ 781 patch->is_new =0; 782 patch->is_delete =0; 783 784/* 785 * Some things may not have the old name in the 786 * rest of the headers anywhere (pure mode changes, 787 * or removing or adding empty files), so we get 788 * the default name from the header. 789 */ 790 patch->def_name =git_header_name(line, len); 791 792 line += len; 793 size -= len; 794 linenr++; 795for(offset = len ; size >0; offset += len, size -= len, line += len, linenr++) { 796static const struct opentry { 797const char*str; 798int(*fn)(const char*,struct patch *); 799} optable[] = { 800{"@@ -", gitdiff_hdrend }, 801{"--- ", gitdiff_oldname }, 802{"+++ ", gitdiff_newname }, 803{"old mode ", gitdiff_oldmode }, 804{"new mode ", gitdiff_newmode }, 805{"deleted file mode ", gitdiff_delete }, 806{"new file mode ", gitdiff_newfile }, 807{"copy from ", gitdiff_copysrc }, 808{"copy to ", gitdiff_copydst }, 809{"rename old ", gitdiff_renamesrc }, 810{"rename new ", gitdiff_renamedst }, 811{"rename from ", gitdiff_renamesrc }, 812{"rename to ", gitdiff_renamedst }, 813{"similarity index ", gitdiff_similarity }, 814{"dissimilarity index ", gitdiff_dissimilarity }, 815{"index ", gitdiff_index }, 816{"", gitdiff_unrecognized }, 817}; 818int i; 819 820 len =linelen(line, size); 821if(!len || line[len-1] !='\n') 822break; 823for(i =0; i <ARRAY_SIZE(optable); i++) { 824const struct opentry *p = optable + i; 825int oplen =strlen(p->str); 826if(len < oplen ||memcmp(p->str, line, oplen)) 827continue; 828if(p->fn(line + oplen, patch) <0) 829return offset; 830break; 831} 832} 833 834return offset; 835} 836 837static intparse_num(const char*line,unsigned long*p) 838{ 839char*ptr; 840 841if(!isdigit(*line)) 842return0; 843*p =strtoul(line, &ptr,10); 844return ptr - line; 845} 846 847static intparse_range(const char*line,int len,int offset,const char*expect, 848unsigned long*p1,unsigned long*p2) 849{ 850int digits, ex; 851 852if(offset <0|| offset >= len) 853return-1; 854 line += offset; 855 len -= offset; 856 857 digits =parse_num(line, p1); 858if(!digits) 859return-1; 860 861 offset += digits; 862 line += digits; 863 len -= digits; 864 865*p2 =1; 866if(*line ==',') { 867 digits =parse_num(line+1, p2); 868if(!digits) 869return-1; 870 871 offset += digits+1; 872 line += digits+1; 873 len -= digits+1; 874} 875 876 ex =strlen(expect); 877if(ex > len) 878return-1; 879if(memcmp(line, expect, ex)) 880return-1; 881 882return offset + ex; 883} 884 885/* 886 * Parse a unified diff fragment header of the 887 * form "@@ -a,b +c,d @@" 888 */ 889static intparse_fragment_header(char*line,int len,struct fragment *fragment) 890{ 891int offset; 892 893if(!len || line[len-1] !='\n') 894return-1; 895 896/* Figure out the number of lines in a fragment */ 897 offset =parse_range(line, len,4," +", &fragment->oldpos, &fragment->oldlines); 898 offset =parse_range(line, len, offset," @@", &fragment->newpos, &fragment->newlines); 899 900return offset; 901} 902 903static intfind_header(char*line,unsigned long size,int*hdrsize,struct patch *patch) 904{ 905unsigned long offset, len; 906 907 patch->is_toplevel_relative =0; 908 patch->is_rename = patch->is_copy =0; 909 patch->is_new = patch->is_delete = -1; 910 patch->old_mode = patch->new_mode =0; 911 patch->old_name = patch->new_name = NULL; 912for(offset =0; size >0; offset += len, size -= len, line += len, linenr++) { 913unsigned long nextlen; 914 915 len =linelen(line, size); 916if(!len) 917break; 918 919/* Testing this early allows us to take a few shortcuts.. */ 920if(len <6) 921continue; 922 923/* 924 * Make sure we don't find any unconnected patch fragments. 925 * That's a sign that we didn't find a header, and that a 926 * patch has become corrupted/broken up. 927 */ 928if(!memcmp("@@ -", line,4)) { 929struct fragment dummy; 930if(parse_fragment_header(line, len, &dummy) <0) 931continue; 932die("patch fragment without header at line%d: %.*s", 933 linenr, (int)len-1, line); 934} 935 936if(size < len +6) 937break; 938 939/* 940 * Git patch? It might not have a real patch, just a rename 941 * or mode change, so we handle that specially 942 */ 943if(!memcmp("diff --git ", line,11)) { 944int git_hdr_len =parse_git_header(line, len, size, patch); 945if(git_hdr_len <= len) 946continue; 947if(!patch->old_name && !patch->new_name) { 948if(!patch->def_name) 949die("git diff header lacks filename information (line%d)", linenr); 950 patch->old_name = patch->new_name = patch->def_name; 951} 952 patch->is_toplevel_relative =1; 953*hdrsize = git_hdr_len; 954return offset; 955} 956 957/* --- followed by +++ ? */ 958if(memcmp("--- ", line,4) ||memcmp("+++ ", line + len,4)) 959continue; 960 961/* 962 * We only accept unified patches, so we want it to 963 * at least have "@@ -a,b +c,d @@\n", which is 14 chars 964 * minimum ("@@ -0,0 +1 @@\n" is the shortest). 965 */ 966 nextlen =linelen(line + len, size - len); 967if(size < nextlen +14||memcmp("@@ -", line + len + nextlen,4)) 968continue; 969 970/* Ok, we'll consider it a patch */ 971parse_traditional_patch(line, line+len, patch); 972*hdrsize = len + nextlen; 973 linenr +=2; 974return offset; 975} 976return-1; 977} 978 979static voidcheck_whitespace(const char*line,int len,unsigned ws_rule) 980{ 981char*err; 982unsigned result =check_and_emit_line(line +1, len -1, ws_rule, 983 NULL, NULL, NULL, NULL); 984if(!result) 985return; 986 987 whitespace_error++; 988if(squelch_whitespace_errors && 989 squelch_whitespace_errors < whitespace_error) 990; 991else{ 992 err =whitespace_error_string(result); 993fprintf(stderr,"%s:%d:%s.\n%.*s\n", 994 patch_input_file, linenr, err, len -2, line +1); 995free(err); 996} 997} 998 999/*1000 * Parse a unified diff. Note that this really needs to parse each1001 * fragment separately, since the only way to know the difference1002 * between a "---" that is part of a patch, and a "---" that starts1003 * the next patch is to look at the line counts..1004 */1005static intparse_fragment(char*line,unsigned long size,1006struct patch *patch,struct fragment *fragment)1007{1008int added, deleted;1009int len =linelen(line, size), offset;1010unsigned long oldlines, newlines;1011unsigned long leading, trailing;10121013 offset =parse_fragment_header(line, len, fragment);1014if(offset <0)1015return-1;1016 oldlines = fragment->oldlines;1017 newlines = fragment->newlines;1018 leading =0;1019 trailing =0;10201021/* Parse the thing.. */1022 line += len;1023 size -= len;1024 linenr++;1025 added = deleted =0;1026for(offset = len;10270< size;1028 offset += len, size -= len, line += len, linenr++) {1029if(!oldlines && !newlines)1030break;1031 len =linelen(line, size);1032if(!len || line[len-1] !='\n')1033return-1;1034switch(*line) {1035default:1036return-1;1037case'\n':/* newer GNU diff, an empty context line */1038case' ':1039 oldlines--;1040 newlines--;1041if(!deleted && !added)1042 leading++;1043 trailing++;1044break;1045case'-':1046if(apply_in_reverse &&1047 ws_error_action != nowarn_ws_error)1048check_whitespace(line, len, patch->ws_rule);1049 deleted++;1050 oldlines--;1051 trailing =0;1052break;1053case'+':1054if(!apply_in_reverse &&1055 ws_error_action != nowarn_ws_error)1056check_whitespace(line, len, patch->ws_rule);1057 added++;1058 newlines--;1059 trailing =0;1060break;10611062/*1063 * We allow "\ No newline at end of file". Depending1064 * on locale settings when the patch was produced we1065 * don't know what this line looks like. The only1066 * thing we do know is that it begins with "\ ".1067 * Checking for 12 is just for sanity check -- any1068 * l10n of "\ No newline..." is at least that long.1069 */1070case'\\':1071if(len <12||memcmp(line,"\\",2))1072return-1;1073break;1074}1075}1076if(oldlines || newlines)1077return-1;1078 fragment->leading = leading;1079 fragment->trailing = trailing;10801081/*1082 * If a fragment ends with an incomplete line, we failed to include1083 * it in the above loop because we hit oldlines == newlines == 01084 * before seeing it.1085 */1086if(12< size && !memcmp(line,"\\",2))1087 offset +=linelen(line, size);10881089 patch->lines_added += added;1090 patch->lines_deleted += deleted;10911092if(0< patch->is_new && oldlines)1093returnerror("new file depends on old contents");1094if(0< patch->is_delete && newlines)1095returnerror("deleted file still has contents");1096return offset;1097}10981099static intparse_single_patch(char*line,unsigned long size,struct patch *patch)1100{1101unsigned long offset =0;1102unsigned long oldlines =0, newlines =0, context =0;1103struct fragment **fragp = &patch->fragments;11041105while(size >4&& !memcmp(line,"@@ -",4)) {1106struct fragment *fragment;1107int len;11081109 fragment =xcalloc(1,sizeof(*fragment));1110 len =parse_fragment(line, size, patch, fragment);1111if(len <=0)1112die("corrupt patch at line%d", linenr);1113 fragment->patch = line;1114 fragment->size = len;1115 oldlines += fragment->oldlines;1116 newlines += fragment->newlines;1117 context += fragment->leading + fragment->trailing;11181119*fragp = fragment;1120 fragp = &fragment->next;11211122 offset += len;1123 line += len;1124 size -= len;1125}11261127/*1128 * If something was removed (i.e. we have old-lines) it cannot1129 * be creation, and if something was added it cannot be1130 * deletion. However, the reverse is not true; --unified=01131 * patches that only add are not necessarily creation even1132 * though they do not have any old lines, and ones that only1133 * delete are not necessarily deletion.1134 *1135 * Unfortunately, a real creation/deletion patch do _not_ have1136 * any context line by definition, so we cannot safely tell it1137 * apart with --unified=0 insanity. At least if the patch has1138 * more than one hunk it is not creation or deletion.1139 */1140if(patch->is_new <0&&1141(oldlines || (patch->fragments && patch->fragments->next)))1142 patch->is_new =0;1143if(patch->is_delete <0&&1144(newlines || (patch->fragments && patch->fragments->next)))1145 patch->is_delete =0;1146if(!unidiff_zero || context) {1147/* If the user says the patch is not generated with1148 * --unified=0, or if we have seen context lines,1149 * then not having oldlines means the patch is creation,1150 * and not having newlines means the patch is deletion.1151 */1152if(patch->is_new <0&& !oldlines) {1153 patch->is_new =1;1154 patch->old_name = NULL;1155}1156if(patch->is_delete <0&& !newlines) {1157 patch->is_delete =1;1158 patch->new_name = NULL;1159}1160}11611162if(0< patch->is_new && oldlines)1163die("new file%sdepends on old contents", patch->new_name);1164if(0< patch->is_delete && newlines)1165die("deleted file%sstill has contents", patch->old_name);1166if(!patch->is_delete && !newlines && context)1167fprintf(stderr,"** warning: file%sbecomes empty but "1168"is not deleted\n", patch->new_name);11691170return offset;1171}11721173staticinlineintmetadata_changes(struct patch *patch)1174{1175return patch->is_rename >0||1176 patch->is_copy >0||1177 patch->is_new >0||1178 patch->is_delete ||1179(patch->old_mode && patch->new_mode &&1180 patch->old_mode != patch->new_mode);1181}11821183static char*inflate_it(const void*data,unsigned long size,1184unsigned long inflated_size)1185{1186 z_stream stream;1187void*out;1188int st;11891190memset(&stream,0,sizeof(stream));11911192 stream.next_in = (unsigned char*)data;1193 stream.avail_in = size;1194 stream.next_out = out =xmalloc(inflated_size);1195 stream.avail_out = inflated_size;1196inflateInit(&stream);1197 st =inflate(&stream, Z_FINISH);1198if((st != Z_STREAM_END) || stream.total_out != inflated_size) {1199free(out);1200return NULL;1201}1202return out;1203}12041205static struct fragment *parse_binary_hunk(char**buf_p,1206unsigned long*sz_p,1207int*status_p,1208int*used_p)1209{1210/*1211 * Expect a line that begins with binary patch method ("literal"1212 * or "delta"), followed by the length of data before deflating.1213 * a sequence of 'length-byte' followed by base-85 encoded data1214 * should follow, terminated by a newline.1215 *1216 * Each 5-byte sequence of base-85 encodes up to 4 bytes,1217 * and we would limit the patch line to 66 characters,1218 * so one line can fit up to 13 groups that would decode1219 * to 52 bytes max. The length byte 'A'-'Z' corresponds1220 * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.1221 */1222int llen, used;1223unsigned long size = *sz_p;1224char*buffer = *buf_p;1225int patch_method;1226unsigned long origlen;1227char*data = NULL;1228int hunk_size =0;1229struct fragment *frag;12301231 llen =linelen(buffer, size);1232 used = llen;12331234*status_p =0;12351236if(!prefixcmp(buffer,"delta ")) {1237 patch_method = BINARY_DELTA_DEFLATED;1238 origlen =strtoul(buffer +6, NULL,10);1239}1240else if(!prefixcmp(buffer,"literal ")) {1241 patch_method = BINARY_LITERAL_DEFLATED;1242 origlen =strtoul(buffer +8, NULL,10);1243}1244else1245return NULL;12461247 linenr++;1248 buffer += llen;1249while(1) {1250int byte_length, max_byte_length, newsize;1251 llen =linelen(buffer, size);1252 used += llen;1253 linenr++;1254if(llen ==1) {1255/* consume the blank line */1256 buffer++;1257 size--;1258break;1259}1260/*1261 * Minimum line is "A00000\n" which is 7-byte long,1262 * and the line length must be multiple of 5 plus 2.1263 */1264if((llen <7) || (llen-2) %5)1265goto corrupt;1266 max_byte_length = (llen -2) /5*4;1267 byte_length = *buffer;1268if('A'<= byte_length && byte_length <='Z')1269 byte_length = byte_length -'A'+1;1270else if('a'<= byte_length && byte_length <='z')1271 byte_length = byte_length -'a'+27;1272else1273goto corrupt;1274/* if the input length was not multiple of 4, we would1275 * have filler at the end but the filler should never1276 * exceed 3 bytes1277 */1278if(max_byte_length < byte_length ||1279 byte_length <= max_byte_length -4)1280goto corrupt;1281 newsize = hunk_size + byte_length;1282 data =xrealloc(data, newsize);1283if(decode_85(data + hunk_size, buffer +1, byte_length))1284goto corrupt;1285 hunk_size = newsize;1286 buffer += llen;1287 size -= llen;1288}12891290 frag =xcalloc(1,sizeof(*frag));1291 frag->patch =inflate_it(data, hunk_size, origlen);1292if(!frag->patch)1293goto corrupt;1294free(data);1295 frag->size = origlen;1296*buf_p = buffer;1297*sz_p = size;1298*used_p = used;1299 frag->binary_patch_method = patch_method;1300return frag;13011302 corrupt:1303free(data);1304*status_p = -1;1305error("corrupt binary patch at line%d: %.*s",1306 linenr-1, llen-1, buffer);1307return NULL;1308}13091310static intparse_binary(char*buffer,unsigned long size,struct patch *patch)1311{1312/*1313 * We have read "GIT binary patch\n"; what follows is a line1314 * that says the patch method (currently, either "literal" or1315 * "delta") and the length of data before deflating; a1316 * sequence of 'length-byte' followed by base-85 encoded data1317 * follows.1318 *1319 * When a binary patch is reversible, there is another binary1320 * hunk in the same format, starting with patch method (either1321 * "literal" or "delta") with the length of data, and a sequence1322 * of length-byte + base-85 encoded data, terminated with another1323 * empty line. This data, when applied to the postimage, produces1324 * the preimage.1325 */1326struct fragment *forward;1327struct fragment *reverse;1328int status;1329int used, used_1;13301331 forward =parse_binary_hunk(&buffer, &size, &status, &used);1332if(!forward && !status)1333/* there has to be one hunk (forward hunk) */1334returnerror("unrecognized binary patch at line%d", linenr-1);1335if(status)1336/* otherwise we already gave an error message */1337return status;13381339 reverse =parse_binary_hunk(&buffer, &size, &status, &used_1);1340if(reverse)1341 used += used_1;1342else if(status) {1343/*1344 * Not having reverse hunk is not an error, but having1345 * a corrupt reverse hunk is.1346 */1347free((void*) forward->patch);1348free(forward);1349return status;1350}1351 forward->next = reverse;1352 patch->fragments = forward;1353 patch->is_binary =1;1354return used;1355}13561357static intparse_chunk(char*buffer,unsigned long size,struct patch *patch)1358{1359int hdrsize, patchsize;1360int offset =find_header(buffer, size, &hdrsize, patch);13611362if(offset <0)1363return offset;13641365 patch->ws_rule =whitespace_rule(patch->new_name1366? patch->new_name1367: patch->old_name);13681369 patchsize =parse_single_patch(buffer + offset + hdrsize,1370 size - offset - hdrsize, patch);13711372if(!patchsize) {1373static const char*binhdr[] = {1374"Binary files ",1375"Files ",1376 NULL,1377};1378static const char git_binary[] ="GIT binary patch\n";1379int i;1380int hd = hdrsize + offset;1381unsigned long llen =linelen(buffer + hd, size - hd);13821383if(llen ==sizeof(git_binary) -1&&1384!memcmp(git_binary, buffer + hd, llen)) {1385int used;1386 linenr++;1387 used =parse_binary(buffer + hd + llen,1388 size - hd - llen, patch);1389if(used)1390 patchsize = used + llen;1391else1392 patchsize =0;1393}1394else if(!memcmp(" differ\n", buffer + hd + llen -8,8)) {1395for(i =0; binhdr[i]; i++) {1396int len =strlen(binhdr[i]);1397if(len < size - hd &&1398!memcmp(binhdr[i], buffer + hd, len)) {1399 linenr++;1400 patch->is_binary =1;1401 patchsize = llen;1402break;1403}1404}1405}14061407/* Empty patch cannot be applied if it is a text patch1408 * without metadata change. A binary patch appears1409 * empty to us here.1410 */1411if((apply || check) &&1412(!patch->is_binary && !metadata_changes(patch)))1413die("patch with only garbage at line%d", linenr);1414}14151416return offset + hdrsize + patchsize;1417}14181419#define swap(a,b) myswap((a),(b),sizeof(a))14201421#define myswap(a, b, size) do { \1422 unsigned char mytmp[size]; \1423 memcpy(mytmp, &a, size); \1424 memcpy(&a, &b, size); \1425 memcpy(&b, mytmp, size); \1426} while (0)14271428static voidreverse_patches(struct patch *p)1429{1430for(; p; p = p->next) {1431struct fragment *frag = p->fragments;14321433swap(p->new_name, p->old_name);1434swap(p->new_mode, p->old_mode);1435swap(p->is_new, p->is_delete);1436swap(p->lines_added, p->lines_deleted);1437swap(p->old_sha1_prefix, p->new_sha1_prefix);14381439for(; frag; frag = frag->next) {1440swap(frag->newpos, frag->oldpos);1441swap(frag->newlines, frag->oldlines);1442}1443}1444}14451446static const char pluses[] =1447"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";1448static const char minuses[]=1449"----------------------------------------------------------------------";14501451static voidshow_stats(struct patch *patch)1452{1453struct strbuf qname;1454char*cp = patch->new_name ? patch->new_name : patch->old_name;1455int max, add, del;14561457strbuf_init(&qname,0);1458quote_c_style(cp, &qname, NULL,0);14591460/*1461 * "scale" the filename1462 */1463 max = max_len;1464if(max >50)1465 max =50;14661467if(qname.len > max) {1468 cp =strchr(qname.buf + qname.len +3- max,'/');1469if(!cp)1470 cp = qname.buf + qname.len +3- max;1471strbuf_splice(&qname,0, cp - qname.buf,"...",3);1472}14731474if(patch->is_binary) {1475printf(" %-*s | Bin\n", max, qname.buf);1476strbuf_release(&qname);1477return;1478}14791480printf(" %-*s |", max, qname.buf);1481strbuf_release(&qname);14821483/*1484 * scale the add/delete1485 */1486 max = max + max_change >70?70- max : max_change;1487 add = patch->lines_added;1488 del = patch->lines_deleted;14891490if(max_change >0) {1491int total = ((add + del) * max + max_change /2) / max_change;1492 add = (add * max + max_change /2) / max_change;1493 del = total - add;1494}1495printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,1496 add, pluses, del, minuses);1497}14981499static intread_old_data(struct stat *st,const char*path,struct strbuf *buf)1500{1501switch(st->st_mode & S_IFMT) {1502case S_IFLNK:1503strbuf_grow(buf, st->st_size);1504if(readlink(path, buf->buf, st->st_size) != st->st_size)1505return-1;1506strbuf_setlen(buf, st->st_size);1507return0;1508case S_IFREG:1509if(strbuf_read_file(buf, path, st->st_size) != st->st_size)1510returnerror("unable to open or read%s", path);1511convert_to_git(path, buf->buf, buf->len, buf);1512return0;1513default:1514return-1;1515}1516}15171518static intcopy_wsfix(char*output,const char*patch,int plen,1519unsigned ws_rule,int count_error)1520{1521/*1522 * plen is number of bytes to be copied from patch, starting1523 * at patch. Typically patch[plen-1] is '\n', unless this is1524 * the incomplete last line.1525 */1526int i;1527int add_nl_to_tail =0;1528int add_cr_to_tail =0;1529int fixed =0;1530int last_tab_in_indent = -1;1531int last_space_in_indent = -1;1532int need_fix_leading_space =0;1533char*buf;15341535/*1536 * Strip trailing whitespace1537 */1538if((ws_rule & WS_TRAILING_SPACE) &&1539(2< plen &&isspace(patch[plen-2]))) {1540if(patch[plen -1] =='\n') {1541 add_nl_to_tail =1;1542 plen--;1543if(1< plen && patch[plen -1] =='\r') {1544 add_cr_to_tail = !!(ws_rule & WS_CR_AT_EOL);1545 plen--;1546}1547}1548if(0< plen &&isspace(patch[plen -1])) {1549while(0< plen &&isspace(patch[plen-1]))1550 plen--;1551 fixed =1;1552}1553}15541555/*1556 * Check leading whitespaces (indent)1557 */1558for(i =0; i < plen; i++) {1559char ch = patch[i];1560if(ch =='\t') {1561 last_tab_in_indent = i;1562if((ws_rule & WS_SPACE_BEFORE_TAB) &&15630<= last_space_in_indent)1564 need_fix_leading_space =1;1565}else if(ch ==' ') {1566 last_space_in_indent = i;1567if((ws_rule & WS_INDENT_WITH_NON_TAB) &&15688<= i - last_tab_in_indent)1569 need_fix_leading_space =1;1570}else1571break;1572}15731574 buf = output;1575if(need_fix_leading_space) {1576/* Process indent ourselves */1577int consecutive_spaces =0;1578int last = last_tab_in_indent +1;15791580if(ws_rule & WS_INDENT_WITH_NON_TAB) {1581/* have "last" point at one past the indent */1582if(last_tab_in_indent < last_space_in_indent)1583 last = last_space_in_indent +1;1584else1585 last = last_tab_in_indent +1;1586}15871588/*1589 * between patch[0..last-1], strip the funny spaces,1590 * updating them to tab as needed.1591 */1592for(i =0; i < last; i++) {1593char ch = patch[i];1594if(ch !=' ') {1595 consecutive_spaces =0;1596*output++ = ch;1597}else{1598 consecutive_spaces++;1599if(consecutive_spaces ==8) {1600*output++ ='\t';1601 consecutive_spaces =0;1602}1603}1604}1605while(0< consecutive_spaces--)1606*output++ =' ';1607 plen -= last;1608 patch += last;1609 fixed =1;1610}16111612memcpy(output, patch, plen);1613if(add_cr_to_tail)1614 output[plen++] ='\r';1615if(add_nl_to_tail)1616 output[plen++] ='\n';1617if(fixed && count_error)1618 applied_after_fixing_ws++;1619return output + plen - buf;1620}16211622static voidupdate_pre_post_images(struct image *preimage,1623struct image *postimage,1624char*buf,1625size_t len)1626{1627int i, ctx;1628char*new, *old, *fixed;1629struct image fixed_preimage;16301631/*1632 * Update the preimage with whitespace fixes. Note that we1633 * are not losing preimage->buf -- apply_one_fragment() will1634 * free "oldlines".1635 */1636prepare_image(&fixed_preimage, buf, len,1);1637assert(fixed_preimage.nr == preimage->nr);1638for(i =0; i < preimage->nr; i++)1639 fixed_preimage.line[i].flag = preimage->line[i].flag;1640free(preimage->line_allocated);1641*preimage = fixed_preimage;16421643/*1644 * Adjust the common context lines in postimage, in place.1645 * This is possible because whitespace fixing does not make1646 * the string grow.1647 */1648new= old = postimage->buf;1649 fixed = preimage->buf;1650for(i = ctx =0; i < postimage->nr; i++) {1651size_t len = postimage->line[i].len;1652if(!(postimage->line[i].flag & LINE_COMMON)) {1653/* an added line -- no counterparts in preimage */1654memmove(new, old, len);1655 old += len;1656new+= len;1657continue;1658}16591660/* a common context -- skip it in the original postimage */1661 old += len;16621663/* and find the corresponding one in the fixed preimage */1664while(ctx < preimage->nr &&1665!(preimage->line[ctx].flag & LINE_COMMON)) {1666 fixed += preimage->line[ctx].len;1667 ctx++;1668}1669if(preimage->nr <= ctx)1670die("oops");16711672/* and copy it in, while fixing the line length */1673 len = preimage->line[ctx].len;1674memcpy(new, fixed, len);1675new+= len;1676 fixed += len;1677 postimage->line[i].len = len;1678 ctx++;1679}16801681/* Fix the length of the whole thing */1682 postimage->len =new- postimage->buf;1683}16841685static intmatch_fragment(struct image *img,1686struct image *preimage,1687struct image *postimage,1688unsigned longtry,1689int try_lno,1690unsigned ws_rule,1691int match_beginning,int match_end)1692{1693int i;1694char*fixed_buf, *buf, *orig, *target;16951696if(preimage->nr + try_lno > img->nr)1697return0;16981699if(match_beginning && try_lno)1700return0;17011702if(match_end && preimage->nr + try_lno != img->nr)1703return0;17041705/* Quick hash check */1706for(i =0; i < preimage->nr; i++)1707if(preimage->line[i].hash != img->line[try_lno + i].hash)1708return0;17091710/*1711 * Do we have an exact match? If we were told to match1712 * at the end, size must be exactly at try+fragsize,1713 * otherwise try+fragsize must be still within the preimage,1714 * and either case, the old piece should match the preimage1715 * exactly.1716 */1717if((match_end1718? (try+ preimage->len == img->len)1719: (try+ preimage->len <= img->len)) &&1720!memcmp(img->buf +try, preimage->buf, preimage->len))1721return1;17221723if(ws_error_action != correct_ws_error)1724return0;17251726/*1727 * The hunk does not apply byte-by-byte, but the hash says1728 * it might with whitespace fuzz.1729 */1730 fixed_buf =xmalloc(preimage->len +1);1731 buf = fixed_buf;1732 orig = preimage->buf;1733 target = img->buf +try;1734for(i =0; i < preimage->nr; i++) {1735size_t fixlen;/* length after fixing the preimage */1736size_t oldlen = preimage->line[i].len;1737size_t tgtlen = img->line[try_lno + i].len;1738size_t tgtfixlen;/* length after fixing the target line */1739char tgtfixbuf[1024], *tgtfix;1740int match;17411742/* Try fixing the line in the preimage */1743 fixlen =copy_wsfix(buf, orig, oldlen, ws_rule,0);17441745/* Try fixing the line in the target */1746if(sizeof(tgtfixbuf) < tgtlen)1747 tgtfix = tgtfixbuf;1748else1749 tgtfix =xmalloc(tgtlen);1750 tgtfixlen =copy_wsfix(tgtfix, target, tgtlen, ws_rule,0);17511752/*1753 * If they match, either the preimage was based on1754 * a version before our tree fixed whitespace breakage,1755 * or we are lacking a whitespace-fix patch the tree1756 * the preimage was based on already had (i.e. target1757 * has whitespace breakage, the preimage doesn't).1758 * In either case, we are fixing the whitespace breakages1759 * so we might as well take the fix together with their1760 * real change.1761 */1762 match = (tgtfixlen == fixlen && !memcmp(tgtfix, buf, fixlen));17631764if(tgtfix != tgtfixbuf)1765free(tgtfix);1766if(!match)1767goto unmatch_exit;17681769 orig += oldlen;1770 buf += fixlen;1771 target += tgtlen;1772}17731774/*1775 * Yes, the preimage is based on an older version that still1776 * has whitespace breakages unfixed, and fixing them makes the1777 * hunk match. Update the context lines in the postimage.1778 */1779update_pre_post_images(preimage, postimage,1780 fixed_buf, buf - fixed_buf);1781return1;17821783 unmatch_exit:1784free(fixed_buf);1785return0;1786}17871788static intfind_pos(struct image *img,1789struct image *preimage,1790struct image *postimage,1791int line,1792unsigned ws_rule,1793int match_beginning,int match_end)1794{1795int i;1796unsigned long backwards, forwards,try;1797int backwards_lno, forwards_lno, try_lno;17981799if(preimage->nr > img->nr)1800return-1;18011802/*1803 * If match_begining or match_end is specified, there is no1804 * point starting from a wrong line that will never match and1805 * wander around and wait for a match at the specified end.1806 */1807if(match_beginning)1808 line =0;1809else if(match_end)1810 line = img->nr - preimage->nr;18111812try=0;1813for(i =0; i < line; i++)1814try+= img->line[i].len;18151816/*1817 * There's probably some smart way to do this, but I'll leave1818 * that to the smart and beautiful people. I'm simple and stupid.1819 */1820 backwards =try;1821 backwards_lno = line;1822 forwards =try;1823 forwards_lno = line;1824 try_lno = line;18251826for(i =0; ; i++) {1827if(match_fragment(img, preimage, postimage,1828try, try_lno, ws_rule,1829 match_beginning, match_end))1830return try_lno;18311832 again:1833if(backwards_lno ==0&& forwards_lno == img->nr)1834break;18351836if(i &1) {1837if(backwards_lno ==0) {1838 i++;1839goto again;1840}1841 backwards_lno--;1842 backwards -= img->line[backwards_lno].len;1843try= backwards;1844 try_lno = backwards_lno;1845}else{1846if(forwards_lno == img->nr) {1847 i++;1848goto again;1849}1850 forwards += img->line[forwards_lno].len;1851 forwards_lno++;1852try= forwards;1853 try_lno = forwards_lno;1854}18551856}1857return-1;1858}18591860static voidremove_first_line(struct image *img)1861{1862 img->buf += img->line[0].len;1863 img->len -= img->line[0].len;1864 img->line++;1865 img->nr--;1866}18671868static voidremove_last_line(struct image *img)1869{1870 img->len -= img->line[--img->nr].len;1871}18721873static voidupdate_image(struct image *img,1874int applied_pos,1875struct image *preimage,1876struct image *postimage)1877{1878/*1879 * remove the copy of preimage at offset in img1880 * and replace it with postimage1881 */1882int i, nr;1883size_t remove_count, insert_count, applied_at =0;1884char*result;18851886for(i =0; i < applied_pos; i++)1887 applied_at += img->line[i].len;18881889 remove_count =0;1890for(i =0; i < preimage->nr; i++)1891 remove_count += img->line[applied_pos + i].len;1892 insert_count = postimage->len;18931894/* Adjust the contents */1895 result =xmalloc(img->len + insert_count - remove_count +1);1896memcpy(result, img->buf, applied_at);1897memcpy(result + applied_at, postimage->buf, postimage->len);1898memcpy(result + applied_at + postimage->len,1899 img->buf + (applied_at + remove_count),1900 img->len - (applied_at + remove_count));1901free(img->buf);1902 img->buf = result;1903 img->len += insert_count - remove_count;1904 result[img->len] ='\0';19051906/* Adjust the line table */1907 nr = img->nr + postimage->nr - preimage->nr;1908if(preimage->nr < postimage->nr) {1909/*1910 * NOTE: this knows that we never call remove_first_line()1911 * on anything other than pre/post image.1912 */1913 img->line =xrealloc(img->line, nr *sizeof(*img->line));1914 img->line_allocated = img->line;1915}1916if(preimage->nr != postimage->nr)1917memmove(img->line + applied_pos + postimage->nr,1918 img->line + applied_pos + preimage->nr,1919(img->nr - (applied_pos + preimage->nr)) *1920sizeof(*img->line));1921memcpy(img->line + applied_pos,1922 postimage->line,1923 postimage->nr *sizeof(*img->line));1924 img->nr = nr;1925}19261927static intapply_one_fragment(struct image *img,struct fragment *frag,1928int inaccurate_eof,unsigned ws_rule)1929{1930int match_beginning, match_end;1931const char*patch = frag->patch;1932int size = frag->size;1933char*old, *new, *oldlines, *newlines;1934int new_blank_lines_at_end =0;1935unsigned long leading, trailing;1936int pos, applied_pos;1937struct image preimage;1938struct image postimage;19391940memset(&preimage,0,sizeof(preimage));1941memset(&postimage,0,sizeof(postimage));1942 oldlines =xmalloc(size);1943 newlines =xmalloc(size);19441945 old = oldlines;1946new= newlines;1947while(size >0) {1948char first;1949int len =linelen(patch, size);1950int plen, added;1951int added_blank_line =0;19521953if(!len)1954break;19551956/*1957 * "plen" is how much of the line we should use for1958 * the actual patch data. Normally we just remove the1959 * first character on the line, but if the line is1960 * followed by "\ No newline", then we also remove the1961 * last one (which is the newline, of course).1962 */1963 plen = len -1;1964if(len < size && patch[len] =='\\')1965 plen--;1966 first = *patch;1967if(apply_in_reverse) {1968if(first =='-')1969 first ='+';1970else if(first =='+')1971 first ='-';1972}19731974switch(first) {1975case'\n':1976/* Newer GNU diff, empty context line */1977if(plen <0)1978/* ... followed by '\No newline'; nothing */1979break;1980*old++ ='\n';1981*new++ ='\n';1982add_line_info(&preimage,"\n",1, LINE_COMMON);1983add_line_info(&postimage,"\n",1, LINE_COMMON);1984break;1985case' ':1986case'-':1987memcpy(old, patch +1, plen);1988add_line_info(&preimage, old, plen,1989(first ==' '? LINE_COMMON :0));1990 old += plen;1991if(first =='-')1992break;1993/* Fall-through for ' ' */1994case'+':1995/* --no-add does not add new lines */1996if(first =='+'&& no_add)1997break;19981999if(first !='+'||2000!whitespace_error ||2001 ws_error_action != correct_ws_error) {2002memcpy(new, patch +1, plen);2003 added = plen;2004}2005else{2006 added =copy_wsfix(new, patch +1, plen,2007 ws_rule,1);2008}2009add_line_info(&postimage,new, added,2010(first =='+'?0: LINE_COMMON));2011new+= added;2012if(first =='+'&&2013 added ==1&&new[-1] =='\n')2014 added_blank_line =1;2015break;2016case'@':case'\\':2017/* Ignore it, we already handled it */2018break;2019default:2020if(apply_verbosely)2021error("invalid start of line: '%c'", first);2022return-1;2023}2024if(added_blank_line)2025 new_blank_lines_at_end++;2026else2027 new_blank_lines_at_end =0;2028 patch += len;2029 size -= len;2030}2031if(inaccurate_eof &&2032 old > oldlines && old[-1] =='\n'&&2033new> newlines &&new[-1] =='\n') {2034 old--;2035new--;2036}20372038 leading = frag->leading;2039 trailing = frag->trailing;20402041/*2042 * If we don't have any leading/trailing data in the patch,2043 * we want it to match at the beginning/end of the file.2044 *2045 * But that would break if the patch is generated with2046 * --unified=0; sane people wouldn't do that to cause us2047 * trouble, but we try to please not so sane ones as well.2048 */2049if(unidiff_zero) {2050 match_beginning = (!leading && !frag->oldpos);2051 match_end =0;2052}2053else{2054 match_beginning = !leading && (frag->oldpos ==1);2055 match_end = !trailing;2056}20572058 pos = frag->newpos ? (frag->newpos -1) :0;2059 preimage.buf = oldlines;2060 preimage.len = old - oldlines;2061 postimage.buf = newlines;2062 postimage.len =new- newlines;2063 preimage.line = preimage.line_allocated;2064 postimage.line = postimage.line_allocated;20652066for(;;) {20672068 applied_pos =find_pos(img, &preimage, &postimage, pos,2069 ws_rule, match_beginning, match_end);20702071if(applied_pos >=0)2072break;20732074/* Am I at my context limits? */2075if((leading <= p_context) && (trailing <= p_context))2076break;2077if(match_beginning || match_end) {2078 match_beginning = match_end =0;2079continue;2080}20812082/*2083 * Reduce the number of context lines; reduce both2084 * leading and trailing if they are equal otherwise2085 * just reduce the larger context.2086 */2087if(leading >= trailing) {2088remove_first_line(&preimage);2089remove_first_line(&postimage);2090 pos--;2091 leading--;2092}2093if(trailing > leading) {2094remove_last_line(&preimage);2095remove_last_line(&postimage);2096 trailing--;2097}2098}20992100if(applied_pos >=0) {2101if(ws_error_action == correct_ws_error &&2102 new_blank_lines_at_end &&2103 postimage.nr + applied_pos == img->nr) {2104/*2105 * If the patch application adds blank lines2106 * at the end, and if the patch applies at the2107 * end of the image, remove those added blank2108 * lines.2109 */2110while(new_blank_lines_at_end--)2111remove_last_line(&postimage);2112}21132114/*2115 * Warn if it was necessary to reduce the number2116 * of context lines.2117 */2118if((leading != frag->leading) ||2119(trailing != frag->trailing))2120fprintf(stderr,"Context reduced to (%ld/%ld)"2121" to apply fragment at%d\n",2122 leading, trailing, applied_pos+1);2123update_image(img, applied_pos, &preimage, &postimage);2124}else{2125if(apply_verbosely)2126error("while searching for:\n%.*s",2127(int)(old - oldlines), oldlines);2128}21292130free(oldlines);2131free(newlines);2132free(preimage.line_allocated);2133free(postimage.line_allocated);21342135return(applied_pos <0);2136}21372138static intapply_binary_fragment(struct image *img,struct patch *patch)2139{2140struct fragment *fragment = patch->fragments;2141unsigned long len;2142void*dst;21432144/* Binary patch is irreversible without the optional second hunk */2145if(apply_in_reverse) {2146if(!fragment->next)2147returnerror("cannot reverse-apply a binary patch "2148"without the reverse hunk to '%s'",2149 patch->new_name2150? patch->new_name : patch->old_name);2151 fragment = fragment->next;2152}2153switch(fragment->binary_patch_method) {2154case BINARY_DELTA_DEFLATED:2155 dst =patch_delta(img->buf, img->len, fragment->patch,2156 fragment->size, &len);2157if(!dst)2158return-1;2159clear_image(img);2160 img->buf = dst;2161 img->len = len;2162return0;2163case BINARY_LITERAL_DEFLATED:2164clear_image(img);2165 img->len = fragment->size;2166 img->buf =xmalloc(img->len+1);2167memcpy(img->buf, fragment->patch, img->len);2168 img->buf[img->len] ='\0';2169return0;2170}2171return-1;2172}21732174static intapply_binary(struct image *img,struct patch *patch)2175{2176const char*name = patch->old_name ? patch->old_name : patch->new_name;2177unsigned char sha1[20];21782179/*2180 * For safety, we require patch index line to contain2181 * full 40-byte textual SHA1 for old and new, at least for now.2182 */2183if(strlen(patch->old_sha1_prefix) !=40||2184strlen(patch->new_sha1_prefix) !=40||2185get_sha1_hex(patch->old_sha1_prefix, sha1) ||2186get_sha1_hex(patch->new_sha1_prefix, sha1))2187returnerror("cannot apply binary patch to '%s' "2188"without full index line", name);21892190if(patch->old_name) {2191/*2192 * See if the old one matches what the patch2193 * applies to.2194 */2195hash_sha1_file(img->buf, img->len, blob_type, sha1);2196if(strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))2197returnerror("the patch applies to '%s' (%s), "2198"which does not match the "2199"current contents.",2200 name,sha1_to_hex(sha1));2201}2202else{2203/* Otherwise, the old one must be empty. */2204if(img->len)2205returnerror("the patch applies to an empty "2206"'%s' but it is not empty", name);2207}22082209get_sha1_hex(patch->new_sha1_prefix, sha1);2210if(is_null_sha1(sha1)) {2211clear_image(img);2212return0;/* deletion patch */2213}22142215if(has_sha1_file(sha1)) {2216/* We already have the postimage */2217enum object_type type;2218unsigned long size;2219char*result;22202221 result =read_sha1_file(sha1, &type, &size);2222if(!result)2223returnerror("the necessary postimage%sfor "2224"'%s' cannot be read",2225 patch->new_sha1_prefix, name);2226clear_image(img);2227 img->buf = result;2228 img->len = size;2229}else{2230/*2231 * We have verified buf matches the preimage;2232 * apply the patch data to it, which is stored2233 * in the patch->fragments->{patch,size}.2234 */2235if(apply_binary_fragment(img, patch))2236returnerror("binary patch does not apply to '%s'",2237 name);22382239/* verify that the result matches */2240hash_sha1_file(img->buf, img->len, blob_type, sha1);2241if(strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))2242returnerror("binary patch to '%s' creates incorrect result (expecting%s, got%s)",2243 name, patch->new_sha1_prefix,sha1_to_hex(sha1));2244}22452246return0;2247}22482249static intapply_fragments(struct image *img,struct patch *patch)2250{2251struct fragment *frag = patch->fragments;2252const char*name = patch->old_name ? patch->old_name : patch->new_name;2253unsigned ws_rule = patch->ws_rule;2254unsigned inaccurate_eof = patch->inaccurate_eof;22552256if(patch->is_binary)2257returnapply_binary(img, patch);22582259while(frag) {2260if(apply_one_fragment(img, frag, inaccurate_eof, ws_rule)) {2261error("patch failed:%s:%ld", name, frag->oldpos);2262if(!apply_with_reject)2263return-1;2264 frag->rejected =1;2265}2266 frag = frag->next;2267}2268return0;2269}22702271static intread_file_or_gitlink(struct cache_entry *ce,struct strbuf *buf)2272{2273if(!ce)2274return0;22752276if(S_ISGITLINK(ntohl(ce->ce_mode))) {2277strbuf_grow(buf,100);2278strbuf_addf(buf,"Subproject commit%s\n",sha1_to_hex(ce->sha1));2279}else{2280enum object_type type;2281unsigned long sz;2282char*result;22832284 result =read_sha1_file(ce->sha1, &type, &sz);2285if(!result)2286return-1;2287/* XXX read_sha1_file NUL-terminates */2288strbuf_attach(buf, result, sz, sz +1);2289}2290return0;2291}22922293static intapply_data(struct patch *patch,struct stat *st,struct cache_entry *ce)2294{2295struct strbuf buf;2296struct image image;2297size_t len;2298char*img;22992300strbuf_init(&buf,0);2301if(cached) {2302if(read_file_or_gitlink(ce, &buf))2303returnerror("read of%sfailed", patch->old_name);2304}else if(patch->old_name) {2305if(S_ISGITLINK(patch->old_mode)) {2306if(ce) {2307read_file_or_gitlink(ce, &buf);2308}else{2309/*2310 * There is no way to apply subproject2311 * patch without looking at the index.2312 */2313 patch->fragments = NULL;2314}2315}else{2316if(read_old_data(st, patch->old_name, &buf))2317returnerror("read of%sfailed", patch->old_name);2318}2319}23202321 img =strbuf_detach(&buf, &len);2322prepare_image(&image, img, len, !patch->is_binary);23232324if(apply_fragments(&image, patch) <0)2325return-1;/* note with --reject this succeeds. */2326 patch->result = image.buf;2327 patch->resultsize = image.len;2328free(image.line_allocated);23292330if(0< patch->is_delete && patch->resultsize)2331returnerror("removal patch leaves file contents");23322333return0;2334}23352336static intcheck_to_create_blob(const char*new_name,int ok_if_exists)2337{2338struct stat nst;2339if(!lstat(new_name, &nst)) {2340if(S_ISDIR(nst.st_mode) || ok_if_exists)2341return0;2342/*2343 * A leading component of new_name might be a symlink2344 * that is going to be removed with this patch, but2345 * still pointing at somewhere that has the path.2346 * In such a case, path "new_name" does not exist as2347 * far as git is concerned.2348 */2349if(has_symlink_leading_path(new_name, NULL))2350return0;23512352returnerror("%s: already exists in working directory", new_name);2353}2354else if((errno != ENOENT) && (errno != ENOTDIR))2355returnerror("%s:%s", new_name,strerror(errno));2356return0;2357}23582359static intverify_index_match(struct cache_entry *ce,struct stat *st)2360{2361if(S_ISGITLINK(ntohl(ce->ce_mode))) {2362if(!S_ISDIR(st->st_mode))2363return-1;2364return0;2365}2366returnce_match_stat(ce, st, CE_MATCH_IGNORE_VALID);2367}23682369static intcheck_patch(struct patch *patch,struct patch *prev_patch)2370{2371struct stat st;2372const char*old_name = patch->old_name;2373const char*new_name = patch->new_name;2374const char*name = old_name ? old_name : new_name;2375struct cache_entry *ce = NULL;2376int ok_if_exists;23772378 patch->rejected =1;/* we will drop this after we succeed */23792380/*2381 * Make sure that we do not have local modifications from the2382 * index when we are looking at the index. Also make sure2383 * we have the preimage file to be patched in the work tree,2384 * unless --cached, which tells git to apply only in the index.2385 */2386if(old_name) {2387int stat_ret =0;2388unsigned st_mode =0;23892390if(!cached)2391 stat_ret =lstat(old_name, &st);2392if(check_index) {2393int pos =cache_name_pos(old_name,strlen(old_name));2394if(pos <0)2395returnerror("%s: does not exist in index",2396 old_name);2397 ce = active_cache[pos];2398if(stat_ret <0) {2399struct checkout costate;2400if(errno != ENOENT)2401returnerror("%s:%s", old_name,2402strerror(errno));2403/* checkout */2404 costate.base_dir ="";2405 costate.base_dir_len =0;2406 costate.force =0;2407 costate.quiet =0;2408 costate.not_new =0;2409 costate.refresh_cache =1;2410if(checkout_entry(ce,2411&costate,2412 NULL) ||2413lstat(old_name, &st))2414return-1;2415}2416if(!cached &&verify_index_match(ce, &st))2417returnerror("%s: does not match index",2418 old_name);2419if(cached)2420 st_mode =ntohl(ce->ce_mode);2421}else if(stat_ret <0)2422returnerror("%s:%s", old_name,strerror(errno));24232424if(!cached)2425 st_mode =ntohl(ce_mode_from_stat(ce, st.st_mode));24262427if(patch->is_new <0)2428 patch->is_new =0;2429if(!patch->old_mode)2430 patch->old_mode = st_mode;2431if((st_mode ^ patch->old_mode) & S_IFMT)2432returnerror("%s: wrong type", old_name);2433if(st_mode != patch->old_mode)2434fprintf(stderr,"warning:%shas type%o, expected%o\n",2435 old_name, st_mode, patch->old_mode);2436}24372438if(new_name && prev_patch &&0< prev_patch->is_delete &&2439!strcmp(prev_patch->old_name, new_name))2440/*2441 * A type-change diff is always split into a patch to2442 * delete old, immediately followed by a patch to2443 * create new (see diff.c::run_diff()); in such a case2444 * it is Ok that the entry to be deleted by the2445 * previous patch is still in the working tree and in2446 * the index.2447 */2448 ok_if_exists =1;2449else2450 ok_if_exists =0;24512452if(new_name &&2453((0< patch->is_new) | (0< patch->is_rename) | patch->is_copy)) {2454if(check_index &&2455cache_name_pos(new_name,strlen(new_name)) >=0&&2456!ok_if_exists)2457returnerror("%s: already exists in index", new_name);2458if(!cached) {2459int err =check_to_create_blob(new_name, ok_if_exists);2460if(err)2461return err;2462}2463if(!patch->new_mode) {2464if(0< patch->is_new)2465 patch->new_mode = S_IFREG |0644;2466else2467 patch->new_mode = patch->old_mode;2468}2469}24702471if(new_name && old_name) {2472int same = !strcmp(old_name, new_name);2473if(!patch->new_mode)2474 patch->new_mode = patch->old_mode;2475if((patch->old_mode ^ patch->new_mode) & S_IFMT)2476returnerror("new mode (%o) of%sdoes not match old mode (%o)%s%s",2477 patch->new_mode, new_name, patch->old_mode,2478 same ?"":" of ", same ?"": old_name);2479}24802481if(apply_data(patch, &st, ce) <0)2482returnerror("%s: patch does not apply", name);2483 patch->rejected =0;2484return0;2485}24862487static intcheck_patch_list(struct patch *patch)2488{2489struct patch *prev_patch = NULL;2490int err =0;24912492for(prev_patch = NULL; patch ; patch = patch->next) {2493if(apply_verbosely)2494say_patch_name(stderr,2495"Checking patch ", patch,"...\n");2496 err |=check_patch(patch, prev_patch);2497 prev_patch = patch;2498}2499return err;2500}25012502/* This function tries to read the sha1 from the current index */2503static intget_current_sha1(const char*path,unsigned char*sha1)2504{2505int pos;25062507if(read_cache() <0)2508return-1;2509 pos =cache_name_pos(path,strlen(path));2510if(pos <0)2511return-1;2512hashcpy(sha1, active_cache[pos]->sha1);2513return0;2514}25152516/* Build an index that contains the just the files needed for a 3way merge */2517static voidbuild_fake_ancestor(struct patch *list,const char*filename)2518{2519struct patch *patch;2520struct index_state result = {0};2521int fd;25222523/* Once we start supporting the reverse patch, it may be2524 * worth showing the new sha1 prefix, but until then...2525 */2526for(patch = list; patch; patch = patch->next) {2527const unsigned char*sha1_ptr;2528unsigned char sha1[20];2529struct cache_entry *ce;2530const char*name;25312532 name = patch->old_name ? patch->old_name : patch->new_name;2533if(0< patch->is_new)2534continue;2535else if(get_sha1(patch->old_sha1_prefix, sha1))2536/* git diff has no index line for mode/type changes */2537if(!patch->lines_added && !patch->lines_deleted) {2538if(get_current_sha1(patch->new_name, sha1) ||2539get_current_sha1(patch->old_name, sha1))2540die("mode change for%s, which is not "2541"in current HEAD", name);2542 sha1_ptr = sha1;2543}else2544die("sha1 information is lacking or useless "2545"(%s).", name);2546else2547 sha1_ptr = sha1;25482549 ce =make_cache_entry(patch->old_mode, sha1_ptr, name,0,0);2550if(add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))2551die("Could not add%sto temporary index", name);2552}25532554 fd =open(filename, O_WRONLY | O_CREAT,0666);2555if(fd <0||write_index(&result, fd) ||close(fd))2556die("Could not write temporary index to%s", filename);25572558discard_index(&result);2559}25602561static voidstat_patch_list(struct patch *patch)2562{2563int files, adds, dels;25642565for(files = adds = dels =0; patch ; patch = patch->next) {2566 files++;2567 adds += patch->lines_added;2568 dels += patch->lines_deleted;2569show_stats(patch);2570}25712572printf("%dfiles changed,%dinsertions(+),%ddeletions(-)\n", files, adds, dels);2573}25742575static voidnumstat_patch_list(struct patch *patch)2576{2577for( ; patch; patch = patch->next) {2578const char*name;2579 name = patch->new_name ? patch->new_name : patch->old_name;2580if(patch->is_binary)2581printf("-\t-\t");2582else2583printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);2584write_name_quoted(name, stdout, line_termination);2585}2586}25872588static voidshow_file_mode_name(const char*newdelete,unsigned int mode,const char*name)2589{2590if(mode)2591printf("%smode%06o%s\n", newdelete, mode, name);2592else2593printf("%s %s\n", newdelete, name);2594}25952596static voidshow_mode_change(struct patch *p,int show_name)2597{2598if(p->old_mode && p->new_mode && p->old_mode != p->new_mode) {2599if(show_name)2600printf(" mode change%06o =>%06o%s\n",2601 p->old_mode, p->new_mode, p->new_name);2602else2603printf(" mode change%06o =>%06o\n",2604 p->old_mode, p->new_mode);2605}2606}26072608static voidshow_rename_copy(struct patch *p)2609{2610const char*renamecopy = p->is_rename ?"rename":"copy";2611const char*old, *new;26122613/* Find common prefix */2614 old = p->old_name;2615new= p->new_name;2616while(1) {2617const char*slash_old, *slash_new;2618 slash_old =strchr(old,'/');2619 slash_new =strchr(new,'/');2620if(!slash_old ||2621!slash_new ||2622 slash_old - old != slash_new -new||2623memcmp(old,new, slash_new -new))2624break;2625 old = slash_old +1;2626new= slash_new +1;2627}2628/* p->old_name thru old is the common prefix, and old and new2629 * through the end of names are renames2630 */2631if(old != p->old_name)2632printf("%s%.*s{%s=>%s} (%d%%)\n", renamecopy,2633(int)(old - p->old_name), p->old_name,2634 old,new, p->score);2635else2636printf("%s %s=>%s(%d%%)\n", renamecopy,2637 p->old_name, p->new_name, p->score);2638show_mode_change(p,0);2639}26402641static voidsummary_patch_list(struct patch *patch)2642{2643struct patch *p;26442645for(p = patch; p; p = p->next) {2646if(p->is_new)2647show_file_mode_name("create", p->new_mode, p->new_name);2648else if(p->is_delete)2649show_file_mode_name("delete", p->old_mode, p->old_name);2650else{2651if(p->is_rename || p->is_copy)2652show_rename_copy(p);2653else{2654if(p->score) {2655printf(" rewrite%s(%d%%)\n",2656 p->new_name, p->score);2657show_mode_change(p,0);2658}2659else2660show_mode_change(p,1);2661}2662}2663}2664}26652666static voidpatch_stats(struct patch *patch)2667{2668int lines = patch->lines_added + patch->lines_deleted;26692670if(lines > max_change)2671 max_change = lines;2672if(patch->old_name) {2673int len =quote_c_style(patch->old_name, NULL, NULL,0);2674if(!len)2675 len =strlen(patch->old_name);2676if(len > max_len)2677 max_len = len;2678}2679if(patch->new_name) {2680int len =quote_c_style(patch->new_name, NULL, NULL,0);2681if(!len)2682 len =strlen(patch->new_name);2683if(len > max_len)2684 max_len = len;2685}2686}26872688static voidremove_file(struct patch *patch,int rmdir_empty)2689{2690if(update_index) {2691if(remove_file_from_cache(patch->old_name) <0)2692die("unable to remove%sfrom index", patch->old_name);2693}2694if(!cached) {2695if(S_ISGITLINK(patch->old_mode)) {2696if(rmdir(patch->old_name))2697warning("unable to remove submodule%s",2698 patch->old_name);2699}else if(!unlink(patch->old_name) && rmdir_empty) {2700char*name =xstrdup(patch->old_name);2701char*end =strrchr(name,'/');2702while(end) {2703*end =0;2704if(rmdir(name))2705break;2706 end =strrchr(name,'/');2707}2708free(name);2709}2710}2711}27122713static voidadd_index_file(const char*path,unsigned mode,void*buf,unsigned long size)2714{2715struct stat st;2716struct cache_entry *ce;2717int namelen =strlen(path);2718unsigned ce_size =cache_entry_size(namelen);27192720if(!update_index)2721return;27222723 ce =xcalloc(1, ce_size);2724memcpy(ce->name, path, namelen);2725 ce->ce_mode =create_ce_mode(mode);2726 ce->ce_flags =htons(namelen);2727if(S_ISGITLINK(mode)) {2728const char*s = buf;27292730if(get_sha1_hex(s +strlen("Subproject commit "), ce->sha1))2731die("corrupt patch for subproject%s", path);2732}else{2733if(!cached) {2734if(lstat(path, &st) <0)2735die("unable to stat newly created file%s",2736 path);2737fill_stat_cache_info(ce, &st);2738}2739if(write_sha1_file(buf, size, blob_type, ce->sha1) <0)2740die("unable to create backing store for newly created file%s", path);2741}2742if(add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) <0)2743die("unable to add cache entry for%s", path);2744}27452746static inttry_create_file(const char*path,unsigned int mode,const char*buf,unsigned long size)2747{2748int fd;2749struct strbuf nbuf;27502751if(S_ISGITLINK(mode)) {2752struct stat st;2753if(!lstat(path, &st) &&S_ISDIR(st.st_mode))2754return0;2755returnmkdir(path,0777);2756}27572758if(has_symlinks &&S_ISLNK(mode))2759/* Although buf:size is counted string, it also is NUL2760 * terminated.2761 */2762returnsymlink(buf, path);27632764 fd =open(path, O_CREAT | O_EXCL | O_WRONLY, (mode &0100) ?0777:0666);2765if(fd <0)2766return-1;27672768strbuf_init(&nbuf,0);2769if(convert_to_working_tree(path, buf, size, &nbuf)) {2770 size = nbuf.len;2771 buf = nbuf.buf;2772}2773write_or_die(fd, buf, size);2774strbuf_release(&nbuf);27752776if(close(fd) <0)2777die("closing file%s:%s", path,strerror(errno));2778return0;2779}27802781/*2782 * We optimistically assume that the directories exist,2783 * which is true 99% of the time anyway. If they don't,2784 * we create them and try again.2785 */2786static voidcreate_one_file(char*path,unsigned mode,const char*buf,unsigned long size)2787{2788if(cached)2789return;2790if(!try_create_file(path, mode, buf, size))2791return;27922793if(errno == ENOENT) {2794if(safe_create_leading_directories(path))2795return;2796if(!try_create_file(path, mode, buf, size))2797return;2798}27992800if(errno == EEXIST || errno == EACCES) {2801/* We may be trying to create a file where a directory2802 * used to be.2803 */2804struct stat st;2805if(!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))2806 errno = EEXIST;2807}28082809if(errno == EEXIST) {2810unsigned int nr =getpid();28112812for(;;) {2813const char*newpath;2814 newpath =mkpath("%s~%u", path, nr);2815if(!try_create_file(newpath, mode, buf, size)) {2816if(!rename(newpath, path))2817return;2818unlink(newpath);2819break;2820}2821if(errno != EEXIST)2822break;2823++nr;2824}2825}2826die("unable to write file%smode%o", path, mode);2827}28282829static voidcreate_file(struct patch *patch)2830{2831char*path = patch->new_name;2832unsigned mode = patch->new_mode;2833unsigned long size = patch->resultsize;2834char*buf = patch->result;28352836if(!mode)2837 mode = S_IFREG |0644;2838create_one_file(path, mode, buf, size);2839add_index_file(path, mode, buf, size);2840}28412842/* phase zero is to remove, phase one is to create */2843static voidwrite_out_one_result(struct patch *patch,int phase)2844{2845if(patch->is_delete >0) {2846if(phase ==0)2847remove_file(patch,1);2848return;2849}2850if(patch->is_new >0|| patch->is_copy) {2851if(phase ==1)2852create_file(patch);2853return;2854}2855/*2856 * Rename or modification boils down to the same2857 * thing: remove the old, write the new2858 */2859if(phase ==0)2860remove_file(patch, patch->is_rename);2861if(phase ==1)2862create_file(patch);2863}28642865static intwrite_out_one_reject(struct patch *patch)2866{2867FILE*rej;2868char namebuf[PATH_MAX];2869struct fragment *frag;2870int cnt =0;28712872for(cnt =0, frag = patch->fragments; frag; frag = frag->next) {2873if(!frag->rejected)2874continue;2875 cnt++;2876}28772878if(!cnt) {2879if(apply_verbosely)2880say_patch_name(stderr,2881"Applied patch ", patch," cleanly.\n");2882return0;2883}28842885/* This should not happen, because a removal patch that leaves2886 * contents are marked "rejected" at the patch level.2887 */2888if(!patch->new_name)2889die("internal error");28902891/* Say this even without --verbose */2892say_patch_name(stderr,"Applying patch ", patch," with");2893fprintf(stderr,"%drejects...\n", cnt);28942895 cnt =strlen(patch->new_name);2896if(ARRAY_SIZE(namebuf) <= cnt +5) {2897 cnt =ARRAY_SIZE(namebuf) -5;2898fprintf(stderr,2899"warning: truncating .rej filename to %.*s.rej",2900 cnt -1, patch->new_name);2901}2902memcpy(namebuf, patch->new_name, cnt);2903memcpy(namebuf + cnt,".rej",5);29042905 rej =fopen(namebuf,"w");2906if(!rej)2907returnerror("cannot open%s:%s", namebuf,strerror(errno));29082909/* Normal git tools never deal with .rej, so do not pretend2910 * this is a git patch by saying --git nor give extended2911 * headers. While at it, maybe please "kompare" that wants2912 * the trailing TAB and some garbage at the end of line ;-).2913 */2914fprintf(rej,"diff a/%sb/%s\t(rejected hunks)\n",2915 patch->new_name, patch->new_name);2916for(cnt =1, frag = patch->fragments;2917 frag;2918 cnt++, frag = frag->next) {2919if(!frag->rejected) {2920fprintf(stderr,"Hunk #%dapplied cleanly.\n", cnt);2921continue;2922}2923fprintf(stderr,"Rejected hunk #%d.\n", cnt);2924fprintf(rej,"%.*s", frag->size, frag->patch);2925if(frag->patch[frag->size-1] !='\n')2926fputc('\n', rej);2927}2928fclose(rej);2929return-1;2930}29312932static intwrite_out_results(struct patch *list,int skipped_patch)2933{2934int phase;2935int errs =0;2936struct patch *l;29372938if(!list && !skipped_patch)2939returnerror("No changes");29402941for(phase =0; phase <2; phase++) {2942 l = list;2943while(l) {2944if(l->rejected)2945 errs =1;2946else{2947write_out_one_result(l, phase);2948if(phase ==1&&write_out_one_reject(l))2949 errs =1;2950}2951 l = l->next;2952}2953}2954return errs;2955}29562957static struct lock_file lock_file;29582959static struct excludes {2960struct excludes *next;2961const char*path;2962} *excludes;29632964static intuse_patch(struct patch *p)2965{2966const char*pathname = p->new_name ? p->new_name : p->old_name;2967struct excludes *x = excludes;2968while(x) {2969if(fnmatch(x->path, pathname,0) ==0)2970return0;2971 x = x->next;2972}2973if(0< prefix_length) {2974int pathlen =strlen(pathname);2975if(pathlen <= prefix_length ||2976memcmp(prefix, pathname, prefix_length))2977return0;2978}2979return1;2980}29812982static voidprefix_one(char**name)2983{2984char*old_name = *name;2985if(!old_name)2986return;2987*name =xstrdup(prefix_filename(prefix, prefix_length, *name));2988free(old_name);2989}29902991static voidprefix_patches(struct patch *p)2992{2993if(!prefix || p->is_toplevel_relative)2994return;2995for( ; p; p = p->next) {2996if(p->new_name == p->old_name) {2997char*prefixed = p->new_name;2998prefix_one(&prefixed);2999 p->new_name = p->old_name = prefixed;3000}3001else{3002prefix_one(&p->new_name);3003prefix_one(&p->old_name);3004}3005}3006}30073008static intapply_patch(int fd,const char*filename,int inaccurate_eof)3009{3010size_t offset;3011struct strbuf buf;3012struct patch *list = NULL, **listp = &list;3013int skipped_patch =0;30143015strbuf_init(&buf,0);3016 patch_input_file = filename;3017read_patch_file(&buf, fd);3018 offset =0;3019while(offset < buf.len) {3020struct patch *patch;3021int nr;30223023 patch =xcalloc(1,sizeof(*patch));3024 patch->inaccurate_eof = inaccurate_eof;3025 nr =parse_chunk(buf.buf + offset, buf.len - offset, patch);3026if(nr <0)3027break;3028if(apply_in_reverse)3029reverse_patches(patch);3030if(prefix)3031prefix_patches(patch);3032if(use_patch(patch)) {3033patch_stats(patch);3034*listp = patch;3035 listp = &patch->next;3036}3037else{3038/* perhaps free it a bit better? */3039free(patch);3040 skipped_patch++;3041}3042 offset += nr;3043}30443045if(whitespace_error && (ws_error_action == die_on_ws_error))3046 apply =0;30473048 update_index = check_index && apply;3049if(update_index && newfd <0)3050 newfd =hold_locked_index(&lock_file,1);30513052if(check_index) {3053if(read_cache() <0)3054die("unable to read index file");3055}30563057if((check || apply) &&3058check_patch_list(list) <0&&3059!apply_with_reject)3060exit(1);30613062if(apply &&write_out_results(list, skipped_patch))3063exit(1);30643065if(fake_ancestor)3066build_fake_ancestor(list, fake_ancestor);30673068if(diffstat)3069stat_patch_list(list);30703071if(numstat)3072numstat_patch_list(list);30733074if(summary)3075summary_patch_list(list);30763077strbuf_release(&buf);3078return0;3079}30803081static intgit_apply_config(const char*var,const char*value)3082{3083if(!strcmp(var,"apply.whitespace")) {3084 apply_default_whitespace =xstrdup(value);3085return0;3086}3087returngit_default_config(var, value);3088}308930903091intcmd_apply(int argc,const char**argv,const char*unused_prefix)3092{3093int i;3094int read_stdin =1;3095int inaccurate_eof =0;3096int errs =0;3097int is_not_gitdir =0;30983099const char*whitespace_option = NULL;31003101 prefix =setup_git_directory_gently(&is_not_gitdir);3102 prefix_length = prefix ?strlen(prefix) :0;3103git_config(git_apply_config);3104if(apply_default_whitespace)3105parse_whitespace_option(apply_default_whitespace);31063107for(i =1; i < argc; i++) {3108const char*arg = argv[i];3109char*end;3110int fd;31113112if(!strcmp(arg,"-")) {3113 errs |=apply_patch(0,"<stdin>", inaccurate_eof);3114 read_stdin =0;3115continue;3116}3117if(!prefixcmp(arg,"--exclude=")) {3118struct excludes *x =xmalloc(sizeof(*x));3119 x->path = arg +10;3120 x->next = excludes;3121 excludes = x;3122continue;3123}3124if(!prefixcmp(arg,"-p")) {3125 p_value =atoi(arg +2);3126 p_value_known =1;3127continue;3128}3129if(!strcmp(arg,"--no-add")) {3130 no_add =1;3131continue;3132}3133if(!strcmp(arg,"--stat")) {3134 apply =0;3135 diffstat =1;3136continue;3137}3138if(!strcmp(arg,"--allow-binary-replacement") ||3139!strcmp(arg,"--binary")) {3140continue;/* now no-op */3141}3142if(!strcmp(arg,"--numstat")) {3143 apply =0;3144 numstat =1;3145continue;3146}3147if(!strcmp(arg,"--summary")) {3148 apply =0;3149 summary =1;3150continue;3151}3152if(!strcmp(arg,"--check")) {3153 apply =0;3154 check =1;3155continue;3156}3157if(!strcmp(arg,"--index")) {3158if(is_not_gitdir)3159die("--index outside a repository");3160 check_index =1;3161continue;3162}3163if(!strcmp(arg,"--cached")) {3164if(is_not_gitdir)3165die("--cached outside a repository");3166 check_index =1;3167 cached =1;3168continue;3169}3170if(!strcmp(arg,"--apply")) {3171 apply =1;3172continue;3173}3174if(!strcmp(arg,"--build-fake-ancestor")) {3175 apply =0;3176if(++i >= argc)3177die("need a filename");3178 fake_ancestor = argv[i];3179continue;3180}3181if(!strcmp(arg,"-z")) {3182 line_termination =0;3183continue;3184}3185if(!prefixcmp(arg,"-C")) {3186 p_context =strtoul(arg +2, &end,0);3187if(*end !='\0')3188die("unrecognized context count '%s'", arg +2);3189continue;3190}3191if(!prefixcmp(arg,"--whitespace=")) {3192 whitespace_option = arg +13;3193parse_whitespace_option(arg +13);3194continue;3195}3196if(!strcmp(arg,"-R") || !strcmp(arg,"--reverse")) {3197 apply_in_reverse =1;3198continue;3199}3200if(!strcmp(arg,"--unidiff-zero")) {3201 unidiff_zero =1;3202continue;3203}3204if(!strcmp(arg,"--reject")) {3205 apply = apply_with_reject = apply_verbosely =1;3206continue;3207}3208if(!strcmp(arg,"-v") || !strcmp(arg,"--verbose")) {3209 apply_verbosely =1;3210continue;3211}3212if(!strcmp(arg,"--inaccurate-eof")) {3213 inaccurate_eof =1;3214continue;3215}3216if(0< prefix_length)3217 arg =prefix_filename(prefix, prefix_length, arg);32183219 fd =open(arg, O_RDONLY);3220if(fd <0)3221usage(apply_usage);3222 read_stdin =0;3223set_default_whitespace_mode(whitespace_option);3224 errs |=apply_patch(fd, arg, inaccurate_eof);3225close(fd);3226}3227set_default_whitespace_mode(whitespace_option);3228if(read_stdin)3229 errs |=apply_patch(0,"<stdin>", inaccurate_eof);3230if(whitespace_error) {3231if(squelch_whitespace_errors &&3232 squelch_whitespace_errors < whitespace_error) {3233int squelched =3234 whitespace_error - squelch_whitespace_errors;3235fprintf(stderr,"warning: squelched%d"3236"whitespace error%s\n",3237 squelched,3238 squelched ==1?"":"s");3239}3240if(ws_error_action == die_on_ws_error)3241die("%dline%sadd%swhitespace errors.",3242 whitespace_error,3243 whitespace_error ==1?"":"s",3244 whitespace_error ==1?"s":"");3245if(applied_after_fixing_ws && apply)3246fprintf(stderr,"warning:%dline%sapplied after"3247" fixing whitespace errors.\n",3248 applied_after_fixing_ws,3249 applied_after_fixing_ws ==1?"":"s");3250else if(whitespace_error)3251fprintf(stderr,"warning:%dline%sadd%swhitespace errors.\n",3252 whitespace_error,3253 whitespace_error ==1?"":"s",3254 whitespace_error ==1?"s":"");3255}32563257if(update_index) {3258if(write_cache(newfd, active_cache, active_nr) ||3259commit_locked_index(&lock_file))3260die("Unable to write new index file");3261}32623263return!!errs;3264}