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 fixed =0;1529int last_tab_in_indent = -1;1530int last_space_in_indent = -1;1531int need_fix_leading_space =0;1532char*buf;15331534/*1535 * Strip trailing whitespace1536 */1537if((ws_rule & WS_TRAILING_SPACE) &&1538(2< plen &&isspace(patch[plen-2]))) {1539if(patch[plen-1] =='\n')1540 add_nl_to_tail =1;1541 plen--;1542while(0< plen &&isspace(patch[plen-1]))1543 plen--;1544 fixed =1;1545}15461547/*1548 * Check leading whitespaces (indent)1549 */1550for(i =0; i < plen; i++) {1551char ch = patch[i];1552if(ch =='\t') {1553 last_tab_in_indent = i;1554if((ws_rule & WS_SPACE_BEFORE_TAB) &&15550<= last_space_in_indent)1556 need_fix_leading_space =1;1557}else if(ch ==' ') {1558 last_space_in_indent = i;1559if((ws_rule & WS_INDENT_WITH_NON_TAB) &&15608<= i - last_tab_in_indent)1561 need_fix_leading_space =1;1562}else1563break;1564}15651566 buf = output;1567if(need_fix_leading_space) {1568/* Process indent ourselves */1569int consecutive_spaces =0;1570int last = last_tab_in_indent +1;15711572if(ws_rule & WS_INDENT_WITH_NON_TAB) {1573/* have "last" point at one past the indent */1574if(last_tab_in_indent < last_space_in_indent)1575 last = last_space_in_indent +1;1576else1577 last = last_tab_in_indent +1;1578}15791580/*1581 * between patch[0..last-1], strip the funny spaces,1582 * updating them to tab as needed.1583 */1584for(i =0; i < last; i++) {1585char ch = patch[i];1586if(ch !=' ') {1587 consecutive_spaces =0;1588*output++ = ch;1589}else{1590 consecutive_spaces++;1591if(consecutive_spaces ==8) {1592*output++ ='\t';1593 consecutive_spaces =0;1594}1595}1596}1597while(0< consecutive_spaces--)1598*output++ =' ';1599 plen -= last;1600 patch += last;1601 fixed =1;1602}16031604memcpy(output, patch, plen);1605if(add_nl_to_tail)1606 output[plen++] ='\n';1607if(fixed && count_error)1608 applied_after_fixing_ws++;1609return output + plen - buf;1610}16111612static voidupdate_pre_post_images(struct image *preimage,1613struct image *postimage,1614char*buf,1615size_t len)1616{1617int i, ctx;1618char*new, *old, *fixed;1619struct image fixed_preimage;16201621/*1622 * Update the preimage with whitespace fixes. Note that we1623 * are not losing preimage->buf -- apply_one_fragment() will1624 * free "oldlines".1625 */1626prepare_image(&fixed_preimage, buf, len,1);1627assert(fixed_preimage.nr == preimage->nr);1628for(i =0; i < preimage->nr; i++)1629 fixed_preimage.line[i].flag = preimage->line[i].flag;1630free(preimage->line_allocated);1631*preimage = fixed_preimage;16321633/*1634 * Adjust the common context lines in postimage, in place.1635 * This is possible because whitespace fixing does not make1636 * the string grow.1637 */1638new= old = postimage->buf;1639 fixed = preimage->buf;1640for(i = ctx =0; i < postimage->nr; i++) {1641size_t len = postimage->line[i].len;1642if(!(postimage->line[i].flag & LINE_COMMON)) {1643/* an added line -- no counterparts in preimage */1644memmove(new, old, len);1645 old += len;1646new+= len;1647continue;1648}16491650/* a common context -- skip it in the original postimage */1651 old += len;16521653/* and find the corresponding one in the fixed preimage */1654while(ctx < preimage->nr &&1655!(preimage->line[ctx].flag & LINE_COMMON)) {1656 fixed += preimage->line[ctx].len;1657 ctx++;1658}1659if(preimage->nr <= ctx)1660die("oops");16611662/* and copy it in, while fixing the line length */1663 len = preimage->line[ctx].len;1664memcpy(new, fixed, len);1665new+= len;1666 fixed += len;1667 postimage->line[i].len = len;1668 ctx++;1669}16701671/* Fix the length of the whole thing */1672 postimage->len =new- postimage->buf;1673}16741675static intmatch_fragment(struct image *img,1676struct image *preimage,1677struct image *postimage,1678unsigned longtry,1679int try_lno,1680unsigned ws_rule,1681int match_beginning,int match_end)1682{1683int i;1684char*fixed_buf, *buf, *orig, *target;16851686if(preimage->nr + try_lno > img->nr)1687return0;16881689if(match_beginning && try_lno)1690return0;16911692if(match_end && preimage->nr + try_lno != img->nr)1693return0;16941695/* Quick hash check */1696for(i =0; i < preimage->nr; i++)1697if(preimage->line[i].hash != img->line[try_lno + i].hash)1698return0;16991700/*1701 * Do we have an exact match? If we were told to match1702 * at the end, size must be exactly at try+fragsize,1703 * otherwise try+fragsize must be still within the preimage,1704 * and either case, the old piece should match the preimage1705 * exactly.1706 */1707if((match_end1708? (try+ preimage->len == img->len)1709: (try+ preimage->len <= img->len)) &&1710!memcmp(img->buf +try, preimage->buf, preimage->len))1711return1;17121713if(ws_error_action != correct_ws_error)1714return0;17151716/*1717 * The hunk does not apply byte-by-byte, but the hash says1718 * it might with whitespace fuzz.1719 */1720 fixed_buf =xmalloc(preimage->len +1);1721 buf = fixed_buf;1722 orig = preimage->buf;1723 target = img->buf +try;1724for(i =0; i < preimage->nr; i++) {1725size_t fixlen;/* length after fixing the preimage */1726size_t oldlen = preimage->line[i].len;1727size_t tgtlen = img->line[try_lno + i].len;1728size_t tgtfixlen;/* length after fixing the target line */1729char tgtfixbuf[1024], *tgtfix;1730int match;17311732/* Try fixing the line in the preimage */1733 fixlen =copy_wsfix(buf, orig, oldlen, ws_rule,0);17341735/* Try fixing the line in the target */1736if(sizeof(tgtfixbuf) < tgtlen)1737 tgtfix = tgtfixbuf;1738else1739 tgtfix =xmalloc(tgtlen);1740 tgtfixlen =copy_wsfix(tgtfix, target, tgtlen, ws_rule,0);17411742/*1743 * If they match, either the preimage was based on1744 * a version before our tree fixed whitespace breakage,1745 * or we are lacking a whitespace-fix patch the tree1746 * the preimage was based on already had (i.e. target1747 * has whitespace breakage, the preimage doesn't).1748 * In either case, we are fixing the whitespace breakages1749 * so we might as well take the fix together with their1750 * real change.1751 */1752 match = (tgtfixlen == fixlen && !memcmp(tgtfix, buf, fixlen));17531754if(tgtfix != tgtfixbuf)1755free(tgtfix);1756if(!match)1757goto unmatch_exit;17581759 orig += oldlen;1760 buf += fixlen;1761 target += tgtlen;1762}17631764/*1765 * Yes, the preimage is based on an older version that still1766 * has whitespace breakages unfixed, and fixing them makes the1767 * hunk match. Update the context lines in the postimage.1768 */1769update_pre_post_images(preimage, postimage,1770 fixed_buf, buf - fixed_buf);1771return1;17721773 unmatch_exit:1774free(fixed_buf);1775return0;1776}17771778static intfind_pos(struct image *img,1779struct image *preimage,1780struct image *postimage,1781int line,1782unsigned ws_rule,1783int match_beginning,int match_end)1784{1785int i;1786unsigned long backwards, forwards,try;1787int backwards_lno, forwards_lno, try_lno;17881789if(preimage->nr > img->nr)1790return-1;17911792/*1793 * If match_begining or match_end is specified, there is no1794 * point starting from a wrong line that will never match and1795 * wander around and wait for a match at the specified end.1796 */1797if(match_beginning)1798 line =0;1799else if(match_end)1800 line = img->nr - preimage->nr;18011802try=0;1803for(i =0; i < line; i++)1804try+= img->line[i].len;18051806/*1807 * There's probably some smart way to do this, but I'll leave1808 * that to the smart and beautiful people. I'm simple and stupid.1809 */1810 backwards =try;1811 backwards_lno = line;1812 forwards =try;1813 forwards_lno = line;1814 try_lno = line;18151816for(i =0; ; i++) {1817if(match_fragment(img, preimage, postimage,1818try, try_lno, ws_rule,1819 match_beginning, match_end))1820return try_lno;18211822 again:1823if(backwards_lno ==0&& forwards_lno == img->nr)1824break;18251826if(i &1) {1827if(backwards_lno ==0) {1828 i++;1829goto again;1830}1831 backwards_lno--;1832 backwards -= img->line[backwards_lno].len;1833try= backwards;1834 try_lno = backwards_lno;1835}else{1836if(forwards_lno == img->nr) {1837 i++;1838goto again;1839}1840 forwards += img->line[forwards_lno].len;1841 forwards_lno++;1842try= forwards;1843 try_lno = forwards_lno;1844}18451846}1847return-1;1848}18491850static voidremove_first_line(struct image *img)1851{1852 img->buf += img->line[0].len;1853 img->len -= img->line[0].len;1854 img->line++;1855 img->nr--;1856}18571858static voidremove_last_line(struct image *img)1859{1860 img->len -= img->line[--img->nr].len;1861}18621863static voidupdate_image(struct image *img,1864int applied_pos,1865struct image *preimage,1866struct image *postimage)1867{1868/*1869 * remove the copy of preimage at offset in img1870 * and replace it with postimage1871 */1872int i, nr;1873size_t remove_count, insert_count, applied_at =0;1874char*result;18751876for(i =0; i < applied_pos; i++)1877 applied_at += img->line[i].len;18781879 remove_count =0;1880for(i =0; i < preimage->nr; i++)1881 remove_count += img->line[applied_pos + i].len;1882 insert_count = postimage->len;18831884/* Adjust the contents */1885 result =xmalloc(img->len + insert_count - remove_count +1);1886memcpy(result, img->buf, applied_at);1887memcpy(result + applied_at, postimage->buf, postimage->len);1888memcpy(result + applied_at + postimage->len,1889 img->buf + (applied_at + remove_count),1890 img->len - (applied_at + remove_count));1891free(img->buf);1892 img->buf = result;1893 img->len += insert_count - remove_count;1894 result[img->len] ='\0';18951896/* Adjust the line table */1897 nr = img->nr + postimage->nr - preimage->nr;1898if(preimage->nr < postimage->nr) {1899/*1900 * NOTE: this knows that we never call remove_first_line()1901 * on anything other than pre/post image.1902 */1903 img->line =xrealloc(img->line, nr *sizeof(*img->line));1904 img->line_allocated = img->line;1905}1906if(preimage->nr != postimage->nr)1907memmove(img->line + applied_pos + postimage->nr,1908 img->line + applied_pos + preimage->nr,1909(img->nr - (applied_pos + preimage->nr)) *1910sizeof(*img->line));1911memcpy(img->line + applied_pos,1912 postimage->line,1913 postimage->nr *sizeof(*img->line));1914 img->nr = nr;1915}19161917static intapply_one_fragment(struct image *img,struct fragment *frag,1918int inaccurate_eof,unsigned ws_rule)1919{1920int match_beginning, match_end;1921const char*patch = frag->patch;1922int size = frag->size;1923char*old, *new, *oldlines, *newlines;1924int new_blank_lines_at_end =0;1925unsigned long leading, trailing;1926int pos, applied_pos;1927struct image preimage;1928struct image postimage;19291930memset(&preimage,0,sizeof(preimage));1931memset(&postimage,0,sizeof(postimage));1932 oldlines =xmalloc(size);1933 newlines =xmalloc(size);19341935 old = oldlines;1936new= newlines;1937while(size >0) {1938char first;1939int len =linelen(patch, size);1940int plen, added;1941int added_blank_line =0;19421943if(!len)1944break;19451946/*1947 * "plen" is how much of the line we should use for1948 * the actual patch data. Normally we just remove the1949 * first character on the line, but if the line is1950 * followed by "\ No newline", then we also remove the1951 * last one (which is the newline, of course).1952 */1953 plen = len -1;1954if(len < size && patch[len] =='\\')1955 plen--;1956 first = *patch;1957if(apply_in_reverse) {1958if(first =='-')1959 first ='+';1960else if(first =='+')1961 first ='-';1962}19631964switch(first) {1965case'\n':1966/* Newer GNU diff, empty context line */1967if(plen <0)1968/* ... followed by '\No newline'; nothing */1969break;1970*old++ ='\n';1971*new++ ='\n';1972add_line_info(&preimage,"\n",1, LINE_COMMON);1973add_line_info(&postimage,"\n",1, LINE_COMMON);1974break;1975case' ':1976case'-':1977memcpy(old, patch +1, plen);1978add_line_info(&preimage, old, plen,1979(first ==' '? LINE_COMMON :0));1980 old += plen;1981if(first =='-')1982break;1983/* Fall-through for ' ' */1984case'+':1985/* --no-add does not add new lines */1986if(first =='+'&& no_add)1987break;19881989if(first !='+'||1990!whitespace_error ||1991 ws_error_action != correct_ws_error) {1992memcpy(new, patch +1, plen);1993 added = plen;1994}1995else{1996 added =copy_wsfix(new, patch +1, plen,1997 ws_rule,1);1998}1999add_line_info(&postimage,new, added,2000(first =='+'?0: LINE_COMMON));2001new+= added;2002if(first =='+'&&2003 added ==1&&new[-1] =='\n')2004 added_blank_line =1;2005break;2006case'@':case'\\':2007/* Ignore it, we already handled it */2008break;2009default:2010if(apply_verbosely)2011error("invalid start of line: '%c'", first);2012return-1;2013}2014if(added_blank_line)2015 new_blank_lines_at_end++;2016else2017 new_blank_lines_at_end =0;2018 patch += len;2019 size -= len;2020}2021if(inaccurate_eof &&2022 old > oldlines && old[-1] =='\n'&&2023new> newlines &&new[-1] =='\n') {2024 old--;2025new--;2026}20272028 leading = frag->leading;2029 trailing = frag->trailing;20302031/*2032 * If we don't have any leading/trailing data in the patch,2033 * we want it to match at the beginning/end of the file.2034 *2035 * But that would break if the patch is generated with2036 * --unified=0; sane people wouldn't do that to cause us2037 * trouble, but we try to please not so sane ones as well.2038 */2039if(unidiff_zero) {2040 match_beginning = (!leading && !frag->oldpos);2041 match_end =0;2042}2043else{2044 match_beginning = !leading && (frag->oldpos ==1);2045 match_end = !trailing;2046}20472048 pos = frag->newpos ? (frag->newpos -1) :0;2049 preimage.buf = oldlines;2050 preimage.len = old - oldlines;2051 postimage.buf = newlines;2052 postimage.len =new- newlines;2053 preimage.line = preimage.line_allocated;2054 postimage.line = postimage.line_allocated;20552056for(;;) {20572058 applied_pos =find_pos(img, &preimage, &postimage, pos,2059 ws_rule, match_beginning, match_end);20602061if(applied_pos >=0)2062break;20632064/* Am I at my context limits? */2065if((leading <= p_context) && (trailing <= p_context))2066break;2067if(match_beginning || match_end) {2068 match_beginning = match_end =0;2069continue;2070}20712072/*2073 * Reduce the number of context lines; reduce both2074 * leading and trailing if they are equal otherwise2075 * just reduce the larger context.2076 */2077if(leading >= trailing) {2078remove_first_line(&preimage);2079remove_first_line(&postimage);2080 pos--;2081 leading--;2082}2083if(trailing > leading) {2084remove_last_line(&preimage);2085remove_last_line(&postimage);2086 trailing--;2087}2088}20892090if(applied_pos >=0) {2091if(ws_error_action == correct_ws_error &&2092 new_blank_lines_at_end &&2093 postimage.nr + applied_pos == img->nr) {2094/*2095 * If the patch application adds blank lines2096 * at the end, and if the patch applies at the2097 * end of the image, remove those added blank2098 * lines.2099 */2100while(new_blank_lines_at_end--)2101remove_last_line(&postimage);2102}21032104/*2105 * Warn if it was necessary to reduce the number2106 * of context lines.2107 */2108if((leading != frag->leading) ||2109(trailing != frag->trailing))2110fprintf(stderr,"Context reduced to (%ld/%ld)"2111" to apply fragment at%d\n",2112 leading, trailing, applied_pos+1);2113update_image(img, applied_pos, &preimage, &postimage);2114}else{2115if(apply_verbosely)2116error("while searching for:\n%.*s",2117(int)(old - oldlines), oldlines);2118}21192120free(oldlines);2121free(newlines);2122free(preimage.line_allocated);2123free(postimage.line_allocated);21242125return(applied_pos <0);2126}21272128static intapply_binary_fragment(struct image *img,struct patch *patch)2129{2130struct fragment *fragment = patch->fragments;2131unsigned long len;2132void*dst;21332134/* Binary patch is irreversible without the optional second hunk */2135if(apply_in_reverse) {2136if(!fragment->next)2137returnerror("cannot reverse-apply a binary patch "2138"without the reverse hunk to '%s'",2139 patch->new_name2140? patch->new_name : patch->old_name);2141 fragment = fragment->next;2142}2143switch(fragment->binary_patch_method) {2144case BINARY_DELTA_DEFLATED:2145 dst =patch_delta(img->buf, img->len, fragment->patch,2146 fragment->size, &len);2147if(!dst)2148return-1;2149clear_image(img);2150 img->buf = dst;2151 img->len = len;2152return0;2153case BINARY_LITERAL_DEFLATED:2154clear_image(img);2155 img->len = fragment->size;2156 img->buf =xmalloc(img->len+1);2157memcpy(img->buf, fragment->patch, img->len);2158 img->buf[img->len] ='\0';2159return0;2160}2161return-1;2162}21632164static intapply_binary(struct image *img,struct patch *patch)2165{2166const char*name = patch->old_name ? patch->old_name : patch->new_name;2167unsigned char sha1[20];21682169/*2170 * For safety, we require patch index line to contain2171 * full 40-byte textual SHA1 for old and new, at least for now.2172 */2173if(strlen(patch->old_sha1_prefix) !=40||2174strlen(patch->new_sha1_prefix) !=40||2175get_sha1_hex(patch->old_sha1_prefix, sha1) ||2176get_sha1_hex(patch->new_sha1_prefix, sha1))2177returnerror("cannot apply binary patch to '%s' "2178"without full index line", name);21792180if(patch->old_name) {2181/*2182 * See if the old one matches what the patch2183 * applies to.2184 */2185hash_sha1_file(img->buf, img->len, blob_type, sha1);2186if(strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))2187returnerror("the patch applies to '%s' (%s), "2188"which does not match the "2189"current contents.",2190 name,sha1_to_hex(sha1));2191}2192else{2193/* Otherwise, the old one must be empty. */2194if(img->len)2195returnerror("the patch applies to an empty "2196"'%s' but it is not empty", name);2197}21982199get_sha1_hex(patch->new_sha1_prefix, sha1);2200if(is_null_sha1(sha1)) {2201clear_image(img);2202return0;/* deletion patch */2203}22042205if(has_sha1_file(sha1)) {2206/* We already have the postimage */2207enum object_type type;2208unsigned long size;2209char*result;22102211 result =read_sha1_file(sha1, &type, &size);2212if(!result)2213returnerror("the necessary postimage%sfor "2214"'%s' cannot be read",2215 patch->new_sha1_prefix, name);2216clear_image(img);2217 img->buf = result;2218 img->len = size;2219}else{2220/*2221 * We have verified buf matches the preimage;2222 * apply the patch data to it, which is stored2223 * in the patch->fragments->{patch,size}.2224 */2225if(apply_binary_fragment(img, patch))2226returnerror("binary patch does not apply to '%s'",2227 name);22282229/* verify that the result matches */2230hash_sha1_file(img->buf, img->len, blob_type, sha1);2231if(strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))2232returnerror("binary patch to '%s' creates incorrect result (expecting%s, got%s)",2233 name, patch->new_sha1_prefix,sha1_to_hex(sha1));2234}22352236return0;2237}22382239static intapply_fragments(struct image *img,struct patch *patch)2240{2241struct fragment *frag = patch->fragments;2242const char*name = patch->old_name ? patch->old_name : patch->new_name;2243unsigned ws_rule = patch->ws_rule;2244unsigned inaccurate_eof = patch->inaccurate_eof;22452246if(patch->is_binary)2247returnapply_binary(img, patch);22482249while(frag) {2250if(apply_one_fragment(img, frag, inaccurate_eof, ws_rule)) {2251error("patch failed:%s:%ld", name, frag->oldpos);2252if(!apply_with_reject)2253return-1;2254 frag->rejected =1;2255}2256 frag = frag->next;2257}2258return0;2259}22602261static intread_file_or_gitlink(struct cache_entry *ce,struct strbuf *buf)2262{2263if(!ce)2264return0;22652266if(S_ISGITLINK(ntohl(ce->ce_mode))) {2267strbuf_grow(buf,100);2268strbuf_addf(buf,"Subproject commit%s\n",sha1_to_hex(ce->sha1));2269}else{2270enum object_type type;2271unsigned long sz;2272char*result;22732274 result =read_sha1_file(ce->sha1, &type, &sz);2275if(!result)2276return-1;2277/* XXX read_sha1_file NUL-terminates */2278strbuf_attach(buf, result, sz, sz +1);2279}2280return0;2281}22822283static intapply_data(struct patch *patch,struct stat *st,struct cache_entry *ce)2284{2285struct strbuf buf;2286struct image image;2287size_t len;2288char*img;22892290strbuf_init(&buf,0);2291if(cached) {2292if(read_file_or_gitlink(ce, &buf))2293returnerror("read of%sfailed", patch->old_name);2294}else if(patch->old_name) {2295if(S_ISGITLINK(patch->old_mode)) {2296if(ce) {2297read_file_or_gitlink(ce, &buf);2298}else{2299/*2300 * There is no way to apply subproject2301 * patch without looking at the index.2302 */2303 patch->fragments = NULL;2304}2305}else{2306if(read_old_data(st, patch->old_name, &buf))2307returnerror("read of%sfailed", patch->old_name);2308}2309}23102311 img =strbuf_detach(&buf, &len);2312prepare_image(&image, img, len, !patch->is_binary);23132314if(apply_fragments(&image, patch) <0)2315return-1;/* note with --reject this succeeds. */2316 patch->result = image.buf;2317 patch->resultsize = image.len;2318free(image.line_allocated);23192320if(0< patch->is_delete && patch->resultsize)2321returnerror("removal patch leaves file contents");23222323return0;2324}23252326static intcheck_to_create_blob(const char*new_name,int ok_if_exists)2327{2328struct stat nst;2329if(!lstat(new_name, &nst)) {2330if(S_ISDIR(nst.st_mode) || ok_if_exists)2331return0;2332/*2333 * A leading component of new_name might be a symlink2334 * that is going to be removed with this patch, but2335 * still pointing at somewhere that has the path.2336 * In such a case, path "new_name" does not exist as2337 * far as git is concerned.2338 */2339if(has_symlink_leading_path(new_name, NULL))2340return0;23412342returnerror("%s: already exists in working directory", new_name);2343}2344else if((errno != ENOENT) && (errno != ENOTDIR))2345returnerror("%s:%s", new_name,strerror(errno));2346return0;2347}23482349static intverify_index_match(struct cache_entry *ce,struct stat *st)2350{2351if(S_ISGITLINK(ntohl(ce->ce_mode))) {2352if(!S_ISDIR(st->st_mode))2353return-1;2354return0;2355}2356returnce_match_stat(ce, st, CE_MATCH_IGNORE_VALID);2357}23582359static intcheck_patch(struct patch *patch,struct patch *prev_patch)2360{2361struct stat st;2362const char*old_name = patch->old_name;2363const char*new_name = patch->new_name;2364const char*name = old_name ? old_name : new_name;2365struct cache_entry *ce = NULL;2366int ok_if_exists;23672368 patch->rejected =1;/* we will drop this after we succeed */23692370/*2371 * Make sure that we do not have local modifications from the2372 * index when we are looking at the index. Also make sure2373 * we have the preimage file to be patched in the work tree,2374 * unless --cached, which tells git to apply only in the index.2375 */2376if(old_name) {2377int stat_ret =0;2378unsigned st_mode =0;23792380if(!cached)2381 stat_ret =lstat(old_name, &st);2382if(check_index) {2383int pos =cache_name_pos(old_name,strlen(old_name));2384if(pos <0)2385returnerror("%s: does not exist in index",2386 old_name);2387 ce = active_cache[pos];2388if(stat_ret <0) {2389struct checkout costate;2390if(errno != ENOENT)2391returnerror("%s:%s", old_name,2392strerror(errno));2393/* checkout */2394 costate.base_dir ="";2395 costate.base_dir_len =0;2396 costate.force =0;2397 costate.quiet =0;2398 costate.not_new =0;2399 costate.refresh_cache =1;2400if(checkout_entry(ce,2401&costate,2402 NULL) ||2403lstat(old_name, &st))2404return-1;2405}2406if(!cached &&verify_index_match(ce, &st))2407returnerror("%s: does not match index",2408 old_name);2409if(cached)2410 st_mode =ntohl(ce->ce_mode);2411}else if(stat_ret <0)2412returnerror("%s:%s", old_name,strerror(errno));24132414if(!cached)2415 st_mode =ntohl(ce_mode_from_stat(ce, st.st_mode));24162417if(patch->is_new <0)2418 patch->is_new =0;2419if(!patch->old_mode)2420 patch->old_mode = st_mode;2421if((st_mode ^ patch->old_mode) & S_IFMT)2422returnerror("%s: wrong type", old_name);2423if(st_mode != patch->old_mode)2424fprintf(stderr,"warning:%shas type%o, expected%o\n",2425 old_name, st_mode, patch->old_mode);2426}24272428if(new_name && prev_patch &&0< prev_patch->is_delete &&2429!strcmp(prev_patch->old_name, new_name))2430/*2431 * A type-change diff is always split into a patch to2432 * delete old, immediately followed by a patch to2433 * create new (see diff.c::run_diff()); in such a case2434 * it is Ok that the entry to be deleted by the2435 * previous patch is still in the working tree and in2436 * the index.2437 */2438 ok_if_exists =1;2439else2440 ok_if_exists =0;24412442if(new_name &&2443((0< patch->is_new) | (0< patch->is_rename) | patch->is_copy)) {2444if(check_index &&2445cache_name_pos(new_name,strlen(new_name)) >=0&&2446!ok_if_exists)2447returnerror("%s: already exists in index", new_name);2448if(!cached) {2449int err =check_to_create_blob(new_name, ok_if_exists);2450if(err)2451return err;2452}2453if(!patch->new_mode) {2454if(0< patch->is_new)2455 patch->new_mode = S_IFREG |0644;2456else2457 patch->new_mode = patch->old_mode;2458}2459}24602461if(new_name && old_name) {2462int same = !strcmp(old_name, new_name);2463if(!patch->new_mode)2464 patch->new_mode = patch->old_mode;2465if((patch->old_mode ^ patch->new_mode) & S_IFMT)2466returnerror("new mode (%o) of%sdoes not match old mode (%o)%s%s",2467 patch->new_mode, new_name, patch->old_mode,2468 same ?"":" of ", same ?"": old_name);2469}24702471if(apply_data(patch, &st, ce) <0)2472returnerror("%s: patch does not apply", name);2473 patch->rejected =0;2474return0;2475}24762477static intcheck_patch_list(struct patch *patch)2478{2479struct patch *prev_patch = NULL;2480int err =0;24812482for(prev_patch = NULL; patch ; patch = patch->next) {2483if(apply_verbosely)2484say_patch_name(stderr,2485"Checking patch ", patch,"...\n");2486 err |=check_patch(patch, prev_patch);2487 prev_patch = patch;2488}2489return err;2490}24912492/* This function tries to read the sha1 from the current index */2493static intget_current_sha1(const char*path,unsigned char*sha1)2494{2495int pos;24962497if(read_cache() <0)2498return-1;2499 pos =cache_name_pos(path,strlen(path));2500if(pos <0)2501return-1;2502hashcpy(sha1, active_cache[pos]->sha1);2503return0;2504}25052506/* Build an index that contains the just the files needed for a 3way merge */2507static voidbuild_fake_ancestor(struct patch *list,const char*filename)2508{2509struct patch *patch;2510struct index_state result = {0};2511int fd;25122513/* Once we start supporting the reverse patch, it may be2514 * worth showing the new sha1 prefix, but until then...2515 */2516for(patch = list; patch; patch = patch->next) {2517const unsigned char*sha1_ptr;2518unsigned char sha1[20];2519struct cache_entry *ce;2520const char*name;25212522 name = patch->old_name ? patch->old_name : patch->new_name;2523if(0< patch->is_new)2524continue;2525else if(get_sha1(patch->old_sha1_prefix, sha1))2526/* git diff has no index line for mode/type changes */2527if(!patch->lines_added && !patch->lines_deleted) {2528if(get_current_sha1(patch->new_name, sha1) ||2529get_current_sha1(patch->old_name, sha1))2530die("mode change for%s, which is not "2531"in current HEAD", name);2532 sha1_ptr = sha1;2533}else2534die("sha1 information is lacking or useless "2535"(%s).", name);2536else2537 sha1_ptr = sha1;25382539 ce =make_cache_entry(patch->old_mode, sha1_ptr, name,0,0);2540if(add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))2541die("Could not add%sto temporary index", name);2542}25432544 fd =open(filename, O_WRONLY | O_CREAT,0666);2545if(fd <0||write_index(&result, fd) ||close(fd))2546die("Could not write temporary index to%s", filename);25472548discard_index(&result);2549}25502551static voidstat_patch_list(struct patch *patch)2552{2553int files, adds, dels;25542555for(files = adds = dels =0; patch ; patch = patch->next) {2556 files++;2557 adds += patch->lines_added;2558 dels += patch->lines_deleted;2559show_stats(patch);2560}25612562printf("%dfiles changed,%dinsertions(+),%ddeletions(-)\n", files, adds, dels);2563}25642565static voidnumstat_patch_list(struct patch *patch)2566{2567for( ; patch; patch = patch->next) {2568const char*name;2569 name = patch->new_name ? patch->new_name : patch->old_name;2570if(patch->is_binary)2571printf("-\t-\t");2572else2573printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);2574write_name_quoted(name, stdout, line_termination);2575}2576}25772578static voidshow_file_mode_name(const char*newdelete,unsigned int mode,const char*name)2579{2580if(mode)2581printf("%smode%06o%s\n", newdelete, mode, name);2582else2583printf("%s %s\n", newdelete, name);2584}25852586static voidshow_mode_change(struct patch *p,int show_name)2587{2588if(p->old_mode && p->new_mode && p->old_mode != p->new_mode) {2589if(show_name)2590printf(" mode change%06o =>%06o%s\n",2591 p->old_mode, p->new_mode, p->new_name);2592else2593printf(" mode change%06o =>%06o\n",2594 p->old_mode, p->new_mode);2595}2596}25972598static voidshow_rename_copy(struct patch *p)2599{2600const char*renamecopy = p->is_rename ?"rename":"copy";2601const char*old, *new;26022603/* Find common prefix */2604 old = p->old_name;2605new= p->new_name;2606while(1) {2607const char*slash_old, *slash_new;2608 slash_old =strchr(old,'/');2609 slash_new =strchr(new,'/');2610if(!slash_old ||2611!slash_new ||2612 slash_old - old != slash_new -new||2613memcmp(old,new, slash_new -new))2614break;2615 old = slash_old +1;2616new= slash_new +1;2617}2618/* p->old_name thru old is the common prefix, and old and new2619 * through the end of names are renames2620 */2621if(old != p->old_name)2622printf("%s%.*s{%s=>%s} (%d%%)\n", renamecopy,2623(int)(old - p->old_name), p->old_name,2624 old,new, p->score);2625else2626printf("%s %s=>%s(%d%%)\n", renamecopy,2627 p->old_name, p->new_name, p->score);2628show_mode_change(p,0);2629}26302631static voidsummary_patch_list(struct patch *patch)2632{2633struct patch *p;26342635for(p = patch; p; p = p->next) {2636if(p->is_new)2637show_file_mode_name("create", p->new_mode, p->new_name);2638else if(p->is_delete)2639show_file_mode_name("delete", p->old_mode, p->old_name);2640else{2641if(p->is_rename || p->is_copy)2642show_rename_copy(p);2643else{2644if(p->score) {2645printf(" rewrite%s(%d%%)\n",2646 p->new_name, p->score);2647show_mode_change(p,0);2648}2649else2650show_mode_change(p,1);2651}2652}2653}2654}26552656static voidpatch_stats(struct patch *patch)2657{2658int lines = patch->lines_added + patch->lines_deleted;26592660if(lines > max_change)2661 max_change = lines;2662if(patch->old_name) {2663int len =quote_c_style(patch->old_name, NULL, NULL,0);2664if(!len)2665 len =strlen(patch->old_name);2666if(len > max_len)2667 max_len = len;2668}2669if(patch->new_name) {2670int len =quote_c_style(patch->new_name, NULL, NULL,0);2671if(!len)2672 len =strlen(patch->new_name);2673if(len > max_len)2674 max_len = len;2675}2676}26772678static voidremove_file(struct patch *patch,int rmdir_empty)2679{2680if(update_index) {2681if(remove_file_from_cache(patch->old_name) <0)2682die("unable to remove%sfrom index", patch->old_name);2683}2684if(!cached) {2685if(S_ISGITLINK(patch->old_mode)) {2686if(rmdir(patch->old_name))2687warning("unable to remove submodule%s",2688 patch->old_name);2689}else if(!unlink(patch->old_name) && rmdir_empty) {2690char*name =xstrdup(patch->old_name);2691char*end =strrchr(name,'/');2692while(end) {2693*end =0;2694if(rmdir(name))2695break;2696 end =strrchr(name,'/');2697}2698free(name);2699}2700}2701}27022703static voidadd_index_file(const char*path,unsigned mode,void*buf,unsigned long size)2704{2705struct stat st;2706struct cache_entry *ce;2707int namelen =strlen(path);2708unsigned ce_size =cache_entry_size(namelen);27092710if(!update_index)2711return;27122713 ce =xcalloc(1, ce_size);2714memcpy(ce->name, path, namelen);2715 ce->ce_mode =create_ce_mode(mode);2716 ce->ce_flags =htons(namelen);2717if(S_ISGITLINK(mode)) {2718const char*s = buf;27192720if(get_sha1_hex(s +strlen("Subproject commit "), ce->sha1))2721die("corrupt patch for subproject%s", path);2722}else{2723if(!cached) {2724if(lstat(path, &st) <0)2725die("unable to stat newly created file%s",2726 path);2727fill_stat_cache_info(ce, &st);2728}2729if(write_sha1_file(buf, size, blob_type, ce->sha1) <0)2730die("unable to create backing store for newly created file%s", path);2731}2732if(add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) <0)2733die("unable to add cache entry for%s", path);2734}27352736static inttry_create_file(const char*path,unsigned int mode,const char*buf,unsigned long size)2737{2738int fd;2739struct strbuf nbuf;27402741if(S_ISGITLINK(mode)) {2742struct stat st;2743if(!lstat(path, &st) &&S_ISDIR(st.st_mode))2744return0;2745returnmkdir(path,0777);2746}27472748if(has_symlinks &&S_ISLNK(mode))2749/* Although buf:size is counted string, it also is NUL2750 * terminated.2751 */2752returnsymlink(buf, path);27532754 fd =open(path, O_CREAT | O_EXCL | O_WRONLY, (mode &0100) ?0777:0666);2755if(fd <0)2756return-1;27572758strbuf_init(&nbuf,0);2759if(convert_to_working_tree(path, buf, size, &nbuf)) {2760 size = nbuf.len;2761 buf = nbuf.buf;2762}2763write_or_die(fd, buf, size);2764strbuf_release(&nbuf);27652766if(close(fd) <0)2767die("closing file%s:%s", path,strerror(errno));2768return0;2769}27702771/*2772 * We optimistically assume that the directories exist,2773 * which is true 99% of the time anyway. If they don't,2774 * we create them and try again.2775 */2776static voidcreate_one_file(char*path,unsigned mode,const char*buf,unsigned long size)2777{2778if(cached)2779return;2780if(!try_create_file(path, mode, buf, size))2781return;27822783if(errno == ENOENT) {2784if(safe_create_leading_directories(path))2785return;2786if(!try_create_file(path, mode, buf, size))2787return;2788}27892790if(errno == EEXIST || errno == EACCES) {2791/* We may be trying to create a file where a directory2792 * used to be.2793 */2794struct stat st;2795if(!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))2796 errno = EEXIST;2797}27982799if(errno == EEXIST) {2800unsigned int nr =getpid();28012802for(;;) {2803const char*newpath;2804 newpath =mkpath("%s~%u", path, nr);2805if(!try_create_file(newpath, mode, buf, size)) {2806if(!rename(newpath, path))2807return;2808unlink(newpath);2809break;2810}2811if(errno != EEXIST)2812break;2813++nr;2814}2815}2816die("unable to write file%smode%o", path, mode);2817}28182819static voidcreate_file(struct patch *patch)2820{2821char*path = patch->new_name;2822unsigned mode = patch->new_mode;2823unsigned long size = patch->resultsize;2824char*buf = patch->result;28252826if(!mode)2827 mode = S_IFREG |0644;2828create_one_file(path, mode, buf, size);2829add_index_file(path, mode, buf, size);2830}28312832/* phase zero is to remove, phase one is to create */2833static voidwrite_out_one_result(struct patch *patch,int phase)2834{2835if(patch->is_delete >0) {2836if(phase ==0)2837remove_file(patch,1);2838return;2839}2840if(patch->is_new >0|| patch->is_copy) {2841if(phase ==1)2842create_file(patch);2843return;2844}2845/*2846 * Rename or modification boils down to the same2847 * thing: remove the old, write the new2848 */2849if(phase ==0)2850remove_file(patch, patch->is_rename);2851if(phase ==1)2852create_file(patch);2853}28542855static intwrite_out_one_reject(struct patch *patch)2856{2857FILE*rej;2858char namebuf[PATH_MAX];2859struct fragment *frag;2860int cnt =0;28612862for(cnt =0, frag = patch->fragments; frag; frag = frag->next) {2863if(!frag->rejected)2864continue;2865 cnt++;2866}28672868if(!cnt) {2869if(apply_verbosely)2870say_patch_name(stderr,2871"Applied patch ", patch," cleanly.\n");2872return0;2873}28742875/* This should not happen, because a removal patch that leaves2876 * contents are marked "rejected" at the patch level.2877 */2878if(!patch->new_name)2879die("internal error");28802881/* Say this even without --verbose */2882say_patch_name(stderr,"Applying patch ", patch," with");2883fprintf(stderr,"%drejects...\n", cnt);28842885 cnt =strlen(patch->new_name);2886if(ARRAY_SIZE(namebuf) <= cnt +5) {2887 cnt =ARRAY_SIZE(namebuf) -5;2888fprintf(stderr,2889"warning: truncating .rej filename to %.*s.rej",2890 cnt -1, patch->new_name);2891}2892memcpy(namebuf, patch->new_name, cnt);2893memcpy(namebuf + cnt,".rej",5);28942895 rej =fopen(namebuf,"w");2896if(!rej)2897returnerror("cannot open%s:%s", namebuf,strerror(errno));28982899/* Normal git tools never deal with .rej, so do not pretend2900 * this is a git patch by saying --git nor give extended2901 * headers. While at it, maybe please "kompare" that wants2902 * the trailing TAB and some garbage at the end of line ;-).2903 */2904fprintf(rej,"diff a/%sb/%s\t(rejected hunks)\n",2905 patch->new_name, patch->new_name);2906for(cnt =1, frag = patch->fragments;2907 frag;2908 cnt++, frag = frag->next) {2909if(!frag->rejected) {2910fprintf(stderr,"Hunk #%dapplied cleanly.\n", cnt);2911continue;2912}2913fprintf(stderr,"Rejected hunk #%d.\n", cnt);2914fprintf(rej,"%.*s", frag->size, frag->patch);2915if(frag->patch[frag->size-1] !='\n')2916fputc('\n', rej);2917}2918fclose(rej);2919return-1;2920}29212922static intwrite_out_results(struct patch *list,int skipped_patch)2923{2924int phase;2925int errs =0;2926struct patch *l;29272928if(!list && !skipped_patch)2929returnerror("No changes");29302931for(phase =0; phase <2; phase++) {2932 l = list;2933while(l) {2934if(l->rejected)2935 errs =1;2936else{2937write_out_one_result(l, phase);2938if(phase ==1&&write_out_one_reject(l))2939 errs =1;2940}2941 l = l->next;2942}2943}2944return errs;2945}29462947static struct lock_file lock_file;29482949static struct excludes {2950struct excludes *next;2951const char*path;2952} *excludes;29532954static intuse_patch(struct patch *p)2955{2956const char*pathname = p->new_name ? p->new_name : p->old_name;2957struct excludes *x = excludes;2958while(x) {2959if(fnmatch(x->path, pathname,0) ==0)2960return0;2961 x = x->next;2962}2963if(0< prefix_length) {2964int pathlen =strlen(pathname);2965if(pathlen <= prefix_length ||2966memcmp(prefix, pathname, prefix_length))2967return0;2968}2969return1;2970}29712972static voidprefix_one(char**name)2973{2974char*old_name = *name;2975if(!old_name)2976return;2977*name =xstrdup(prefix_filename(prefix, prefix_length, *name));2978free(old_name);2979}29802981static voidprefix_patches(struct patch *p)2982{2983if(!prefix || p->is_toplevel_relative)2984return;2985for( ; p; p = p->next) {2986if(p->new_name == p->old_name) {2987char*prefixed = p->new_name;2988prefix_one(&prefixed);2989 p->new_name = p->old_name = prefixed;2990}2991else{2992prefix_one(&p->new_name);2993prefix_one(&p->old_name);2994}2995}2996}29972998static intapply_patch(int fd,const char*filename,int inaccurate_eof)2999{3000size_t offset;3001struct strbuf buf;3002struct patch *list = NULL, **listp = &list;3003int skipped_patch =0;30043005strbuf_init(&buf,0);3006 patch_input_file = filename;3007read_patch_file(&buf, fd);3008 offset =0;3009while(offset < buf.len) {3010struct patch *patch;3011int nr;30123013 patch =xcalloc(1,sizeof(*patch));3014 patch->inaccurate_eof = inaccurate_eof;3015 nr =parse_chunk(buf.buf + offset, buf.len - offset, patch);3016if(nr <0)3017break;3018if(apply_in_reverse)3019reverse_patches(patch);3020if(prefix)3021prefix_patches(patch);3022if(use_patch(patch)) {3023patch_stats(patch);3024*listp = patch;3025 listp = &patch->next;3026}3027else{3028/* perhaps free it a bit better? */3029free(patch);3030 skipped_patch++;3031}3032 offset += nr;3033}30343035if(whitespace_error && (ws_error_action == die_on_ws_error))3036 apply =0;30373038 update_index = check_index && apply;3039if(update_index && newfd <0)3040 newfd =hold_locked_index(&lock_file,1);30413042if(check_index) {3043if(read_cache() <0)3044die("unable to read index file");3045}30463047if((check || apply) &&3048check_patch_list(list) <0&&3049!apply_with_reject)3050exit(1);30513052if(apply &&write_out_results(list, skipped_patch))3053exit(1);30543055if(fake_ancestor)3056build_fake_ancestor(list, fake_ancestor);30573058if(diffstat)3059stat_patch_list(list);30603061if(numstat)3062numstat_patch_list(list);30633064if(summary)3065summary_patch_list(list);30663067strbuf_release(&buf);3068return0;3069}30703071static intgit_apply_config(const char*var,const char*value)3072{3073if(!strcmp(var,"apply.whitespace")) {3074 apply_default_whitespace =xstrdup(value);3075return0;3076}3077returngit_default_config(var, value);3078}307930803081intcmd_apply(int argc,const char**argv,const char*unused_prefix)3082{3083int i;3084int read_stdin =1;3085int inaccurate_eof =0;3086int errs =0;3087int is_not_gitdir =0;30883089const char*whitespace_option = NULL;30903091 prefix =setup_git_directory_gently(&is_not_gitdir);3092 prefix_length = prefix ?strlen(prefix) :0;3093git_config(git_apply_config);3094if(apply_default_whitespace)3095parse_whitespace_option(apply_default_whitespace);30963097for(i =1; i < argc; i++) {3098const char*arg = argv[i];3099char*end;3100int fd;31013102if(!strcmp(arg,"-")) {3103 errs |=apply_patch(0,"<stdin>", inaccurate_eof);3104 read_stdin =0;3105continue;3106}3107if(!prefixcmp(arg,"--exclude=")) {3108struct excludes *x =xmalloc(sizeof(*x));3109 x->path = arg +10;3110 x->next = excludes;3111 excludes = x;3112continue;3113}3114if(!prefixcmp(arg,"-p")) {3115 p_value =atoi(arg +2);3116 p_value_known =1;3117continue;3118}3119if(!strcmp(arg,"--no-add")) {3120 no_add =1;3121continue;3122}3123if(!strcmp(arg,"--stat")) {3124 apply =0;3125 diffstat =1;3126continue;3127}3128if(!strcmp(arg,"--allow-binary-replacement") ||3129!strcmp(arg,"--binary")) {3130continue;/* now no-op */3131}3132if(!strcmp(arg,"--numstat")) {3133 apply =0;3134 numstat =1;3135continue;3136}3137if(!strcmp(arg,"--summary")) {3138 apply =0;3139 summary =1;3140continue;3141}3142if(!strcmp(arg,"--check")) {3143 apply =0;3144 check =1;3145continue;3146}3147if(!strcmp(arg,"--index")) {3148if(is_not_gitdir)3149die("--index outside a repository");3150 check_index =1;3151continue;3152}3153if(!strcmp(arg,"--cached")) {3154if(is_not_gitdir)3155die("--cached outside a repository");3156 check_index =1;3157 cached =1;3158continue;3159}3160if(!strcmp(arg,"--apply")) {3161 apply =1;3162continue;3163}3164if(!strcmp(arg,"--build-fake-ancestor")) {3165 apply =0;3166if(++i >= argc)3167die("need a filename");3168 fake_ancestor = argv[i];3169continue;3170}3171if(!strcmp(arg,"-z")) {3172 line_termination =0;3173continue;3174}3175if(!prefixcmp(arg,"-C")) {3176 p_context =strtoul(arg +2, &end,0);3177if(*end !='\0')3178die("unrecognized context count '%s'", arg +2);3179continue;3180}3181if(!prefixcmp(arg,"--whitespace=")) {3182 whitespace_option = arg +13;3183parse_whitespace_option(arg +13);3184continue;3185}3186if(!strcmp(arg,"-R") || !strcmp(arg,"--reverse")) {3187 apply_in_reverse =1;3188continue;3189}3190if(!strcmp(arg,"--unidiff-zero")) {3191 unidiff_zero =1;3192continue;3193}3194if(!strcmp(arg,"--reject")) {3195 apply = apply_with_reject = apply_verbosely =1;3196continue;3197}3198if(!strcmp(arg,"-v") || !strcmp(arg,"--verbose")) {3199 apply_verbosely =1;3200continue;3201}3202if(!strcmp(arg,"--inaccurate-eof")) {3203 inaccurate_eof =1;3204continue;3205}3206if(0< prefix_length)3207 arg =prefix_filename(prefix, prefix_length, arg);32083209 fd =open(arg, O_RDONLY);3210if(fd <0)3211usage(apply_usage);3212 read_stdin =0;3213set_default_whitespace_mode(whitespace_option);3214 errs |=apply_patch(fd, arg, inaccurate_eof);3215close(fd);3216}3217set_default_whitespace_mode(whitespace_option);3218if(read_stdin)3219 errs |=apply_patch(0,"<stdin>", inaccurate_eof);3220if(whitespace_error) {3221if(squelch_whitespace_errors &&3222 squelch_whitespace_errors < whitespace_error) {3223int squelched =3224 whitespace_error - squelch_whitespace_errors;3225fprintf(stderr,"warning: squelched%d"3226"whitespace error%s\n",3227 squelched,3228 squelched ==1?"":"s");3229}3230if(ws_error_action == die_on_ws_error)3231die("%dline%sadd%swhitespace errors.",3232 whitespace_error,3233 whitespace_error ==1?"":"s",3234 whitespace_error ==1?"s":"");3235if(applied_after_fixing_ws && apply)3236fprintf(stderr,"warning:%dline%sapplied after"3237" fixing whitespace errors.\n",3238 applied_after_fixing_ws,3239 applied_after_fixing_ws ==1?"":"s");3240else if(whitespace_error)3241fprintf(stderr,"warning:%dline%sadd%swhitespace errors.\n",3242 whitespace_error,3243 whitespace_error ==1?"":"s",3244 whitespace_error ==1?"s":"");3245}32463247if(update_index) {3248if(write_cache(newfd, active_cache, active_nr) ||3249commit_locked_index(&lock_file))3250die("Unable to write new index file");3251}32523253return!!errs;3254}