1/* 2 * apply.c 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 * 6 * This applies patches on top of some (arbitrary) version of the SCM. 7 * 8 */ 9#include"cache.h" 10#include"cache-tree.h" 11#include"quote.h" 12#include"blob.h" 13#include"delta.h" 14#include"builtin.h" 15#include"string-list.h" 16#include"dir.h" 17#include"parse-options.h" 18 19/* 20 * --check turns on checking that the working tree matches the 21 * files that are being modified, but doesn't apply the patch 22 * --stat does just a diffstat, and doesn't actually apply 23 * --numstat does numeric diffstat, and doesn't actually apply 24 * --index-info shows the old and new index info for paths if available. 25 * --index updates the cache as well. 26 * --cached updates only the cache without ever touching the working tree. 27 */ 28static const char*prefix; 29static int prefix_length = -1; 30static int newfd = -1; 31 32static int unidiff_zero; 33static int p_value =1; 34static int p_value_known; 35static int check_index; 36static int update_index; 37static int cached; 38static int diffstat; 39static int numstat; 40static int summary; 41static int check; 42static int apply =1; 43static int apply_in_reverse; 44static int apply_with_reject; 45static int apply_verbosely; 46static int allow_overlap; 47static int no_add; 48static const char*fake_ancestor; 49static int line_termination ='\n'; 50static unsigned int p_context = UINT_MAX; 51static const char*const apply_usage[] = { 52"git apply [options] [<patch>...]", 53 NULL 54}; 55 56static enum ws_error_action { 57 nowarn_ws_error, 58 warn_on_ws_error, 59 die_on_ws_error, 60 correct_ws_error 61} ws_error_action = warn_on_ws_error; 62static int whitespace_error; 63static int squelch_whitespace_errors =5; 64static int applied_after_fixing_ws; 65 66static enum ws_ignore { 67 ignore_ws_none, 68 ignore_ws_change 69} ws_ignore_action = ignore_ws_none; 70 71 72static const char*patch_input_file; 73static const char*root; 74static int root_len; 75static int read_stdin =1; 76static int options; 77 78static voidparse_whitespace_option(const char*option) 79{ 80if(!option) { 81 ws_error_action = warn_on_ws_error; 82return; 83} 84if(!strcmp(option,"warn")) { 85 ws_error_action = warn_on_ws_error; 86return; 87} 88if(!strcmp(option,"nowarn")) { 89 ws_error_action = nowarn_ws_error; 90return; 91} 92if(!strcmp(option,"error")) { 93 ws_error_action = die_on_ws_error; 94return; 95} 96if(!strcmp(option,"error-all")) { 97 ws_error_action = die_on_ws_error; 98 squelch_whitespace_errors =0; 99return; 100} 101if(!strcmp(option,"strip") || !strcmp(option,"fix")) { 102 ws_error_action = correct_ws_error; 103return; 104} 105die("unrecognized whitespace option '%s'", option); 106} 107 108static voidparse_ignorewhitespace_option(const char*option) 109{ 110if(!option || !strcmp(option,"no") || 111!strcmp(option,"false") || !strcmp(option,"never") || 112!strcmp(option,"none")) { 113 ws_ignore_action = ignore_ws_none; 114return; 115} 116if(!strcmp(option,"change")) { 117 ws_ignore_action = ignore_ws_change; 118return; 119} 120die("unrecognized whitespace ignore option '%s'", option); 121} 122 123static voidset_default_whitespace_mode(const char*whitespace_option) 124{ 125if(!whitespace_option && !apply_default_whitespace) 126 ws_error_action = (apply ? warn_on_ws_error : nowarn_ws_error); 127} 128 129/* 130 * For "diff-stat" like behaviour, we keep track of the biggest change 131 * we've seen, and the longest filename. That allows us to do simple 132 * scaling. 133 */ 134static int max_change, max_len; 135 136/* 137 * Various "current state", notably line numbers and what 138 * file (and how) we're patching right now.. The "is_xxxx" 139 * things are flags, where -1 means "don't know yet". 140 */ 141static int linenr =1; 142 143/* 144 * This represents one "hunk" from a patch, starting with 145 * "@@ -oldpos,oldlines +newpos,newlines @@" marker. The 146 * patch text is pointed at by patch, and its byte length 147 * is stored in size. leading and trailing are the number 148 * of context lines. 149 */ 150struct fragment { 151unsigned long leading, trailing; 152unsigned long oldpos, oldlines; 153unsigned long newpos, newlines; 154const char*patch; 155int size; 156int rejected; 157int linenr; 158struct fragment *next; 159}; 160 161/* 162 * When dealing with a binary patch, we reuse "leading" field 163 * to store the type of the binary hunk, either deflated "delta" 164 * or deflated "literal". 165 */ 166#define binary_patch_method leading 167#define BINARY_DELTA_DEFLATED 1 168#define BINARY_LITERAL_DEFLATED 2 169 170/* 171 * This represents a "patch" to a file, both metainfo changes 172 * such as creation/deletion, filemode and content changes represented 173 * as a series of fragments. 174 */ 175struct patch { 176char*new_name, *old_name, *def_name; 177unsigned int old_mode, new_mode; 178int is_new, is_delete;/* -1 = unknown, 0 = false, 1 = true */ 179int rejected; 180unsigned ws_rule; 181unsigned long deflate_origlen; 182int lines_added, lines_deleted; 183int score; 184unsigned int is_toplevel_relative:1; 185unsigned int inaccurate_eof:1; 186unsigned int is_binary:1; 187unsigned int is_copy:1; 188unsigned int is_rename:1; 189unsigned int recount:1; 190struct fragment *fragments; 191char*result; 192size_t resultsize; 193char old_sha1_prefix[41]; 194char new_sha1_prefix[41]; 195struct patch *next; 196}; 197 198/* 199 * A line in a file, len-bytes long (includes the terminating LF, 200 * except for an incomplete line at the end if the file ends with 201 * one), and its contents hashes to 'hash'. 202 */ 203struct line { 204size_t len; 205unsigned hash :24; 206unsigned flag :8; 207#define LINE_COMMON 1 208#define LINE_PATCHED 2 209}; 210 211/* 212 * This represents a "file", which is an array of "lines". 213 */ 214struct image { 215char*buf; 216size_t len; 217size_t nr; 218size_t alloc; 219struct line *line_allocated; 220struct line *line; 221}; 222 223/* 224 * Records filenames that have been touched, in order to handle 225 * the case where more than one patches touch the same file. 226 */ 227 228static struct string_list fn_table; 229 230static uint32_thash_line(const char*cp,size_t len) 231{ 232size_t i; 233uint32_t h; 234for(i =0, h =0; i < len; i++) { 235if(!isspace(cp[i])) { 236 h = h *3+ (cp[i] &0xff); 237} 238} 239return h; 240} 241 242/* 243 * Compare lines s1 of length n1 and s2 of length n2, ignoring 244 * whitespace difference. Returns 1 if they match, 0 otherwise 245 */ 246static intfuzzy_matchlines(const char*s1,size_t n1, 247const char*s2,size_t n2) 248{ 249const char*last1 = s1 + n1 -1; 250const char*last2 = s2 + n2 -1; 251int result =0; 252 253if(n1 <0|| n2 <0) 254return0; 255 256/* ignore line endings */ 257while((*last1 =='\r') || (*last1 =='\n')) 258 last1--; 259while((*last2 =='\r') || (*last2 =='\n')) 260 last2--; 261 262/* skip leading whitespace */ 263while(isspace(*s1) && (s1 <= last1)) 264 s1++; 265while(isspace(*s2) && (s2 <= last2)) 266 s2++; 267/* early return if both lines are empty */ 268if((s1 > last1) && (s2 > last2)) 269return1; 270while(!result) { 271 result = *s1++ - *s2++; 272/* 273 * Skip whitespace inside. We check for whitespace on 274 * both buffers because we don't want "a b" to match 275 * "ab" 276 */ 277if(isspace(*s1) &&isspace(*s2)) { 278while(isspace(*s1) && s1 <= last1) 279 s1++; 280while(isspace(*s2) && s2 <= last2) 281 s2++; 282} 283/* 284 * If we reached the end on one side only, 285 * lines don't match 286 */ 287if( 288((s2 > last2) && (s1 <= last1)) || 289((s1 > last1) && (s2 <= last2))) 290return0; 291if((s1 > last1) && (s2 > last2)) 292break; 293} 294 295return!result; 296} 297 298static voidadd_line_info(struct image *img,const char*bol,size_t len,unsigned flag) 299{ 300ALLOC_GROW(img->line_allocated, img->nr +1, img->alloc); 301 img->line_allocated[img->nr].len = len; 302 img->line_allocated[img->nr].hash =hash_line(bol, len); 303 img->line_allocated[img->nr].flag = flag; 304 img->nr++; 305} 306 307static voidprepare_image(struct image *image,char*buf,size_t len, 308int prepare_linetable) 309{ 310const char*cp, *ep; 311 312memset(image,0,sizeof(*image)); 313 image->buf = buf; 314 image->len = len; 315 316if(!prepare_linetable) 317return; 318 319 ep = image->buf + image->len; 320 cp = image->buf; 321while(cp < ep) { 322const char*next; 323for(next = cp; next < ep && *next !='\n'; next++) 324; 325if(next < ep) 326 next++; 327add_line_info(image, cp, next - cp,0); 328 cp = next; 329} 330 image->line = image->line_allocated; 331} 332 333static voidclear_image(struct image *image) 334{ 335free(image->buf); 336 image->buf = NULL; 337 image->len =0; 338} 339 340static voidsay_patch_name(FILE*output,const char*pre, 341struct patch *patch,const char*post) 342{ 343fputs(pre, output); 344if(patch->old_name && patch->new_name && 345strcmp(patch->old_name, patch->new_name)) { 346quote_c_style(patch->old_name, NULL, output,0); 347fputs(" => ", output); 348quote_c_style(patch->new_name, NULL, output,0); 349}else{ 350const char*n = patch->new_name; 351if(!n) 352 n = patch->old_name; 353quote_c_style(n, NULL, output,0); 354} 355fputs(post, output); 356} 357 358#define CHUNKSIZE (8192) 359#define SLOP (16) 360 361static voidread_patch_file(struct strbuf *sb,int fd) 362{ 363if(strbuf_read(sb, fd,0) <0) 364die_errno("git apply: failed to read"); 365 366/* 367 * Make sure that we have some slop in the buffer 368 * so that we can do speculative "memcmp" etc, and 369 * see to it that it is NUL-filled. 370 */ 371strbuf_grow(sb, SLOP); 372memset(sb->buf + sb->len,0, SLOP); 373} 374 375static unsigned longlinelen(const char*buffer,unsigned long size) 376{ 377unsigned long len =0; 378while(size--) { 379 len++; 380if(*buffer++ =='\n') 381break; 382} 383return len; 384} 385 386static intis_dev_null(const char*str) 387{ 388return!memcmp("/dev/null", str,9) &&isspace(str[9]); 389} 390 391#define TERM_SPACE 1 392#define TERM_TAB 2 393 394static intname_terminate(const char*name,int namelen,int c,int terminate) 395{ 396if(c ==' '&& !(terminate & TERM_SPACE)) 397return0; 398if(c =='\t'&& !(terminate & TERM_TAB)) 399return0; 400 401return1; 402} 403 404/* remove double slashes to make --index work with such filenames */ 405static char*squash_slash(char*name) 406{ 407int i =0, j =0; 408 409if(!name) 410return NULL; 411 412while(name[i]) { 413if((name[j++] = name[i++]) =='/') 414while(name[i] =='/') 415 i++; 416} 417 name[j] ='\0'; 418return name; 419} 420 421static char*find_name_gnu(const char*line,char*def,int p_value) 422{ 423struct strbuf name = STRBUF_INIT; 424char*cp; 425 426/* 427 * Proposed "new-style" GNU patch/diff format; see 428 * http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2 429 */ 430if(unquote_c_style(&name, line, NULL)) { 431strbuf_release(&name); 432return NULL; 433} 434 435for(cp = name.buf; p_value; p_value--) { 436 cp =strchr(cp,'/'); 437if(!cp) { 438strbuf_release(&name); 439return NULL; 440} 441 cp++; 442} 443 444/* name can later be freed, so we need 445 * to memmove, not just return cp 446 */ 447strbuf_remove(&name,0, cp - name.buf); 448free(def); 449if(root) 450strbuf_insert(&name,0, root, root_len); 451returnsquash_slash(strbuf_detach(&name, NULL)); 452} 453 454static size_tsane_tz_len(const char*line,size_t len) 455{ 456const char*tz, *p; 457 458if(len <strlen(" +0500") || line[len-strlen(" +0500")] !=' ') 459return0; 460 tz = line + len -strlen(" +0500"); 461 462if(tz[1] !='+'&& tz[1] !='-') 463return0; 464 465for(p = tz +2; p != line + len; p++) 466if(!isdigit(*p)) 467return0; 468 469return line + len - tz; 470} 471 472static size_ttz_with_colon_len(const char*line,size_t len) 473{ 474const char*tz, *p; 475 476if(len <strlen(" +08:00") || line[len -strlen(":00")] !=':') 477return0; 478 tz = line + len -strlen(" +08:00"); 479 480if(tz[0] !=' '|| (tz[1] !='+'&& tz[1] !='-')) 481return0; 482 p = tz +2; 483if(!isdigit(*p++) || !isdigit(*p++) || *p++ !=':'|| 484!isdigit(*p++) || !isdigit(*p++)) 485return0; 486 487return line + len - tz; 488} 489 490static size_tdate_len(const char*line,size_t len) 491{ 492const char*date, *p; 493 494if(len <strlen("72-02-05") || line[len-strlen("-05")] !='-') 495return0; 496 p = date = line + len -strlen("72-02-05"); 497 498if(!isdigit(*p++) || !isdigit(*p++) || *p++ !='-'|| 499!isdigit(*p++) || !isdigit(*p++) || *p++ !='-'|| 500!isdigit(*p++) || !isdigit(*p++))/* Not a date. */ 501return0; 502 503if(date - line >=strlen("19") && 504isdigit(date[-1]) &&isdigit(date[-2]))/* 4-digit year */ 505 date -=strlen("19"); 506 507return line + len - date; 508} 509 510static size_tshort_time_len(const char*line,size_t len) 511{ 512const char*time, *p; 513 514if(len <strlen(" 07:01:32") || line[len-strlen(":32")] !=':') 515return0; 516 p = time = line + len -strlen(" 07:01:32"); 517 518/* Permit 1-digit hours? */ 519if(*p++ !=' '|| 520!isdigit(*p++) || !isdigit(*p++) || *p++ !=':'|| 521!isdigit(*p++) || !isdigit(*p++) || *p++ !=':'|| 522!isdigit(*p++) || !isdigit(*p++))/* Not a time. */ 523return0; 524 525return line + len - time; 526} 527 528static size_tfractional_time_len(const char*line,size_t len) 529{ 530const char*p; 531size_t n; 532 533/* Expected format: 19:41:17.620000023 */ 534if(!len || !isdigit(line[len -1])) 535return0; 536 p = line + len -1; 537 538/* Fractional seconds. */ 539while(p > line &&isdigit(*p)) 540 p--; 541if(*p !='.') 542return0; 543 544/* Hours, minutes, and whole seconds. */ 545 n =short_time_len(line, p - line); 546if(!n) 547return0; 548 549return line + len - p + n; 550} 551 552static size_ttrailing_spaces_len(const char*line,size_t len) 553{ 554const char*p; 555 556/* Expected format: ' ' x (1 or more) */ 557if(!len || line[len -1] !=' ') 558return0; 559 560 p = line + len; 561while(p != line) { 562 p--; 563if(*p !=' ') 564return line + len - (p +1); 565} 566 567/* All spaces! */ 568return len; 569} 570 571static size_tdiff_timestamp_len(const char*line,size_t len) 572{ 573const char*end = line + len; 574size_t n; 575 576/* 577 * Posix: 2010-07-05 19:41:17 578 * GNU: 2010-07-05 19:41:17.620000023 -0500 579 */ 580 581if(!isdigit(end[-1])) 582return0; 583 584 n =sane_tz_len(line, end - line); 585if(!n) 586 n =tz_with_colon_len(line, end - line); 587 end -= n; 588 589 n =short_time_len(line, end - line); 590if(!n) 591 n =fractional_time_len(line, end - line); 592 end -= n; 593 594 n =date_len(line, end - line); 595if(!n)/* No date. Too bad. */ 596return0; 597 end -= n; 598 599if(end == line)/* No space before date. */ 600return0; 601if(end[-1] =='\t') {/* Success! */ 602 end--; 603return line + len - end; 604} 605if(end[-1] !=' ')/* No space before date. */ 606return0; 607 608/* Whitespace damage. */ 609 end -=trailing_spaces_len(line, end - line); 610return line + len - end; 611} 612 613static char*find_name_common(const char*line,char*def,int p_value, 614const char*end,int terminate) 615{ 616int len; 617const char*start = NULL; 618 619if(p_value ==0) 620 start = line; 621while(line != end) { 622char c = *line; 623 624if(!end &&isspace(c)) { 625if(c =='\n') 626break; 627if(name_terminate(start, line-start, c, terminate)) 628break; 629} 630 line++; 631if(c =='/'&& !--p_value) 632 start = line; 633} 634if(!start) 635returnsquash_slash(def); 636 len = line - start; 637if(!len) 638returnsquash_slash(def); 639 640/* 641 * Generally we prefer the shorter name, especially 642 * if the other one is just a variation of that with 643 * something else tacked on to the end (ie "file.orig" 644 * or "file~"). 645 */ 646if(def) { 647int deflen =strlen(def); 648if(deflen < len && !strncmp(start, def, deflen)) 649returnsquash_slash(def); 650free(def); 651} 652 653if(root) { 654char*ret =xmalloc(root_len + len +1); 655strcpy(ret, root); 656memcpy(ret + root_len, start, len); 657 ret[root_len + len] ='\0'; 658returnsquash_slash(ret); 659} 660 661returnsquash_slash(xmemdupz(start, len)); 662} 663 664static char*find_name(const char*line,char*def,int p_value,int terminate) 665{ 666if(*line =='"') { 667char*name =find_name_gnu(line, def, p_value); 668if(name) 669return name; 670} 671 672returnfind_name_common(line, def, p_value, NULL, terminate); 673} 674 675static char*find_name_traditional(const char*line,char*def,int p_value) 676{ 677size_t len =strlen(line); 678size_t date_len; 679 680if(*line =='"') { 681char*name =find_name_gnu(line, def, p_value); 682if(name) 683return name; 684} 685 686 len =strchrnul(line,'\n') - line; 687 date_len =diff_timestamp_len(line, len); 688if(!date_len) 689returnfind_name_common(line, def, p_value, NULL, TERM_TAB); 690 len -= date_len; 691 692returnfind_name_common(line, def, p_value, line + len,0); 693} 694 695static intcount_slashes(const char*cp) 696{ 697int cnt =0; 698char ch; 699 700while((ch = *cp++)) 701if(ch =='/') 702 cnt++; 703return cnt; 704} 705 706/* 707 * Given the string after "--- " or "+++ ", guess the appropriate 708 * p_value for the given patch. 709 */ 710static intguess_p_value(const char*nameline) 711{ 712char*name, *cp; 713int val = -1; 714 715if(is_dev_null(nameline)) 716return-1; 717 name =find_name_traditional(nameline, NULL,0); 718if(!name) 719return-1; 720 cp =strchr(name,'/'); 721if(!cp) 722 val =0; 723else if(prefix) { 724/* 725 * Does it begin with "a/$our-prefix" and such? Then this is 726 * very likely to apply to our directory. 727 */ 728if(!strncmp(name, prefix, prefix_length)) 729 val =count_slashes(prefix); 730else{ 731 cp++; 732if(!strncmp(cp, prefix, prefix_length)) 733 val =count_slashes(prefix) +1; 734} 735} 736free(name); 737return val; 738} 739 740/* 741 * Does the ---/+++ line has the POSIX timestamp after the last HT? 742 * GNU diff puts epoch there to signal a creation/deletion event. Is 743 * this such a timestamp? 744 */ 745static inthas_epoch_timestamp(const char*nameline) 746{ 747/* 748 * We are only interested in epoch timestamp; any non-zero 749 * fraction cannot be one, hence "(\.0+)?" in the regexp below. 750 * For the same reason, the date must be either 1969-12-31 or 751 * 1970-01-01, and the seconds part must be "00". 752 */ 753const char stamp_regexp[] = 754"^(1969-12-31|1970-01-01)" 755" " 756"[0-2][0-9]:[0-5][0-9]:00(\\.0+)?" 757" " 758"([-+][0-2][0-9]:?[0-5][0-9])\n"; 759const char*timestamp = NULL, *cp, *colon; 760static regex_t *stamp; 761 regmatch_t m[10]; 762int zoneoffset; 763int hourminute; 764int status; 765 766for(cp = nameline; *cp !='\n'; cp++) { 767if(*cp =='\t') 768 timestamp = cp +1; 769} 770if(!timestamp) 771return0; 772if(!stamp) { 773 stamp =xmalloc(sizeof(*stamp)); 774if(regcomp(stamp, stamp_regexp, REG_EXTENDED)) { 775warning("Cannot prepare timestamp regexp%s", 776 stamp_regexp); 777return0; 778} 779} 780 781 status =regexec(stamp, timestamp,ARRAY_SIZE(m), m,0); 782if(status) { 783if(status != REG_NOMATCH) 784warning("regexec returned%dfor input:%s", 785 status, timestamp); 786return0; 787} 788 789 zoneoffset =strtol(timestamp + m[3].rm_so +1, (char**) &colon,10); 790if(*colon ==':') 791 zoneoffset = zoneoffset *60+strtol(colon +1, NULL,10); 792else 793 zoneoffset = (zoneoffset /100) *60+ (zoneoffset %100); 794if(timestamp[m[3].rm_so] =='-') 795 zoneoffset = -zoneoffset; 796 797/* 798 * YYYY-MM-DD hh:mm:ss must be from either 1969-12-31 799 * (west of GMT) or 1970-01-01 (east of GMT) 800 */ 801if((zoneoffset <0&&memcmp(timestamp,"1969-12-31",10)) || 802(0<= zoneoffset &&memcmp(timestamp,"1970-01-01",10))) 803return0; 804 805 hourminute = (strtol(timestamp +11, NULL,10) *60+ 806strtol(timestamp +14, NULL,10) - 807 zoneoffset); 808 809return((zoneoffset <0&& hourminute ==1440) || 810(0<= zoneoffset && !hourminute)); 811} 812 813/* 814 * Get the name etc info from the ---/+++ lines of a traditional patch header 815 * 816 * FIXME! The end-of-filename heuristics are kind of screwy. For existing 817 * files, we can happily check the index for a match, but for creating a 818 * new file we should try to match whatever "patch" does. I have no idea. 819 */ 820static voidparse_traditional_patch(const char*first,const char*second,struct patch *patch) 821{ 822char*name; 823 824 first +=4;/* skip "--- " */ 825 second +=4;/* skip "+++ " */ 826if(!p_value_known) { 827int p, q; 828 p =guess_p_value(first); 829 q =guess_p_value(second); 830if(p <0) p = q; 831if(0<= p && p == q) { 832 p_value = p; 833 p_value_known =1; 834} 835} 836if(is_dev_null(first)) { 837 patch->is_new =1; 838 patch->is_delete =0; 839 name =find_name_traditional(second, NULL, p_value); 840 patch->new_name = name; 841}else if(is_dev_null(second)) { 842 patch->is_new =0; 843 patch->is_delete =1; 844 name =find_name_traditional(first, NULL, p_value); 845 patch->old_name = name; 846}else{ 847 name =find_name_traditional(first, NULL, p_value); 848 name =find_name_traditional(second, name, p_value); 849if(has_epoch_timestamp(first)) { 850 patch->is_new =1; 851 patch->is_delete =0; 852 patch->new_name = name; 853}else if(has_epoch_timestamp(second)) { 854 patch->is_new =0; 855 patch->is_delete =1; 856 patch->old_name = name; 857}else{ 858 patch->old_name = patch->new_name = name; 859} 860} 861if(!name) 862die("unable to find filename in patch at line%d", linenr); 863} 864 865static intgitdiff_hdrend(const char*line,struct patch *patch) 866{ 867return-1; 868} 869 870/* 871 * We're anal about diff header consistency, to make 872 * sure that we don't end up having strange ambiguous 873 * patches floating around. 874 * 875 * As a result, gitdiff_{old|new}name() will check 876 * their names against any previous information, just 877 * to make sure.. 878 */ 879static char*gitdiff_verify_name(const char*line,int isnull,char*orig_name,const char*oldnew) 880{ 881if(!orig_name && !isnull) 882returnfind_name(line, NULL, p_value, TERM_TAB); 883 884if(orig_name) { 885int len; 886const char*name; 887char*another; 888 name = orig_name; 889 len =strlen(name); 890if(isnull) 891die("git apply: bad git-diff - expected /dev/null, got%son line%d", name, linenr); 892 another =find_name(line, NULL, p_value, TERM_TAB); 893if(!another ||memcmp(another, name, len +1)) 894die("git apply: bad git-diff - inconsistent%sfilename on line%d", oldnew, linenr); 895free(another); 896return orig_name; 897} 898else{ 899/* expect "/dev/null" */ 900if(memcmp("/dev/null", line,9) || line[9] !='\n') 901die("git apply: bad git-diff - expected /dev/null on line%d", linenr); 902return NULL; 903} 904} 905 906static intgitdiff_oldname(const char*line,struct patch *patch) 907{ 908 patch->old_name =gitdiff_verify_name(line, patch->is_new, patch->old_name,"old"); 909return0; 910} 911 912static intgitdiff_newname(const char*line,struct patch *patch) 913{ 914 patch->new_name =gitdiff_verify_name(line, patch->is_delete, patch->new_name,"new"); 915return0; 916} 917 918static intgitdiff_oldmode(const char*line,struct patch *patch) 919{ 920 patch->old_mode =strtoul(line, NULL,8); 921return0; 922} 923 924static intgitdiff_newmode(const char*line,struct patch *patch) 925{ 926 patch->new_mode =strtoul(line, NULL,8); 927return0; 928} 929 930static intgitdiff_delete(const char*line,struct patch *patch) 931{ 932 patch->is_delete =1; 933 patch->old_name = patch->def_name; 934returngitdiff_oldmode(line, patch); 935} 936 937static intgitdiff_newfile(const char*line,struct patch *patch) 938{ 939 patch->is_new =1; 940 patch->new_name = patch->def_name; 941returngitdiff_newmode(line, patch); 942} 943 944static intgitdiff_copysrc(const char*line,struct patch *patch) 945{ 946 patch->is_copy =1; 947 patch->old_name =find_name(line, NULL, p_value ? p_value -1:0,0); 948return0; 949} 950 951static intgitdiff_copydst(const char*line,struct patch *patch) 952{ 953 patch->is_copy =1; 954 patch->new_name =find_name(line, NULL, p_value ? p_value -1:0,0); 955return0; 956} 957 958static intgitdiff_renamesrc(const char*line,struct patch *patch) 959{ 960 patch->is_rename =1; 961 patch->old_name =find_name(line, NULL, p_value ? p_value -1:0,0); 962return0; 963} 964 965static intgitdiff_renamedst(const char*line,struct patch *patch) 966{ 967 patch->is_rename =1; 968 patch->new_name =find_name(line, NULL, p_value ? p_value -1:0,0); 969return0; 970} 971 972static intgitdiff_similarity(const char*line,struct patch *patch) 973{ 974if((patch->score =strtoul(line, NULL,10)) == ULONG_MAX) 975 patch->score =0; 976return0; 977} 978 979static intgitdiff_dissimilarity(const char*line,struct patch *patch) 980{ 981if((patch->score =strtoul(line, NULL,10)) == ULONG_MAX) 982 patch->score =0; 983return0; 984} 985 986static intgitdiff_index(const char*line,struct patch *patch) 987{ 988/* 989 * index line is N hexadecimal, "..", N hexadecimal, 990 * and optional space with octal mode. 991 */ 992const char*ptr, *eol; 993int len; 994 995 ptr =strchr(line,'.'); 996if(!ptr || ptr[1] !='.'||40< ptr - line) 997return0; 998 len = ptr - line; 999memcpy(patch->old_sha1_prefix, line, len);1000 patch->old_sha1_prefix[len] =0;10011002 line = ptr +2;1003 ptr =strchr(line,' ');1004 eol =strchr(line,'\n');10051006if(!ptr || eol < ptr)1007 ptr = eol;1008 len = ptr - line;10091010if(40< len)1011return0;1012memcpy(patch->new_sha1_prefix, line, len);1013 patch->new_sha1_prefix[len] =0;1014if(*ptr ==' ')1015 patch->old_mode =strtoul(ptr+1, NULL,8);1016return0;1017}10181019/*1020 * This is normal for a diff that doesn't change anything: we'll fall through1021 * into the next diff. Tell the parser to break out.1022 */1023static intgitdiff_unrecognized(const char*line,struct patch *patch)1024{1025return-1;1026}10271028static const char*stop_at_slash(const char*line,int llen)1029{1030int nslash = p_value;1031int i;10321033for(i =0; i < llen; i++) {1034int ch = line[i];1035if(ch =='/'&& --nslash <=0)1036return&line[i];1037}1038return NULL;1039}10401041/*1042 * This is to extract the same name that appears on "diff --git"1043 * line. We do not find and return anything if it is a rename1044 * patch, and it is OK because we will find the name elsewhere.1045 * We need to reliably find name only when it is mode-change only,1046 * creation or deletion of an empty file. In any of these cases,1047 * both sides are the same name under a/ and b/ respectively.1048 */1049static char*git_header_name(char*line,int llen)1050{1051const char*name;1052const char*second = NULL;1053size_t len, line_len;10541055 line +=strlen("diff --git ");1056 llen -=strlen("diff --git ");10571058if(*line =='"') {1059const char*cp;1060struct strbuf first = STRBUF_INIT;1061struct strbuf sp = STRBUF_INIT;10621063if(unquote_c_style(&first, line, &second))1064goto free_and_fail1;10651066/* advance to the first slash */1067 cp =stop_at_slash(first.buf, first.len);1068/* we do not accept absolute paths */1069if(!cp || cp == first.buf)1070goto free_and_fail1;1071strbuf_remove(&first,0, cp +1- first.buf);10721073/*1074 * second points at one past closing dq of name.1075 * find the second name.1076 */1077while((second < line + llen) &&isspace(*second))1078 second++;10791080if(line + llen <= second)1081goto free_and_fail1;1082if(*second =='"') {1083if(unquote_c_style(&sp, second, NULL))1084goto free_and_fail1;1085 cp =stop_at_slash(sp.buf, sp.len);1086if(!cp || cp == sp.buf)1087goto free_and_fail1;1088/* They must match, otherwise ignore */1089if(strcmp(cp +1, first.buf))1090goto free_and_fail1;1091strbuf_release(&sp);1092returnstrbuf_detach(&first, NULL);1093}10941095/* unquoted second */1096 cp =stop_at_slash(second, line + llen - second);1097if(!cp || cp == second)1098goto free_and_fail1;1099 cp++;1100if(line + llen - cp != first.len +1||1101memcmp(first.buf, cp, first.len))1102goto free_and_fail1;1103returnstrbuf_detach(&first, NULL);11041105 free_and_fail1:1106strbuf_release(&first);1107strbuf_release(&sp);1108return NULL;1109}11101111/* unquoted first name */1112 name =stop_at_slash(line, llen);1113if(!name || name == line)1114return NULL;1115 name++;11161117/*1118 * since the first name is unquoted, a dq if exists must be1119 * the beginning of the second name.1120 */1121for(second = name; second < line + llen; second++) {1122if(*second =='"') {1123struct strbuf sp = STRBUF_INIT;1124const char*np;11251126if(unquote_c_style(&sp, second, NULL))1127goto free_and_fail2;11281129 np =stop_at_slash(sp.buf, sp.len);1130if(!np || np == sp.buf)1131goto free_and_fail2;1132 np++;11331134 len = sp.buf + sp.len - np;1135if(len < second - name &&1136!strncmp(np, name, len) &&1137isspace(name[len])) {1138/* Good */1139strbuf_remove(&sp,0, np - sp.buf);1140returnstrbuf_detach(&sp, NULL);1141}11421143 free_and_fail2:1144strbuf_release(&sp);1145return NULL;1146}1147}11481149/*1150 * Accept a name only if it shows up twice, exactly the same1151 * form.1152 */1153 second =strchr(name,'\n');1154if(!second)1155return NULL;1156 line_len = second - name;1157for(len =0; ; len++) {1158switch(name[len]) {1159default:1160continue;1161case'\n':1162return NULL;1163case'\t':case' ':1164 second =stop_at_slash(name + len, line_len - len);1165if(!second)1166return NULL;1167 second++;1168if(second[len] =='\n'&& !strncmp(name, second, len)) {1169returnxmemdupz(name, len);1170}1171}1172}1173}11741175/* Verify that we recognize the lines following a git header */1176static intparse_git_header(char*line,int len,unsigned int size,struct patch *patch)1177{1178unsigned long offset;11791180/* A git diff has explicit new/delete information, so we don't guess */1181 patch->is_new =0;1182 patch->is_delete =0;11831184/*1185 * Some things may not have the old name in the1186 * rest of the headers anywhere (pure mode changes,1187 * or removing or adding empty files), so we get1188 * the default name from the header.1189 */1190 patch->def_name =git_header_name(line, len);1191if(patch->def_name && root) {1192char*s =xmalloc(root_len +strlen(patch->def_name) +1);1193strcpy(s, root);1194strcpy(s + root_len, patch->def_name);1195free(patch->def_name);1196 patch->def_name = s;1197}11981199 line += len;1200 size -= len;1201 linenr++;1202for(offset = len ; size >0; offset += len, size -= len, line += len, linenr++) {1203static const struct opentry {1204const char*str;1205int(*fn)(const char*,struct patch *);1206} optable[] = {1207{"@@ -", gitdiff_hdrend },1208{"--- ", gitdiff_oldname },1209{"+++ ", gitdiff_newname },1210{"old mode ", gitdiff_oldmode },1211{"new mode ", gitdiff_newmode },1212{"deleted file mode ", gitdiff_delete },1213{"new file mode ", gitdiff_newfile },1214{"copy from ", gitdiff_copysrc },1215{"copy to ", gitdiff_copydst },1216{"rename old ", gitdiff_renamesrc },1217{"rename new ", gitdiff_renamedst },1218{"rename from ", gitdiff_renamesrc },1219{"rename to ", gitdiff_renamedst },1220{"similarity index ", gitdiff_similarity },1221{"dissimilarity index ", gitdiff_dissimilarity },1222{"index ", gitdiff_index },1223{"", gitdiff_unrecognized },1224};1225int i;12261227 len =linelen(line, size);1228if(!len || line[len-1] !='\n')1229break;1230for(i =0; i <ARRAY_SIZE(optable); i++) {1231const struct opentry *p = optable + i;1232int oplen =strlen(p->str);1233if(len < oplen ||memcmp(p->str, line, oplen))1234continue;1235if(p->fn(line + oplen, patch) <0)1236return offset;1237break;1238}1239}12401241return offset;1242}12431244static intparse_num(const char*line,unsigned long*p)1245{1246char*ptr;12471248if(!isdigit(*line))1249return0;1250*p =strtoul(line, &ptr,10);1251return ptr - line;1252}12531254static intparse_range(const char*line,int len,int offset,const char*expect,1255unsigned long*p1,unsigned long*p2)1256{1257int digits, ex;12581259if(offset <0|| offset >= len)1260return-1;1261 line += offset;1262 len -= offset;12631264 digits =parse_num(line, p1);1265if(!digits)1266return-1;12671268 offset += digits;1269 line += digits;1270 len -= digits;12711272*p2 =1;1273if(*line ==',') {1274 digits =parse_num(line+1, p2);1275if(!digits)1276return-1;12771278 offset += digits+1;1279 line += digits+1;1280 len -= digits+1;1281}12821283 ex =strlen(expect);1284if(ex > len)1285return-1;1286if(memcmp(line, expect, ex))1287return-1;12881289return offset + ex;1290}12911292static voidrecount_diff(char*line,int size,struct fragment *fragment)1293{1294int oldlines =0, newlines =0, ret =0;12951296if(size <1) {1297warning("recount: ignore empty hunk");1298return;1299}13001301for(;;) {1302int len =linelen(line, size);1303 size -= len;1304 line += len;13051306if(size <1)1307break;13081309switch(*line) {1310case' ':case'\n':1311 newlines++;1312/* fall through */1313case'-':1314 oldlines++;1315continue;1316case'+':1317 newlines++;1318continue;1319case'\\':1320continue;1321case'@':1322 ret = size <3||prefixcmp(line,"@@ ");1323break;1324case'd':1325 ret = size <5||prefixcmp(line,"diff ");1326break;1327default:1328 ret = -1;1329break;1330}1331if(ret) {1332warning("recount: unexpected line: %.*s",1333(int)linelen(line, size), line);1334return;1335}1336break;1337}1338 fragment->oldlines = oldlines;1339 fragment->newlines = newlines;1340}13411342/*1343 * Parse a unified diff fragment header of the1344 * form "@@ -a,b +c,d @@"1345 */1346static intparse_fragment_header(char*line,int len,struct fragment *fragment)1347{1348int offset;13491350if(!len || line[len-1] !='\n')1351return-1;13521353/* Figure out the number of lines in a fragment */1354 offset =parse_range(line, len,4," +", &fragment->oldpos, &fragment->oldlines);1355 offset =parse_range(line, len, offset," @@", &fragment->newpos, &fragment->newlines);13561357return offset;1358}13591360static intfind_header(char*line,unsigned long size,int*hdrsize,struct patch *patch)1361{1362unsigned long offset, len;13631364 patch->is_toplevel_relative =0;1365 patch->is_rename = patch->is_copy =0;1366 patch->is_new = patch->is_delete = -1;1367 patch->old_mode = patch->new_mode =0;1368 patch->old_name = patch->new_name = NULL;1369for(offset =0; size >0; offset += len, size -= len, line += len, linenr++) {1370unsigned long nextlen;13711372 len =linelen(line, size);1373if(!len)1374break;13751376/* Testing this early allows us to take a few shortcuts.. */1377if(len <6)1378continue;13791380/*1381 * Make sure we don't find any unconnected patch fragments.1382 * That's a sign that we didn't find a header, and that a1383 * patch has become corrupted/broken up.1384 */1385if(!memcmp("@@ -", line,4)) {1386struct fragment dummy;1387if(parse_fragment_header(line, len, &dummy) <0)1388continue;1389die("patch fragment without header at line%d: %.*s",1390 linenr, (int)len-1, line);1391}13921393if(size < len +6)1394break;13951396/*1397 * Git patch? It might not have a real patch, just a rename1398 * or mode change, so we handle that specially1399 */1400if(!memcmp("diff --git ", line,11)) {1401int git_hdr_len =parse_git_header(line, len, size, patch);1402if(git_hdr_len <= len)1403continue;1404if(!patch->old_name && !patch->new_name) {1405if(!patch->def_name)1406die("git diff header lacks filename information when removing "1407"%dleading pathname components (line%d)", p_value, linenr);1408 patch->old_name = patch->new_name = patch->def_name;1409}1410if(!patch->is_delete && !patch->new_name)1411die("git diff header lacks filename information "1412"(line%d)", linenr);1413 patch->is_toplevel_relative =1;1414*hdrsize = git_hdr_len;1415return offset;1416}14171418/* --- followed by +++ ? */1419if(memcmp("--- ", line,4) ||memcmp("+++ ", line + len,4))1420continue;14211422/*1423 * We only accept unified patches, so we want it to1424 * at least have "@@ -a,b +c,d @@\n", which is 14 chars1425 * minimum ("@@ -0,0 +1 @@\n" is the shortest).1426 */1427 nextlen =linelen(line + len, size - len);1428if(size < nextlen +14||memcmp("@@ -", line + len + nextlen,4))1429continue;14301431/* Ok, we'll consider it a patch */1432parse_traditional_patch(line, line+len, patch);1433*hdrsize = len + nextlen;1434 linenr +=2;1435return offset;1436}1437return-1;1438}14391440static voidrecord_ws_error(unsigned result,const char*line,int len,int linenr)1441{1442char*err;14431444if(!result)1445return;14461447 whitespace_error++;1448if(squelch_whitespace_errors &&1449 squelch_whitespace_errors < whitespace_error)1450return;14511452 err =whitespace_error_string(result);1453fprintf(stderr,"%s:%d:%s.\n%.*s\n",1454 patch_input_file, linenr, err, len, line);1455free(err);1456}14571458static voidcheck_whitespace(const char*line,int len,unsigned ws_rule)1459{1460unsigned result =ws_check(line +1, len -1, ws_rule);14611462record_ws_error(result, line +1, len -2, linenr);1463}14641465/*1466 * Parse a unified diff. Note that this really needs to parse each1467 * fragment separately, since the only way to know the difference1468 * between a "---" that is part of a patch, and a "---" that starts1469 * the next patch is to look at the line counts..1470 */1471static intparse_fragment(char*line,unsigned long size,1472struct patch *patch,struct fragment *fragment)1473{1474int added, deleted;1475int len =linelen(line, size), offset;1476unsigned long oldlines, newlines;1477unsigned long leading, trailing;14781479 offset =parse_fragment_header(line, len, fragment);1480if(offset <0)1481return-1;1482if(offset >0&& patch->recount)1483recount_diff(line + offset, size - offset, fragment);1484 oldlines = fragment->oldlines;1485 newlines = fragment->newlines;1486 leading =0;1487 trailing =0;14881489/* Parse the thing.. */1490 line += len;1491 size -= len;1492 linenr++;1493 added = deleted =0;1494for(offset = len;14950< size;1496 offset += len, size -= len, line += len, linenr++) {1497if(!oldlines && !newlines)1498break;1499 len =linelen(line, size);1500if(!len || line[len-1] !='\n')1501return-1;1502switch(*line) {1503default:1504return-1;1505case'\n':/* newer GNU diff, an empty context line */1506case' ':1507 oldlines--;1508 newlines--;1509if(!deleted && !added)1510 leading++;1511 trailing++;1512break;1513case'-':1514if(apply_in_reverse &&1515 ws_error_action != nowarn_ws_error)1516check_whitespace(line, len, patch->ws_rule);1517 deleted++;1518 oldlines--;1519 trailing =0;1520break;1521case'+':1522if(!apply_in_reverse &&1523 ws_error_action != nowarn_ws_error)1524check_whitespace(line, len, patch->ws_rule);1525 added++;1526 newlines--;1527 trailing =0;1528break;15291530/*1531 * We allow "\ No newline at end of file". Depending1532 * on locale settings when the patch was produced we1533 * don't know what this line looks like. The only1534 * thing we do know is that it begins with "\ ".1535 * Checking for 12 is just for sanity check -- any1536 * l10n of "\ No newline..." is at least that long.1537 */1538case'\\':1539if(len <12||memcmp(line,"\\",2))1540return-1;1541break;1542}1543}1544if(oldlines || newlines)1545return-1;1546 fragment->leading = leading;1547 fragment->trailing = trailing;15481549/*1550 * If a fragment ends with an incomplete line, we failed to include1551 * it in the above loop because we hit oldlines == newlines == 01552 * before seeing it.1553 */1554if(12< size && !memcmp(line,"\\",2))1555 offset +=linelen(line, size);15561557 patch->lines_added += added;1558 patch->lines_deleted += deleted;15591560if(0< patch->is_new && oldlines)1561returnerror("new file depends on old contents");1562if(0< patch->is_delete && newlines)1563returnerror("deleted file still has contents");1564return offset;1565}15661567static intparse_single_patch(char*line,unsigned long size,struct patch *patch)1568{1569unsigned long offset =0;1570unsigned long oldlines =0, newlines =0, context =0;1571struct fragment **fragp = &patch->fragments;15721573while(size >4&& !memcmp(line,"@@ -",4)) {1574struct fragment *fragment;1575int len;15761577 fragment =xcalloc(1,sizeof(*fragment));1578 fragment->linenr = linenr;1579 len =parse_fragment(line, size, patch, fragment);1580if(len <=0)1581die("corrupt patch at line%d", linenr);1582 fragment->patch = line;1583 fragment->size = len;1584 oldlines += fragment->oldlines;1585 newlines += fragment->newlines;1586 context += fragment->leading + fragment->trailing;15871588*fragp = fragment;1589 fragp = &fragment->next;15901591 offset += len;1592 line += len;1593 size -= len;1594}15951596/*1597 * If something was removed (i.e. we have old-lines) it cannot1598 * be creation, and if something was added it cannot be1599 * deletion. However, the reverse is not true; --unified=01600 * patches that only add are not necessarily creation even1601 * though they do not have any old lines, and ones that only1602 * delete are not necessarily deletion.1603 *1604 * Unfortunately, a real creation/deletion patch do _not_ have1605 * any context line by definition, so we cannot safely tell it1606 * apart with --unified=0 insanity. At least if the patch has1607 * more than one hunk it is not creation or deletion.1608 */1609if(patch->is_new <0&&1610(oldlines || (patch->fragments && patch->fragments->next)))1611 patch->is_new =0;1612if(patch->is_delete <0&&1613(newlines || (patch->fragments && patch->fragments->next)))1614 patch->is_delete =0;16151616if(0< patch->is_new && oldlines)1617die("new file%sdepends on old contents", patch->new_name);1618if(0< patch->is_delete && newlines)1619die("deleted file%sstill has contents", patch->old_name);1620if(!patch->is_delete && !newlines && context)1621fprintf(stderr,"** warning: file%sbecomes empty but "1622"is not deleted\n", patch->new_name);16231624return offset;1625}16261627staticinlineintmetadata_changes(struct patch *patch)1628{1629return patch->is_rename >0||1630 patch->is_copy >0||1631 patch->is_new >0||1632 patch->is_delete ||1633(patch->old_mode && patch->new_mode &&1634 patch->old_mode != patch->new_mode);1635}16361637static char*inflate_it(const void*data,unsigned long size,1638unsigned long inflated_size)1639{1640 git_zstream stream;1641void*out;1642int st;16431644memset(&stream,0,sizeof(stream));16451646 stream.next_in = (unsigned char*)data;1647 stream.avail_in = size;1648 stream.next_out = out =xmalloc(inflated_size);1649 stream.avail_out = inflated_size;1650git_inflate_init(&stream);1651 st =git_inflate(&stream, Z_FINISH);1652git_inflate_end(&stream);1653if((st != Z_STREAM_END) || stream.total_out != inflated_size) {1654free(out);1655return NULL;1656}1657return out;1658}16591660static struct fragment *parse_binary_hunk(char**buf_p,1661unsigned long*sz_p,1662int*status_p,1663int*used_p)1664{1665/*1666 * Expect a line that begins with binary patch method ("literal"1667 * or "delta"), followed by the length of data before deflating.1668 * a sequence of 'length-byte' followed by base-85 encoded data1669 * should follow, terminated by a newline.1670 *1671 * Each 5-byte sequence of base-85 encodes up to 4 bytes,1672 * and we would limit the patch line to 66 characters,1673 * so one line can fit up to 13 groups that would decode1674 * to 52 bytes max. The length byte 'A'-'Z' corresponds1675 * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.1676 */1677int llen, used;1678unsigned long size = *sz_p;1679char*buffer = *buf_p;1680int patch_method;1681unsigned long origlen;1682char*data = NULL;1683int hunk_size =0;1684struct fragment *frag;16851686 llen =linelen(buffer, size);1687 used = llen;16881689*status_p =0;16901691if(!prefixcmp(buffer,"delta ")) {1692 patch_method = BINARY_DELTA_DEFLATED;1693 origlen =strtoul(buffer +6, NULL,10);1694}1695else if(!prefixcmp(buffer,"literal ")) {1696 patch_method = BINARY_LITERAL_DEFLATED;1697 origlen =strtoul(buffer +8, NULL,10);1698}1699else1700return NULL;17011702 linenr++;1703 buffer += llen;1704while(1) {1705int byte_length, max_byte_length, newsize;1706 llen =linelen(buffer, size);1707 used += llen;1708 linenr++;1709if(llen ==1) {1710/* consume the blank line */1711 buffer++;1712 size--;1713break;1714}1715/*1716 * Minimum line is "A00000\n" which is 7-byte long,1717 * and the line length must be multiple of 5 plus 2.1718 */1719if((llen <7) || (llen-2) %5)1720goto corrupt;1721 max_byte_length = (llen -2) /5*4;1722 byte_length = *buffer;1723if('A'<= byte_length && byte_length <='Z')1724 byte_length = byte_length -'A'+1;1725else if('a'<= byte_length && byte_length <='z')1726 byte_length = byte_length -'a'+27;1727else1728goto corrupt;1729/* if the input length was not multiple of 4, we would1730 * have filler at the end but the filler should never1731 * exceed 3 bytes1732 */1733if(max_byte_length < byte_length ||1734 byte_length <= max_byte_length -4)1735goto corrupt;1736 newsize = hunk_size + byte_length;1737 data =xrealloc(data, newsize);1738if(decode_85(data + hunk_size, buffer +1, byte_length))1739goto corrupt;1740 hunk_size = newsize;1741 buffer += llen;1742 size -= llen;1743}17441745 frag =xcalloc(1,sizeof(*frag));1746 frag->patch =inflate_it(data, hunk_size, origlen);1747if(!frag->patch)1748goto corrupt;1749free(data);1750 frag->size = origlen;1751*buf_p = buffer;1752*sz_p = size;1753*used_p = used;1754 frag->binary_patch_method = patch_method;1755return frag;17561757 corrupt:1758free(data);1759*status_p = -1;1760error("corrupt binary patch at line%d: %.*s",1761 linenr-1, llen-1, buffer);1762return NULL;1763}17641765static intparse_binary(char*buffer,unsigned long size,struct patch *patch)1766{1767/*1768 * We have read "GIT binary patch\n"; what follows is a line1769 * that says the patch method (currently, either "literal" or1770 * "delta") and the length of data before deflating; a1771 * sequence of 'length-byte' followed by base-85 encoded data1772 * follows.1773 *1774 * When a binary patch is reversible, there is another binary1775 * hunk in the same format, starting with patch method (either1776 * "literal" or "delta") with the length of data, and a sequence1777 * of length-byte + base-85 encoded data, terminated with another1778 * empty line. This data, when applied to the postimage, produces1779 * the preimage.1780 */1781struct fragment *forward;1782struct fragment *reverse;1783int status;1784int used, used_1;17851786 forward =parse_binary_hunk(&buffer, &size, &status, &used);1787if(!forward && !status)1788/* there has to be one hunk (forward hunk) */1789returnerror("unrecognized binary patch at line%d", linenr-1);1790if(status)1791/* otherwise we already gave an error message */1792return status;17931794 reverse =parse_binary_hunk(&buffer, &size, &status, &used_1);1795if(reverse)1796 used += used_1;1797else if(status) {1798/*1799 * Not having reverse hunk is not an error, but having1800 * a corrupt reverse hunk is.1801 */1802free((void*) forward->patch);1803free(forward);1804return status;1805}1806 forward->next = reverse;1807 patch->fragments = forward;1808 patch->is_binary =1;1809return used;1810}18111812static intparse_chunk(char*buffer,unsigned long size,struct patch *patch)1813{1814int hdrsize, patchsize;1815int offset =find_header(buffer, size, &hdrsize, patch);18161817if(offset <0)1818return offset;18191820 patch->ws_rule =whitespace_rule(patch->new_name1821? patch->new_name1822: patch->old_name);18231824 patchsize =parse_single_patch(buffer + offset + hdrsize,1825 size - offset - hdrsize, patch);18261827if(!patchsize) {1828static const char*binhdr[] = {1829"Binary files ",1830"Files ",1831 NULL,1832};1833static const char git_binary[] ="GIT binary patch\n";1834int i;1835int hd = hdrsize + offset;1836unsigned long llen =linelen(buffer + hd, size - hd);18371838if(llen ==sizeof(git_binary) -1&&1839!memcmp(git_binary, buffer + hd, llen)) {1840int used;1841 linenr++;1842 used =parse_binary(buffer + hd + llen,1843 size - hd - llen, patch);1844if(used)1845 patchsize = used + llen;1846else1847 patchsize =0;1848}1849else if(!memcmp(" differ\n", buffer + hd + llen -8,8)) {1850for(i =0; binhdr[i]; i++) {1851int len =strlen(binhdr[i]);1852if(len < size - hd &&1853!memcmp(binhdr[i], buffer + hd, len)) {1854 linenr++;1855 patch->is_binary =1;1856 patchsize = llen;1857break;1858}1859}1860}18611862/* Empty patch cannot be applied if it is a text patch1863 * without metadata change. A binary patch appears1864 * empty to us here.1865 */1866if((apply || check) &&1867(!patch->is_binary && !metadata_changes(patch)))1868die("patch with only garbage at line%d", linenr);1869}18701871return offset + hdrsize + patchsize;1872}18731874#define swap(a,b) myswap((a),(b),sizeof(a))18751876#define myswap(a, b, size) do { \1877 unsigned char mytmp[size]; \1878 memcpy(mytmp, &a, size); \1879 memcpy(&a, &b, size); \1880 memcpy(&b, mytmp, size); \1881} while (0)18821883static voidreverse_patches(struct patch *p)1884{1885for(; p; p = p->next) {1886struct fragment *frag = p->fragments;18871888swap(p->new_name, p->old_name);1889swap(p->new_mode, p->old_mode);1890swap(p->is_new, p->is_delete);1891swap(p->lines_added, p->lines_deleted);1892swap(p->old_sha1_prefix, p->new_sha1_prefix);18931894for(; frag; frag = frag->next) {1895swap(frag->newpos, frag->oldpos);1896swap(frag->newlines, frag->oldlines);1897}1898}1899}19001901static const char pluses[] =1902"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";1903static const char minuses[]=1904"----------------------------------------------------------------------";19051906static voidshow_stats(struct patch *patch)1907{1908struct strbuf qname = STRBUF_INIT;1909char*cp = patch->new_name ? patch->new_name : patch->old_name;1910int max, add, del;19111912quote_c_style(cp, &qname, NULL,0);19131914/*1915 * "scale" the filename1916 */1917 max = max_len;1918if(max >50)1919 max =50;19201921if(qname.len > max) {1922 cp =strchr(qname.buf + qname.len +3- max,'/');1923if(!cp)1924 cp = qname.buf + qname.len +3- max;1925strbuf_splice(&qname,0, cp - qname.buf,"...",3);1926}19271928if(patch->is_binary) {1929printf(" %-*s | Bin\n", max, qname.buf);1930strbuf_release(&qname);1931return;1932}19331934printf(" %-*s |", max, qname.buf);1935strbuf_release(&qname);19361937/*1938 * scale the add/delete1939 */1940 max = max + max_change >70?70- max : max_change;1941 add = patch->lines_added;1942 del = patch->lines_deleted;19431944if(max_change >0) {1945int total = ((add + del) * max + max_change /2) / max_change;1946 add = (add * max + max_change /2) / max_change;1947 del = total - add;1948}1949printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,1950 add, pluses, del, minuses);1951}19521953static intread_old_data(struct stat *st,const char*path,struct strbuf *buf)1954{1955switch(st->st_mode & S_IFMT) {1956case S_IFLNK:1957if(strbuf_readlink(buf, path, st->st_size) <0)1958returnerror("unable to read symlink%s", path);1959return0;1960case S_IFREG:1961if(strbuf_read_file(buf, path, st->st_size) != st->st_size)1962returnerror("unable to open or read%s", path);1963convert_to_git(path, buf->buf, buf->len, buf,0);1964return0;1965default:1966return-1;1967}1968}19691970/*1971 * Update the preimage, and the common lines in postimage,1972 * from buffer buf of length len. If postlen is 0 the postimage1973 * is updated in place, otherwise it's updated on a new buffer1974 * of length postlen1975 */19761977static voidupdate_pre_post_images(struct image *preimage,1978struct image *postimage,1979char*buf,1980size_t len,size_t postlen)1981{1982int i, ctx;1983char*new, *old, *fixed;1984struct image fixed_preimage;19851986/*1987 * Update the preimage with whitespace fixes. Note that we1988 * are not losing preimage->buf -- apply_one_fragment() will1989 * free "oldlines".1990 */1991prepare_image(&fixed_preimage, buf, len,1);1992assert(fixed_preimage.nr == preimage->nr);1993for(i =0; i < preimage->nr; i++)1994 fixed_preimage.line[i].flag = preimage->line[i].flag;1995free(preimage->line_allocated);1996*preimage = fixed_preimage;19971998/*1999 * Adjust the common context lines in postimage. This can be2000 * done in-place when we are just doing whitespace fixing,2001 * which does not make the string grow, but needs a new buffer2002 * when ignoring whitespace causes the update, since in this case2003 * we could have e.g. tabs converted to multiple spaces.2004 * We trust the caller to tell us if the update can be done2005 * in place (postlen==0) or not.2006 */2007 old = postimage->buf;2008if(postlen)2009new= postimage->buf =xmalloc(postlen);2010else2011new= old;2012 fixed = preimage->buf;2013for(i = ctx =0; i < postimage->nr; i++) {2014size_t len = postimage->line[i].len;2015if(!(postimage->line[i].flag & LINE_COMMON)) {2016/* an added line -- no counterparts in preimage */2017memmove(new, old, len);2018 old += len;2019new+= len;2020continue;2021}20222023/* a common context -- skip it in the original postimage */2024 old += len;20252026/* and find the corresponding one in the fixed preimage */2027while(ctx < preimage->nr &&2028!(preimage->line[ctx].flag & LINE_COMMON)) {2029 fixed += preimage->line[ctx].len;2030 ctx++;2031}2032if(preimage->nr <= ctx)2033die("oops");20342035/* and copy it in, while fixing the line length */2036 len = preimage->line[ctx].len;2037memcpy(new, fixed, len);2038new+= len;2039 fixed += len;2040 postimage->line[i].len = len;2041 ctx++;2042}20432044/* Fix the length of the whole thing */2045 postimage->len =new- postimage->buf;2046}20472048static intmatch_fragment(struct image *img,2049struct image *preimage,2050struct image *postimage,2051unsigned longtry,2052int try_lno,2053unsigned ws_rule,2054int match_beginning,int match_end)2055{2056int i;2057char*fixed_buf, *buf, *orig, *target;2058struct strbuf fixed;2059size_t fixed_len;2060int preimage_limit;20612062if(preimage->nr + try_lno <= img->nr) {2063/*2064 * The hunk falls within the boundaries of img.2065 */2066 preimage_limit = preimage->nr;2067if(match_end && (preimage->nr + try_lno != img->nr))2068return0;2069}else if(ws_error_action == correct_ws_error &&2070(ws_rule & WS_BLANK_AT_EOF)) {2071/*2072 * This hunk extends beyond the end of img, and we are2073 * removing blank lines at the end of the file. This2074 * many lines from the beginning of the preimage must2075 * match with img, and the remainder of the preimage2076 * must be blank.2077 */2078 preimage_limit = img->nr - try_lno;2079}else{2080/*2081 * The hunk extends beyond the end of the img and2082 * we are not removing blanks at the end, so we2083 * should reject the hunk at this position.2084 */2085return0;2086}20872088if(match_beginning && try_lno)2089return0;20902091/* Quick hash check */2092for(i =0; i < preimage_limit; i++)2093if((img->line[try_lno + i].flag & LINE_PATCHED) ||2094(preimage->line[i].hash != img->line[try_lno + i].hash))2095return0;20962097if(preimage_limit == preimage->nr) {2098/*2099 * Do we have an exact match? If we were told to match2100 * at the end, size must be exactly at try+fragsize,2101 * otherwise try+fragsize must be still within the preimage,2102 * and either case, the old piece should match the preimage2103 * exactly.2104 */2105if((match_end2106? (try+ preimage->len == img->len)2107: (try+ preimage->len <= img->len)) &&2108!memcmp(img->buf +try, preimage->buf, preimage->len))2109return1;2110}else{2111/*2112 * The preimage extends beyond the end of img, so2113 * there cannot be an exact match.2114 *2115 * There must be one non-blank context line that match2116 * a line before the end of img.2117 */2118char*buf_end;21192120 buf = preimage->buf;2121 buf_end = buf;2122for(i =0; i < preimage_limit; i++)2123 buf_end += preimage->line[i].len;21242125for( ; buf < buf_end; buf++)2126if(!isspace(*buf))2127break;2128if(buf == buf_end)2129return0;2130}21312132/*2133 * No exact match. If we are ignoring whitespace, run a line-by-line2134 * fuzzy matching. We collect all the line length information because2135 * we need it to adjust whitespace if we match.2136 */2137if(ws_ignore_action == ignore_ws_change) {2138size_t imgoff =0;2139size_t preoff =0;2140size_t postlen = postimage->len;2141size_t extra_chars;2142char*preimage_eof;2143char*preimage_end;2144for(i =0; i < preimage_limit; i++) {2145size_t prelen = preimage->line[i].len;2146size_t imglen = img->line[try_lno+i].len;21472148if(!fuzzy_matchlines(img->buf +try+ imgoff, imglen,2149 preimage->buf + preoff, prelen))2150return0;2151if(preimage->line[i].flag & LINE_COMMON)2152 postlen += imglen - prelen;2153 imgoff += imglen;2154 preoff += prelen;2155}21562157/*2158 * Ok, the preimage matches with whitespace fuzz.2159 *2160 * imgoff now holds the true length of the target that2161 * matches the preimage before the end of the file.2162 *2163 * Count the number of characters in the preimage that fall2164 * beyond the end of the file and make sure that all of them2165 * are whitespace characters. (This can only happen if2166 * we are removing blank lines at the end of the file.)2167 */2168 buf = preimage_eof = preimage->buf + preoff;2169for( ; i < preimage->nr; i++)2170 preoff += preimage->line[i].len;2171 preimage_end = preimage->buf + preoff;2172for( ; buf < preimage_end; buf++)2173if(!isspace(*buf))2174return0;21752176/*2177 * Update the preimage and the common postimage context2178 * lines to use the same whitespace as the target.2179 * If whitespace is missing in the target (i.e.2180 * if the preimage extends beyond the end of the file),2181 * use the whitespace from the preimage.2182 */2183 extra_chars = preimage_end - preimage_eof;2184strbuf_init(&fixed, imgoff + extra_chars);2185strbuf_add(&fixed, img->buf +try, imgoff);2186strbuf_add(&fixed, preimage_eof, extra_chars);2187 fixed_buf =strbuf_detach(&fixed, &fixed_len);2188update_pre_post_images(preimage, postimage,2189 fixed_buf, fixed_len, postlen);2190return1;2191}21922193if(ws_error_action != correct_ws_error)2194return0;21952196/*2197 * The hunk does not apply byte-by-byte, but the hash says2198 * it might with whitespace fuzz. We haven't been asked to2199 * ignore whitespace, we were asked to correct whitespace2200 * errors, so let's try matching after whitespace correction.2201 *2202 * The preimage may extend beyond the end of the file,2203 * but in this loop we will only handle the part of the2204 * preimage that falls within the file.2205 */2206strbuf_init(&fixed, preimage->len +1);2207 orig = preimage->buf;2208 target = img->buf +try;2209for(i =0; i < preimage_limit; i++) {2210size_t oldlen = preimage->line[i].len;2211size_t tgtlen = img->line[try_lno + i].len;2212size_t fixstart = fixed.len;2213struct strbuf tgtfix;2214int match;22152216/* Try fixing the line in the preimage */2217ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);22182219/* Try fixing the line in the target */2220strbuf_init(&tgtfix, tgtlen);2221ws_fix_copy(&tgtfix, target, tgtlen, ws_rule, NULL);22222223/*2224 * If they match, either the preimage was based on2225 * a version before our tree fixed whitespace breakage,2226 * or we are lacking a whitespace-fix patch the tree2227 * the preimage was based on already had (i.e. target2228 * has whitespace breakage, the preimage doesn't).2229 * In either case, we are fixing the whitespace breakages2230 * so we might as well take the fix together with their2231 * real change.2232 */2233 match = (tgtfix.len == fixed.len - fixstart &&2234!memcmp(tgtfix.buf, fixed.buf + fixstart,2235 fixed.len - fixstart));22362237strbuf_release(&tgtfix);2238if(!match)2239goto unmatch_exit;22402241 orig += oldlen;2242 target += tgtlen;2243}224422452246/*2247 * Now handle the lines in the preimage that falls beyond the2248 * end of the file (if any). They will only match if they are2249 * empty or only contain whitespace (if WS_BLANK_AT_EOL is2250 * false).2251 */2252for( ; i < preimage->nr; i++) {2253size_t fixstart = fixed.len;/* start of the fixed preimage */2254size_t oldlen = preimage->line[i].len;2255int j;22562257/* Try fixing the line in the preimage */2258ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);22592260for(j = fixstart; j < fixed.len; j++)2261if(!isspace(fixed.buf[j]))2262goto unmatch_exit;22632264 orig += oldlen;2265}22662267/*2268 * Yes, the preimage is based on an older version that still2269 * has whitespace breakages unfixed, and fixing them makes the2270 * hunk match. Update the context lines in the postimage.2271 */2272 fixed_buf =strbuf_detach(&fixed, &fixed_len);2273update_pre_post_images(preimage, postimage,2274 fixed_buf, fixed_len,0);2275return1;22762277 unmatch_exit:2278strbuf_release(&fixed);2279return0;2280}22812282static intfind_pos(struct image *img,2283struct image *preimage,2284struct image *postimage,2285int line,2286unsigned ws_rule,2287int match_beginning,int match_end)2288{2289int i;2290unsigned long backwards, forwards,try;2291int backwards_lno, forwards_lno, try_lno;22922293/*2294 * If match_beginning or match_end is specified, there is no2295 * point starting from a wrong line that will never match and2296 * wander around and wait for a match at the specified end.2297 */2298if(match_beginning)2299 line =0;2300else if(match_end)2301 line = img->nr - preimage->nr;23022303/*2304 * Because the comparison is unsigned, the following test2305 * will also take care of a negative line number that can2306 * result when match_end and preimage is larger than the target.2307 */2308if((size_t) line > img->nr)2309 line = img->nr;23102311try=0;2312for(i =0; i < line; i++)2313try+= img->line[i].len;23142315/*2316 * There's probably some smart way to do this, but I'll leave2317 * that to the smart and beautiful people. I'm simple and stupid.2318 */2319 backwards =try;2320 backwards_lno = line;2321 forwards =try;2322 forwards_lno = line;2323 try_lno = line;23242325for(i =0; ; i++) {2326if(match_fragment(img, preimage, postimage,2327try, try_lno, ws_rule,2328 match_beginning, match_end))2329return try_lno;23302331 again:2332if(backwards_lno ==0&& forwards_lno == img->nr)2333break;23342335if(i &1) {2336if(backwards_lno ==0) {2337 i++;2338goto again;2339}2340 backwards_lno--;2341 backwards -= img->line[backwards_lno].len;2342try= backwards;2343 try_lno = backwards_lno;2344}else{2345if(forwards_lno == img->nr) {2346 i++;2347goto again;2348}2349 forwards += img->line[forwards_lno].len;2350 forwards_lno++;2351try= forwards;2352 try_lno = forwards_lno;2353}23542355}2356return-1;2357}23582359static voidremove_first_line(struct image *img)2360{2361 img->buf += img->line[0].len;2362 img->len -= img->line[0].len;2363 img->line++;2364 img->nr--;2365}23662367static voidremove_last_line(struct image *img)2368{2369 img->len -= img->line[--img->nr].len;2370}23712372static voidupdate_image(struct image *img,2373int applied_pos,2374struct image *preimage,2375struct image *postimage)2376{2377/*2378 * remove the copy of preimage at offset in img2379 * and replace it with postimage2380 */2381int i, nr;2382size_t remove_count, insert_count, applied_at =0;2383char*result;2384int preimage_limit;23852386/*2387 * If we are removing blank lines at the end of img,2388 * the preimage may extend beyond the end.2389 * If that is the case, we must be careful only to2390 * remove the part of the preimage that falls within2391 * the boundaries of img. Initialize preimage_limit2392 * to the number of lines in the preimage that falls2393 * within the boundaries.2394 */2395 preimage_limit = preimage->nr;2396if(preimage_limit > img->nr - applied_pos)2397 preimage_limit = img->nr - applied_pos;23982399for(i =0; i < applied_pos; i++)2400 applied_at += img->line[i].len;24012402 remove_count =0;2403for(i =0; i < preimage_limit; i++)2404 remove_count += img->line[applied_pos + i].len;2405 insert_count = postimage->len;24062407/* Adjust the contents */2408 result =xmalloc(img->len + insert_count - remove_count +1);2409memcpy(result, img->buf, applied_at);2410memcpy(result + applied_at, postimage->buf, postimage->len);2411memcpy(result + applied_at + postimage->len,2412 img->buf + (applied_at + remove_count),2413 img->len - (applied_at + remove_count));2414free(img->buf);2415 img->buf = result;2416 img->len += insert_count - remove_count;2417 result[img->len] ='\0';24182419/* Adjust the line table */2420 nr = img->nr + postimage->nr - preimage_limit;2421if(preimage_limit < postimage->nr) {2422/*2423 * NOTE: this knows that we never call remove_first_line()2424 * on anything other than pre/post image.2425 */2426 img->line =xrealloc(img->line, nr *sizeof(*img->line));2427 img->line_allocated = img->line;2428}2429if(preimage_limit != postimage->nr)2430memmove(img->line + applied_pos + postimage->nr,2431 img->line + applied_pos + preimage_limit,2432(img->nr - (applied_pos + preimage_limit)) *2433sizeof(*img->line));2434memcpy(img->line + applied_pos,2435 postimage->line,2436 postimage->nr *sizeof(*img->line));2437if(!allow_overlap)2438for(i =0; i < postimage->nr; i++)2439 img->line[applied_pos + i].flag |= LINE_PATCHED;2440 img->nr = nr;2441}24422443static intapply_one_fragment(struct image *img,struct fragment *frag,2444int inaccurate_eof,unsigned ws_rule,2445int nth_fragment)2446{2447int match_beginning, match_end;2448const char*patch = frag->patch;2449int size = frag->size;2450char*old, *oldlines;2451struct strbuf newlines;2452int new_blank_lines_at_end =0;2453unsigned long leading, trailing;2454int pos, applied_pos;2455struct image preimage;2456struct image postimage;24572458memset(&preimage,0,sizeof(preimage));2459memset(&postimage,0,sizeof(postimage));2460 oldlines =xmalloc(size);2461strbuf_init(&newlines, size);24622463 old = oldlines;2464while(size >0) {2465char first;2466int len =linelen(patch, size);2467int plen;2468int added_blank_line =0;2469int is_blank_context =0;2470size_t start;24712472if(!len)2473break;24742475/*2476 * "plen" is how much of the line we should use for2477 * the actual patch data. Normally we just remove the2478 * first character on the line, but if the line is2479 * followed by "\ No newline", then we also remove the2480 * last one (which is the newline, of course).2481 */2482 plen = len -1;2483if(len < size && patch[len] =='\\')2484 plen--;2485 first = *patch;2486if(apply_in_reverse) {2487if(first =='-')2488 first ='+';2489else if(first =='+')2490 first ='-';2491}24922493switch(first) {2494case'\n':2495/* Newer GNU diff, empty context line */2496if(plen <0)2497/* ... followed by '\No newline'; nothing */2498break;2499*old++ ='\n';2500strbuf_addch(&newlines,'\n');2501add_line_info(&preimage,"\n",1, LINE_COMMON);2502add_line_info(&postimage,"\n",1, LINE_COMMON);2503 is_blank_context =1;2504break;2505case' ':2506if(plen && (ws_rule & WS_BLANK_AT_EOF) &&2507ws_blank_line(patch +1, plen, ws_rule))2508 is_blank_context =1;2509case'-':2510memcpy(old, patch +1, plen);2511add_line_info(&preimage, old, plen,2512(first ==' '? LINE_COMMON :0));2513 old += plen;2514if(first =='-')2515break;2516/* Fall-through for ' ' */2517case'+':2518/* --no-add does not add new lines */2519if(first =='+'&& no_add)2520break;25212522 start = newlines.len;2523if(first !='+'||2524!whitespace_error ||2525 ws_error_action != correct_ws_error) {2526strbuf_add(&newlines, patch +1, plen);2527}2528else{2529ws_fix_copy(&newlines, patch +1, plen, ws_rule, &applied_after_fixing_ws);2530}2531add_line_info(&postimage, newlines.buf + start, newlines.len - start,2532(first =='+'?0: LINE_COMMON));2533if(first =='+'&&2534(ws_rule & WS_BLANK_AT_EOF) &&2535ws_blank_line(patch +1, plen, ws_rule))2536 added_blank_line =1;2537break;2538case'@':case'\\':2539/* Ignore it, we already handled it */2540break;2541default:2542if(apply_verbosely)2543error("invalid start of line: '%c'", first);2544return-1;2545}2546if(added_blank_line)2547 new_blank_lines_at_end++;2548else if(is_blank_context)2549;2550else2551 new_blank_lines_at_end =0;2552 patch += len;2553 size -= len;2554}2555if(inaccurate_eof &&2556 old > oldlines && old[-1] =='\n'&&2557 newlines.len >0&& newlines.buf[newlines.len -1] =='\n') {2558 old--;2559strbuf_setlen(&newlines, newlines.len -1);2560}25612562 leading = frag->leading;2563 trailing = frag->trailing;25642565/*2566 * A hunk to change lines at the beginning would begin with2567 * @@ -1,L +N,M @@2568 * but we need to be careful. -U0 that inserts before the second2569 * line also has this pattern.2570 *2571 * And a hunk to add to an empty file would begin with2572 * @@ -0,0 +N,M @@2573 *2574 * In other words, a hunk that is (frag->oldpos <= 1) with or2575 * without leading context must match at the beginning.2576 */2577 match_beginning = (!frag->oldpos ||2578(frag->oldpos ==1&& !unidiff_zero));25792580/*2581 * A hunk without trailing lines must match at the end.2582 * However, we simply cannot tell if a hunk must match end2583 * from the lack of trailing lines if the patch was generated2584 * with unidiff without any context.2585 */2586 match_end = !unidiff_zero && !trailing;25872588 pos = frag->newpos ? (frag->newpos -1) :0;2589 preimage.buf = oldlines;2590 preimage.len = old - oldlines;2591 postimage.buf = newlines.buf;2592 postimage.len = newlines.len;2593 preimage.line = preimage.line_allocated;2594 postimage.line = postimage.line_allocated;25952596for(;;) {25972598 applied_pos =find_pos(img, &preimage, &postimage, pos,2599 ws_rule, match_beginning, match_end);26002601if(applied_pos >=0)2602break;26032604/* Am I at my context limits? */2605if((leading <= p_context) && (trailing <= p_context))2606break;2607if(match_beginning || match_end) {2608 match_beginning = match_end =0;2609continue;2610}26112612/*2613 * Reduce the number of context lines; reduce both2614 * leading and trailing if they are equal otherwise2615 * just reduce the larger context.2616 */2617if(leading >= trailing) {2618remove_first_line(&preimage);2619remove_first_line(&postimage);2620 pos--;2621 leading--;2622}2623if(trailing > leading) {2624remove_last_line(&preimage);2625remove_last_line(&postimage);2626 trailing--;2627}2628}26292630if(applied_pos >=0) {2631if(new_blank_lines_at_end &&2632 preimage.nr + applied_pos >= img->nr &&2633(ws_rule & WS_BLANK_AT_EOF) &&2634 ws_error_action != nowarn_ws_error) {2635record_ws_error(WS_BLANK_AT_EOF,"+",1, frag->linenr);2636if(ws_error_action == correct_ws_error) {2637while(new_blank_lines_at_end--)2638remove_last_line(&postimage);2639}2640/*2641 * We would want to prevent write_out_results()2642 * from taking place in apply_patch() that follows2643 * the callchain led us here, which is:2644 * apply_patch->check_patch_list->check_patch->2645 * apply_data->apply_fragments->apply_one_fragment2646 */2647if(ws_error_action == die_on_ws_error)2648 apply =0;2649}26502651if(apply_verbosely && applied_pos != pos) {2652int offset = applied_pos - pos;2653if(apply_in_reverse)2654 offset =0- offset;2655fprintf(stderr,2656"Hunk #%dsucceeded at%d(offset%dlines).\n",2657 nth_fragment, applied_pos +1, offset);2658}26592660/*2661 * Warn if it was necessary to reduce the number2662 * of context lines.2663 */2664if((leading != frag->leading) ||2665(trailing != frag->trailing))2666fprintf(stderr,"Context reduced to (%ld/%ld)"2667" to apply fragment at%d\n",2668 leading, trailing, applied_pos+1);2669update_image(img, applied_pos, &preimage, &postimage);2670}else{2671if(apply_verbosely)2672error("while searching for:\n%.*s",2673(int)(old - oldlines), oldlines);2674}26752676free(oldlines);2677strbuf_release(&newlines);2678free(preimage.line_allocated);2679free(postimage.line_allocated);26802681return(applied_pos <0);2682}26832684static intapply_binary_fragment(struct image *img,struct patch *patch)2685{2686struct fragment *fragment = patch->fragments;2687unsigned long len;2688void*dst;26892690if(!fragment)2691returnerror("missing binary patch data for '%s'",2692 patch->new_name ?2693 patch->new_name :2694 patch->old_name);26952696/* Binary patch is irreversible without the optional second hunk */2697if(apply_in_reverse) {2698if(!fragment->next)2699returnerror("cannot reverse-apply a binary patch "2700"without the reverse hunk to '%s'",2701 patch->new_name2702? patch->new_name : patch->old_name);2703 fragment = fragment->next;2704}2705switch(fragment->binary_patch_method) {2706case BINARY_DELTA_DEFLATED:2707 dst =patch_delta(img->buf, img->len, fragment->patch,2708 fragment->size, &len);2709if(!dst)2710return-1;2711clear_image(img);2712 img->buf = dst;2713 img->len = len;2714return0;2715case BINARY_LITERAL_DEFLATED:2716clear_image(img);2717 img->len = fragment->size;2718 img->buf =xmalloc(img->len+1);2719memcpy(img->buf, fragment->patch, img->len);2720 img->buf[img->len] ='\0';2721return0;2722}2723return-1;2724}27252726static intapply_binary(struct image *img,struct patch *patch)2727{2728const char*name = patch->old_name ? patch->old_name : patch->new_name;2729unsigned char sha1[20];27302731/*2732 * For safety, we require patch index line to contain2733 * full 40-byte textual SHA1 for old and new, at least for now.2734 */2735if(strlen(patch->old_sha1_prefix) !=40||2736strlen(patch->new_sha1_prefix) !=40||2737get_sha1_hex(patch->old_sha1_prefix, sha1) ||2738get_sha1_hex(patch->new_sha1_prefix, sha1))2739returnerror("cannot apply binary patch to '%s' "2740"without full index line", name);27412742if(patch->old_name) {2743/*2744 * See if the old one matches what the patch2745 * applies to.2746 */2747hash_sha1_file(img->buf, img->len, blob_type, sha1);2748if(strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))2749returnerror("the patch applies to '%s' (%s), "2750"which does not match the "2751"current contents.",2752 name,sha1_to_hex(sha1));2753}2754else{2755/* Otherwise, the old one must be empty. */2756if(img->len)2757returnerror("the patch applies to an empty "2758"'%s' but it is not empty", name);2759}27602761get_sha1_hex(patch->new_sha1_prefix, sha1);2762if(is_null_sha1(sha1)) {2763clear_image(img);2764return0;/* deletion patch */2765}27662767if(has_sha1_file(sha1)) {2768/* We already have the postimage */2769enum object_type type;2770unsigned long size;2771char*result;27722773 result =read_sha1_file(sha1, &type, &size);2774if(!result)2775returnerror("the necessary postimage%sfor "2776"'%s' cannot be read",2777 patch->new_sha1_prefix, name);2778clear_image(img);2779 img->buf = result;2780 img->len = size;2781}else{2782/*2783 * We have verified buf matches the preimage;2784 * apply the patch data to it, which is stored2785 * in the patch->fragments->{patch,size}.2786 */2787if(apply_binary_fragment(img, patch))2788returnerror("binary patch does not apply to '%s'",2789 name);27902791/* verify that the result matches */2792hash_sha1_file(img->buf, img->len, blob_type, sha1);2793if(strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))2794returnerror("binary patch to '%s' creates incorrect result (expecting%s, got%s)",2795 name, patch->new_sha1_prefix,sha1_to_hex(sha1));2796}27972798return0;2799}28002801static intapply_fragments(struct image *img,struct patch *patch)2802{2803struct fragment *frag = patch->fragments;2804const char*name = patch->old_name ? patch->old_name : patch->new_name;2805unsigned ws_rule = patch->ws_rule;2806unsigned inaccurate_eof = patch->inaccurate_eof;2807int nth =0;28082809if(patch->is_binary)2810returnapply_binary(img, patch);28112812while(frag) {2813 nth++;2814if(apply_one_fragment(img, frag, inaccurate_eof, ws_rule, nth)) {2815error("patch failed:%s:%ld", name, frag->oldpos);2816if(!apply_with_reject)2817return-1;2818 frag->rejected =1;2819}2820 frag = frag->next;2821}2822return0;2823}28242825static intread_file_or_gitlink(struct cache_entry *ce,struct strbuf *buf)2826{2827if(!ce)2828return0;28292830if(S_ISGITLINK(ce->ce_mode)) {2831strbuf_grow(buf,100);2832strbuf_addf(buf,"Subproject commit%s\n",sha1_to_hex(ce->sha1));2833}else{2834enum object_type type;2835unsigned long sz;2836char*result;28372838 result =read_sha1_file(ce->sha1, &type, &sz);2839if(!result)2840return-1;2841/* XXX read_sha1_file NUL-terminates */2842strbuf_attach(buf, result, sz, sz +1);2843}2844return0;2845}28462847static struct patch *in_fn_table(const char*name)2848{2849struct string_list_item *item;28502851if(name == NULL)2852return NULL;28532854 item =string_list_lookup(&fn_table, name);2855if(item != NULL)2856return(struct patch *)item->util;28572858return NULL;2859}28602861/*2862 * item->util in the filename table records the status of the path.2863 * Usually it points at a patch (whose result records the contents2864 * of it after applying it), but it could be PATH_WAS_DELETED for a2865 * path that a previously applied patch has already removed.2866 */2867#define PATH_TO_BE_DELETED ((struct patch *) -2)2868#define PATH_WAS_DELETED ((struct patch *) -1)28692870static intto_be_deleted(struct patch *patch)2871{2872return patch == PATH_TO_BE_DELETED;2873}28742875static intwas_deleted(struct patch *patch)2876{2877return patch == PATH_WAS_DELETED;2878}28792880static voidadd_to_fn_table(struct patch *patch)2881{2882struct string_list_item *item;28832884/*2885 * Always add new_name unless patch is a deletion2886 * This should cover the cases for normal diffs,2887 * file creations and copies2888 */2889if(patch->new_name != NULL) {2890 item =string_list_insert(&fn_table, patch->new_name);2891 item->util = patch;2892}28932894/*2895 * store a failure on rename/deletion cases because2896 * later chunks shouldn't patch old names2897 */2898if((patch->new_name == NULL) || (patch->is_rename)) {2899 item =string_list_insert(&fn_table, patch->old_name);2900 item->util = PATH_WAS_DELETED;2901}2902}29032904static voidprepare_fn_table(struct patch *patch)2905{2906/*2907 * store information about incoming file deletion2908 */2909while(patch) {2910if((patch->new_name == NULL) || (patch->is_rename)) {2911struct string_list_item *item;2912 item =string_list_insert(&fn_table, patch->old_name);2913 item->util = PATH_TO_BE_DELETED;2914}2915 patch = patch->next;2916}2917}29182919static intapply_data(struct patch *patch,struct stat *st,struct cache_entry *ce)2920{2921struct strbuf buf = STRBUF_INIT;2922struct image image;2923size_t len;2924char*img;2925struct patch *tpatch;29262927if(!(patch->is_copy || patch->is_rename) &&2928(tpatch =in_fn_table(patch->old_name)) != NULL && !to_be_deleted(tpatch)) {2929if(was_deleted(tpatch)) {2930returnerror("patch%shas been renamed/deleted",2931 patch->old_name);2932}2933/* We have a patched copy in memory use that */2934strbuf_add(&buf, tpatch->result, tpatch->resultsize);2935}else if(cached) {2936if(read_file_or_gitlink(ce, &buf))2937returnerror("read of%sfailed", patch->old_name);2938}else if(patch->old_name) {2939if(S_ISGITLINK(patch->old_mode)) {2940if(ce) {2941read_file_or_gitlink(ce, &buf);2942}else{2943/*2944 * There is no way to apply subproject2945 * patch without looking at the index.2946 */2947 patch->fragments = NULL;2948}2949}else{2950if(read_old_data(st, patch->old_name, &buf))2951returnerror("read of%sfailed", patch->old_name);2952}2953}29542955 img =strbuf_detach(&buf, &len);2956prepare_image(&image, img, len, !patch->is_binary);29572958if(apply_fragments(&image, patch) <0)2959return-1;/* note with --reject this succeeds. */2960 patch->result = image.buf;2961 patch->resultsize = image.len;2962add_to_fn_table(patch);2963free(image.line_allocated);29642965if(0< patch->is_delete && patch->resultsize)2966returnerror("removal patch leaves file contents");29672968return0;2969}29702971static intcheck_to_create_blob(const char*new_name,int ok_if_exists)2972{2973struct stat nst;2974if(!lstat(new_name, &nst)) {2975if(S_ISDIR(nst.st_mode) || ok_if_exists)2976return0;2977/*2978 * A leading component of new_name might be a symlink2979 * that is going to be removed with this patch, but2980 * still pointing at somewhere that has the path.2981 * In such a case, path "new_name" does not exist as2982 * far as git is concerned.2983 */2984if(has_symlink_leading_path(new_name,strlen(new_name)))2985return0;29862987returnerror("%s: already exists in working directory", new_name);2988}2989else if((errno != ENOENT) && (errno != ENOTDIR))2990returnerror("%s:%s", new_name,strerror(errno));2991return0;2992}29932994static intverify_index_match(struct cache_entry *ce,struct stat *st)2995{2996if(S_ISGITLINK(ce->ce_mode)) {2997if(!S_ISDIR(st->st_mode))2998return-1;2999return0;3000}3001returnce_match_stat(ce, st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);3002}30033004static intcheck_preimage(struct patch *patch,struct cache_entry **ce,struct stat *st)3005{3006const char*old_name = patch->old_name;3007struct patch *tpatch = NULL;3008int stat_ret =0;3009unsigned st_mode =0;30103011/*3012 * Make sure that we do not have local modifications from the3013 * index when we are looking at the index. Also make sure3014 * we have the preimage file to be patched in the work tree,3015 * unless --cached, which tells git to apply only in the index.3016 */3017if(!old_name)3018return0;30193020assert(patch->is_new <=0);30213022if(!(patch->is_copy || patch->is_rename) &&3023(tpatch =in_fn_table(old_name)) != NULL && !to_be_deleted(tpatch)) {3024if(was_deleted(tpatch))3025returnerror("%s: has been deleted/renamed", old_name);3026 st_mode = tpatch->new_mode;3027}else if(!cached) {3028 stat_ret =lstat(old_name, st);3029if(stat_ret && errno != ENOENT)3030returnerror("%s:%s", old_name,strerror(errno));3031}30323033if(to_be_deleted(tpatch))3034 tpatch = NULL;30353036if(check_index && !tpatch) {3037int pos =cache_name_pos(old_name,strlen(old_name));3038if(pos <0) {3039if(patch->is_new <0)3040goto is_new;3041returnerror("%s: does not exist in index", old_name);3042}3043*ce = active_cache[pos];3044if(stat_ret <0) {3045struct checkout costate;3046/* checkout */3047memset(&costate,0,sizeof(costate));3048 costate.base_dir ="";3049 costate.refresh_cache =1;3050if(checkout_entry(*ce, &costate, NULL) ||3051lstat(old_name, st))3052return-1;3053}3054if(!cached &&verify_index_match(*ce, st))3055returnerror("%s: does not match index", old_name);3056if(cached)3057 st_mode = (*ce)->ce_mode;3058}else if(stat_ret <0) {3059if(patch->is_new <0)3060goto is_new;3061returnerror("%s:%s", old_name,strerror(errno));3062}30633064if(!cached && !tpatch)3065 st_mode =ce_mode_from_stat(*ce, st->st_mode);30663067if(patch->is_new <0)3068 patch->is_new =0;3069if(!patch->old_mode)3070 patch->old_mode = st_mode;3071if((st_mode ^ patch->old_mode) & S_IFMT)3072returnerror("%s: wrong type", old_name);3073if(st_mode != patch->old_mode)3074warning("%shas type%o, expected%o",3075 old_name, st_mode, patch->old_mode);3076if(!patch->new_mode && !patch->is_delete)3077 patch->new_mode = st_mode;3078return0;30793080 is_new:3081 patch->is_new =1;3082 patch->is_delete =0;3083 patch->old_name = NULL;3084return0;3085}30863087static intcheck_patch(struct patch *patch)3088{3089struct stat st;3090const char*old_name = patch->old_name;3091const char*new_name = patch->new_name;3092const char*name = old_name ? old_name : new_name;3093struct cache_entry *ce = NULL;3094struct patch *tpatch;3095int ok_if_exists;3096int status;30973098 patch->rejected =1;/* we will drop this after we succeed */30993100 status =check_preimage(patch, &ce, &st);3101if(status)3102return status;3103 old_name = patch->old_name;31043105if((tpatch =in_fn_table(new_name)) &&3106(was_deleted(tpatch) ||to_be_deleted(tpatch)))3107/*3108 * A type-change diff is always split into a patch to3109 * delete old, immediately followed by a patch to3110 * create new (see diff.c::run_diff()); in such a case3111 * it is Ok that the entry to be deleted by the3112 * previous patch is still in the working tree and in3113 * the index.3114 */3115 ok_if_exists =1;3116else3117 ok_if_exists =0;31183119if(new_name &&3120((0< patch->is_new) | (0< patch->is_rename) | patch->is_copy)) {3121if(check_index &&3122cache_name_pos(new_name,strlen(new_name)) >=0&&3123!ok_if_exists)3124returnerror("%s: already exists in index", new_name);3125if(!cached) {3126int err =check_to_create_blob(new_name, ok_if_exists);3127if(err)3128return err;3129}3130if(!patch->new_mode) {3131if(0< patch->is_new)3132 patch->new_mode = S_IFREG |0644;3133else3134 patch->new_mode = patch->old_mode;3135}3136}31373138if(new_name && old_name) {3139int same = !strcmp(old_name, new_name);3140if(!patch->new_mode)3141 patch->new_mode = patch->old_mode;3142if((patch->old_mode ^ patch->new_mode) & S_IFMT)3143returnerror("new mode (%o) of%sdoes not match old mode (%o)%s%s",3144 patch->new_mode, new_name, patch->old_mode,3145 same ?"":" of ", same ?"": old_name);3146}31473148if(apply_data(patch, &st, ce) <0)3149returnerror("%s: patch does not apply", name);3150 patch->rejected =0;3151return0;3152}31533154static intcheck_patch_list(struct patch *patch)3155{3156int err =0;31573158prepare_fn_table(patch);3159while(patch) {3160if(apply_verbosely)3161say_patch_name(stderr,3162"Checking patch ", patch,"...\n");3163 err |=check_patch(patch);3164 patch = patch->next;3165}3166return err;3167}31683169/* This function tries to read the sha1 from the current index */3170static intget_current_sha1(const char*path,unsigned char*sha1)3171{3172int pos;31733174if(read_cache() <0)3175return-1;3176 pos =cache_name_pos(path,strlen(path));3177if(pos <0)3178return-1;3179hashcpy(sha1, active_cache[pos]->sha1);3180return0;3181}31823183/* Build an index that contains the just the files needed for a 3way merge */3184static voidbuild_fake_ancestor(struct patch *list,const char*filename)3185{3186struct patch *patch;3187struct index_state result = { NULL };3188int fd;31893190/* Once we start supporting the reverse patch, it may be3191 * worth showing the new sha1 prefix, but until then...3192 */3193for(patch = list; patch; patch = patch->next) {3194const unsigned char*sha1_ptr;3195unsigned char sha1[20];3196struct cache_entry *ce;3197const char*name;31983199 name = patch->old_name ? patch->old_name : patch->new_name;3200if(0< patch->is_new)3201continue;3202else if(get_sha1(patch->old_sha1_prefix, sha1))3203/* git diff has no index line for mode/type changes */3204if(!patch->lines_added && !patch->lines_deleted) {3205if(get_current_sha1(patch->old_name, sha1))3206die("mode change for%s, which is not "3207"in current HEAD", name);3208 sha1_ptr = sha1;3209}else3210die("sha1 information is lacking or useless "3211"(%s).", name);3212else3213 sha1_ptr = sha1;32143215 ce =make_cache_entry(patch->old_mode, sha1_ptr, name,0,0);3216if(!ce)3217die("make_cache_entry failed for path '%s'", name);3218if(add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))3219die("Could not add%sto temporary index", name);3220}32213222 fd =open(filename, O_WRONLY | O_CREAT,0666);3223if(fd <0||write_index(&result, fd) ||close(fd))3224die("Could not write temporary index to%s", filename);32253226discard_index(&result);3227}32283229static voidstat_patch_list(struct patch *patch)3230{3231int files, adds, dels;32323233for(files = adds = dels =0; patch ; patch = patch->next) {3234 files++;3235 adds += patch->lines_added;3236 dels += patch->lines_deleted;3237show_stats(patch);3238}32393240printf("%dfiles changed,%dinsertions(+),%ddeletions(-)\n", files, adds, dels);3241}32423243static voidnumstat_patch_list(struct patch *patch)3244{3245for( ; patch; patch = patch->next) {3246const char*name;3247 name = patch->new_name ? patch->new_name : patch->old_name;3248if(patch->is_binary)3249printf("-\t-\t");3250else3251printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);3252write_name_quoted(name, stdout, line_termination);3253}3254}32553256static voidshow_file_mode_name(const char*newdelete,unsigned int mode,const char*name)3257{3258if(mode)3259printf("%smode%06o%s\n", newdelete, mode, name);3260else3261printf("%s %s\n", newdelete, name);3262}32633264static voidshow_mode_change(struct patch *p,int show_name)3265{3266if(p->old_mode && p->new_mode && p->old_mode != p->new_mode) {3267if(show_name)3268printf(" mode change%06o =>%06o%s\n",3269 p->old_mode, p->new_mode, p->new_name);3270else3271printf(" mode change%06o =>%06o\n",3272 p->old_mode, p->new_mode);3273}3274}32753276static voidshow_rename_copy(struct patch *p)3277{3278const char*renamecopy = p->is_rename ?"rename":"copy";3279const char*old, *new;32803281/* Find common prefix */3282 old = p->old_name;3283new= p->new_name;3284while(1) {3285const char*slash_old, *slash_new;3286 slash_old =strchr(old,'/');3287 slash_new =strchr(new,'/');3288if(!slash_old ||3289!slash_new ||3290 slash_old - old != slash_new -new||3291memcmp(old,new, slash_new -new))3292break;3293 old = slash_old +1;3294new= slash_new +1;3295}3296/* p->old_name thru old is the common prefix, and old and new3297 * through the end of names are renames3298 */3299if(old != p->old_name)3300printf("%s%.*s{%s=>%s} (%d%%)\n", renamecopy,3301(int)(old - p->old_name), p->old_name,3302 old,new, p->score);3303else3304printf("%s %s=>%s(%d%%)\n", renamecopy,3305 p->old_name, p->new_name, p->score);3306show_mode_change(p,0);3307}33083309static voidsummary_patch_list(struct patch *patch)3310{3311struct patch *p;33123313for(p = patch; p; p = p->next) {3314if(p->is_new)3315show_file_mode_name("create", p->new_mode, p->new_name);3316else if(p->is_delete)3317show_file_mode_name("delete", p->old_mode, p->old_name);3318else{3319if(p->is_rename || p->is_copy)3320show_rename_copy(p);3321else{3322if(p->score) {3323printf(" rewrite%s(%d%%)\n",3324 p->new_name, p->score);3325show_mode_change(p,0);3326}3327else3328show_mode_change(p,1);3329}3330}3331}3332}33333334static voidpatch_stats(struct patch *patch)3335{3336int lines = patch->lines_added + patch->lines_deleted;33373338if(lines > max_change)3339 max_change = lines;3340if(patch->old_name) {3341int len =quote_c_style(patch->old_name, NULL, NULL,0);3342if(!len)3343 len =strlen(patch->old_name);3344if(len > max_len)3345 max_len = len;3346}3347if(patch->new_name) {3348int len =quote_c_style(patch->new_name, NULL, NULL,0);3349if(!len)3350 len =strlen(patch->new_name);3351if(len > max_len)3352 max_len = len;3353}3354}33553356static voidremove_file(struct patch *patch,int rmdir_empty)3357{3358if(update_index) {3359if(remove_file_from_cache(patch->old_name) <0)3360die("unable to remove%sfrom index", patch->old_name);3361}3362if(!cached) {3363if(!remove_or_warn(patch->old_mode, patch->old_name) && rmdir_empty) {3364remove_path(patch->old_name);3365}3366}3367}33683369static voidadd_index_file(const char*path,unsigned mode,void*buf,unsigned long size)3370{3371struct stat st;3372struct cache_entry *ce;3373int namelen =strlen(path);3374unsigned ce_size =cache_entry_size(namelen);33753376if(!update_index)3377return;33783379 ce =xcalloc(1, ce_size);3380memcpy(ce->name, path, namelen);3381 ce->ce_mode =create_ce_mode(mode);3382 ce->ce_flags = namelen;3383if(S_ISGITLINK(mode)) {3384const char*s = buf;33853386if(get_sha1_hex(s +strlen("Subproject commit "), ce->sha1))3387die("corrupt patch for subproject%s", path);3388}else{3389if(!cached) {3390if(lstat(path, &st) <0)3391die_errno("unable to stat newly created file '%s'",3392 path);3393fill_stat_cache_info(ce, &st);3394}3395if(write_sha1_file(buf, size, blob_type, ce->sha1) <0)3396die("unable to create backing store for newly created file%s", path);3397}3398if(add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) <0)3399die("unable to add cache entry for%s", path);3400}34013402static inttry_create_file(const char*path,unsigned int mode,const char*buf,unsigned long size)3403{3404int fd;3405struct strbuf nbuf = STRBUF_INIT;34063407if(S_ISGITLINK(mode)) {3408struct stat st;3409if(!lstat(path, &st) &&S_ISDIR(st.st_mode))3410return0;3411returnmkdir(path,0777);3412}34133414if(has_symlinks &&S_ISLNK(mode))3415/* Although buf:size is counted string, it also is NUL3416 * terminated.3417 */3418returnsymlink(buf, path);34193420 fd =open(path, O_CREAT | O_EXCL | O_WRONLY, (mode &0100) ?0777:0666);3421if(fd <0)3422return-1;34233424if(convert_to_working_tree(path, buf, size, &nbuf)) {3425 size = nbuf.len;3426 buf = nbuf.buf;3427}3428write_or_die(fd, buf, size);3429strbuf_release(&nbuf);34303431if(close(fd) <0)3432die_errno("closing file '%s'", path);3433return0;3434}34353436/*3437 * We optimistically assume that the directories exist,3438 * which is true 99% of the time anyway. If they don't,3439 * we create them and try again.3440 */3441static voidcreate_one_file(char*path,unsigned mode,const char*buf,unsigned long size)3442{3443if(cached)3444return;3445if(!try_create_file(path, mode, buf, size))3446return;34473448if(errno == ENOENT) {3449if(safe_create_leading_directories(path))3450return;3451if(!try_create_file(path, mode, buf, size))3452return;3453}34543455if(errno == EEXIST || errno == EACCES) {3456/* We may be trying to create a file where a directory3457 * used to be.3458 */3459struct stat st;3460if(!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))3461 errno = EEXIST;3462}34633464if(errno == EEXIST) {3465unsigned int nr =getpid();34663467for(;;) {3468char newpath[PATH_MAX];3469mksnpath(newpath,sizeof(newpath),"%s~%u", path, nr);3470if(!try_create_file(newpath, mode, buf, size)) {3471if(!rename(newpath, path))3472return;3473unlink_or_warn(newpath);3474break;3475}3476if(errno != EEXIST)3477break;3478++nr;3479}3480}3481die_errno("unable to write file '%s' mode%o", path, mode);3482}34833484static voidcreate_file(struct patch *patch)3485{3486char*path = patch->new_name;3487unsigned mode = patch->new_mode;3488unsigned long size = patch->resultsize;3489char*buf = patch->result;34903491if(!mode)3492 mode = S_IFREG |0644;3493create_one_file(path, mode, buf, size);3494add_index_file(path, mode, buf, size);3495}34963497/* phase zero is to remove, phase one is to create */3498static voidwrite_out_one_result(struct patch *patch,int phase)3499{3500if(patch->is_delete >0) {3501if(phase ==0)3502remove_file(patch,1);3503return;3504}3505if(patch->is_new >0|| patch->is_copy) {3506if(phase ==1)3507create_file(patch);3508return;3509}3510/*3511 * Rename or modification boils down to the same3512 * thing: remove the old, write the new3513 */3514if(phase ==0)3515remove_file(patch, patch->is_rename);3516if(phase ==1)3517create_file(patch);3518}35193520static intwrite_out_one_reject(struct patch *patch)3521{3522FILE*rej;3523char namebuf[PATH_MAX];3524struct fragment *frag;3525int cnt =0;35263527for(cnt =0, frag = patch->fragments; frag; frag = frag->next) {3528if(!frag->rejected)3529continue;3530 cnt++;3531}35323533if(!cnt) {3534if(apply_verbosely)3535say_patch_name(stderr,3536"Applied patch ", patch," cleanly.\n");3537return0;3538}35393540/* This should not happen, because a removal patch that leaves3541 * contents are marked "rejected" at the patch level.3542 */3543if(!patch->new_name)3544die("internal error");35453546/* Say this even without --verbose */3547say_patch_name(stderr,"Applying patch ", patch," with");3548fprintf(stderr,"%drejects...\n", cnt);35493550 cnt =strlen(patch->new_name);3551if(ARRAY_SIZE(namebuf) <= cnt +5) {3552 cnt =ARRAY_SIZE(namebuf) -5;3553warning("truncating .rej filename to %.*s.rej",3554 cnt -1, patch->new_name);3555}3556memcpy(namebuf, patch->new_name, cnt);3557memcpy(namebuf + cnt,".rej",5);35583559 rej =fopen(namebuf,"w");3560if(!rej)3561returnerror("cannot open%s:%s", namebuf,strerror(errno));35623563/* Normal git tools never deal with .rej, so do not pretend3564 * this is a git patch by saying --git nor give extended3565 * headers. While at it, maybe please "kompare" that wants3566 * the trailing TAB and some garbage at the end of line ;-).3567 */3568fprintf(rej,"diff a/%sb/%s\t(rejected hunks)\n",3569 patch->new_name, patch->new_name);3570for(cnt =1, frag = patch->fragments;3571 frag;3572 cnt++, frag = frag->next) {3573if(!frag->rejected) {3574fprintf(stderr,"Hunk #%dapplied cleanly.\n", cnt);3575continue;3576}3577fprintf(stderr,"Rejected hunk #%d.\n", cnt);3578fprintf(rej,"%.*s", frag->size, frag->patch);3579if(frag->patch[frag->size-1] !='\n')3580fputc('\n', rej);3581}3582fclose(rej);3583return-1;3584}35853586static intwrite_out_results(struct patch *list,int skipped_patch)3587{3588int phase;3589int errs =0;3590struct patch *l;35913592if(!list && !skipped_patch)3593returnerror("No changes");35943595for(phase =0; phase <2; phase++) {3596 l = list;3597while(l) {3598if(l->rejected)3599 errs =1;3600else{3601write_out_one_result(l, phase);3602if(phase ==1&&write_out_one_reject(l))3603 errs =1;3604}3605 l = l->next;3606}3607}3608return errs;3609}36103611static struct lock_file lock_file;36123613static struct string_list limit_by_name;3614static int has_include;3615static voidadd_name_limit(const char*name,int exclude)3616{3617struct string_list_item *it;36183619 it =string_list_append(&limit_by_name, name);3620 it->util = exclude ? NULL : (void*)1;3621}36223623static intuse_patch(struct patch *p)3624{3625const char*pathname = p->new_name ? p->new_name : p->old_name;3626int i;36273628/* Paths outside are not touched regardless of "--include" */3629if(0< prefix_length) {3630int pathlen =strlen(pathname);3631if(pathlen <= prefix_length ||3632memcmp(prefix, pathname, prefix_length))3633return0;3634}36353636/* See if it matches any of exclude/include rule */3637for(i =0; i < limit_by_name.nr; i++) {3638struct string_list_item *it = &limit_by_name.items[i];3639if(!fnmatch(it->string, pathname,0))3640return(it->util != NULL);3641}36423643/*3644 * If we had any include, a path that does not match any rule is3645 * not used. Otherwise, we saw bunch of exclude rules (or none)3646 * and such a path is used.3647 */3648return!has_include;3649}365036513652static voidprefix_one(char**name)3653{3654char*old_name = *name;3655if(!old_name)3656return;3657*name =xstrdup(prefix_filename(prefix, prefix_length, *name));3658free(old_name);3659}36603661static voidprefix_patches(struct patch *p)3662{3663if(!prefix || p->is_toplevel_relative)3664return;3665for( ; p; p = p->next) {3666if(p->new_name == p->old_name) {3667char*prefixed = p->new_name;3668prefix_one(&prefixed);3669 p->new_name = p->old_name = prefixed;3670}3671else{3672prefix_one(&p->new_name);3673prefix_one(&p->old_name);3674}3675}3676}36773678#define INACCURATE_EOF (1<<0)3679#define RECOUNT (1<<1)36803681static intapply_patch(int fd,const char*filename,int options)3682{3683size_t offset;3684struct strbuf buf = STRBUF_INIT;3685struct patch *list = NULL, **listp = &list;3686int skipped_patch =0;36873688/* FIXME - memory leak when using multiple patch files as inputs */3689memset(&fn_table,0,sizeof(struct string_list));3690 patch_input_file = filename;3691read_patch_file(&buf, fd);3692 offset =0;3693while(offset < buf.len) {3694struct patch *patch;3695int nr;36963697 patch =xcalloc(1,sizeof(*patch));3698 patch->inaccurate_eof = !!(options & INACCURATE_EOF);3699 patch->recount = !!(options & RECOUNT);3700 nr =parse_chunk(buf.buf + offset, buf.len - offset, patch);3701if(nr <0)3702break;3703if(apply_in_reverse)3704reverse_patches(patch);3705if(prefix)3706prefix_patches(patch);3707if(use_patch(patch)) {3708patch_stats(patch);3709*listp = patch;3710 listp = &patch->next;3711}3712else{3713/* perhaps free it a bit better? */3714free(patch);3715 skipped_patch++;3716}3717 offset += nr;3718}37193720if(whitespace_error && (ws_error_action == die_on_ws_error))3721 apply =0;37223723 update_index = check_index && apply;3724if(update_index && newfd <0)3725 newfd =hold_locked_index(&lock_file,1);37263727if(check_index) {3728if(read_cache() <0)3729die("unable to read index file");3730}37313732if((check || apply) &&3733check_patch_list(list) <0&&3734!apply_with_reject)3735exit(1);37363737if(apply &&write_out_results(list, skipped_patch))3738exit(1);37393740if(fake_ancestor)3741build_fake_ancestor(list, fake_ancestor);37423743if(diffstat)3744stat_patch_list(list);37453746if(numstat)3747numstat_patch_list(list);37483749if(summary)3750summary_patch_list(list);37513752strbuf_release(&buf);3753return0;3754}37553756static intgit_apply_config(const char*var,const char*value,void*cb)3757{3758if(!strcmp(var,"apply.whitespace"))3759returngit_config_string(&apply_default_whitespace, var, value);3760else if(!strcmp(var,"apply.ignorewhitespace"))3761returngit_config_string(&apply_default_ignorewhitespace, var, value);3762returngit_default_config(var, value, cb);3763}37643765static intoption_parse_exclude(const struct option *opt,3766const char*arg,int unset)3767{3768add_name_limit(arg,1);3769return0;3770}37713772static intoption_parse_include(const struct option *opt,3773const char*arg,int unset)3774{3775add_name_limit(arg,0);3776 has_include =1;3777return0;3778}37793780static intoption_parse_p(const struct option *opt,3781const char*arg,int unset)3782{3783 p_value =atoi(arg);3784 p_value_known =1;3785return0;3786}37873788static intoption_parse_z(const struct option *opt,3789const char*arg,int unset)3790{3791if(unset)3792 line_termination ='\n';3793else3794 line_termination =0;3795return0;3796}37973798static intoption_parse_space_change(const struct option *opt,3799const char*arg,int unset)3800{3801if(unset)3802 ws_ignore_action = ignore_ws_none;3803else3804 ws_ignore_action = ignore_ws_change;3805return0;3806}38073808static intoption_parse_whitespace(const struct option *opt,3809const char*arg,int unset)3810{3811const char**whitespace_option = opt->value;38123813*whitespace_option = arg;3814parse_whitespace_option(arg);3815return0;3816}38173818static intoption_parse_directory(const struct option *opt,3819const char*arg,int unset)3820{3821 root_len =strlen(arg);3822if(root_len && arg[root_len -1] !='/') {3823char*new_root;3824 root = new_root =xmalloc(root_len +2);3825strcpy(new_root, arg);3826strcpy(new_root + root_len++,"/");3827}else3828 root = arg;3829return0;3830}38313832intcmd_apply(int argc,const char**argv,const char*prefix_)3833{3834int i;3835int errs =0;3836int is_not_gitdir = !startup_info->have_repository;3837int binary;3838int force_apply =0;38393840const char*whitespace_option = NULL;38413842struct option builtin_apply_options[] = {3843{ OPTION_CALLBACK,0,"exclude", NULL,"path",3844"don't apply changes matching the given path",38450, option_parse_exclude },3846{ OPTION_CALLBACK,0,"include", NULL,"path",3847"apply changes matching the given path",38480, option_parse_include },3849{ OPTION_CALLBACK,'p', NULL, NULL,"num",3850"remove <num> leading slashes from traditional diff paths",38510, option_parse_p },3852OPT_BOOLEAN(0,"no-add", &no_add,3853"ignore additions made by the patch"),3854OPT_BOOLEAN(0,"stat", &diffstat,3855"instead of applying the patch, output diffstat for the input"),3856{ OPTION_BOOLEAN,0,"allow-binary-replacement", &binary,3857 NULL,"old option, now no-op",3858 PARSE_OPT_HIDDEN | PARSE_OPT_NOARG },3859{ OPTION_BOOLEAN,0,"binary", &binary,3860 NULL,"old option, now no-op",3861 PARSE_OPT_HIDDEN | PARSE_OPT_NOARG },3862OPT_BOOLEAN(0,"numstat", &numstat,3863"shows number of added and deleted lines in decimal notation"),3864OPT_BOOLEAN(0,"summary", &summary,3865"instead of applying the patch, output a summary for the input"),3866OPT_BOOLEAN(0,"check", &check,3867"instead of applying the patch, see if the patch is applicable"),3868OPT_BOOLEAN(0,"index", &check_index,3869"make sure the patch is applicable to the current index"),3870OPT_BOOLEAN(0,"cached", &cached,3871"apply a patch without touching the working tree"),3872OPT_BOOLEAN(0,"apply", &force_apply,3873"also apply the patch (use with --stat/--summary/--check)"),3874OPT_FILENAME(0,"build-fake-ancestor", &fake_ancestor,3875"build a temporary index based on embedded index information"),3876{ OPTION_CALLBACK,'z', NULL, NULL, NULL,3877"paths are separated with NUL character",3878 PARSE_OPT_NOARG, option_parse_z },3879OPT_INTEGER('C', NULL, &p_context,3880"ensure at least <n> lines of context match"),3881{ OPTION_CALLBACK,0,"whitespace", &whitespace_option,"action",3882"detect new or modified lines that have whitespace errors",38830, option_parse_whitespace },3884{ OPTION_CALLBACK,0,"ignore-space-change", NULL, NULL,3885"ignore changes in whitespace when finding context",3886 PARSE_OPT_NOARG, option_parse_space_change },3887{ OPTION_CALLBACK,0,"ignore-whitespace", NULL, NULL,3888"ignore changes in whitespace when finding context",3889 PARSE_OPT_NOARG, option_parse_space_change },3890OPT_BOOLEAN('R',"reverse", &apply_in_reverse,3891"apply the patch in reverse"),3892OPT_BOOLEAN(0,"unidiff-zero", &unidiff_zero,3893"don't expect at least one line of context"),3894OPT_BOOLEAN(0,"reject", &apply_with_reject,3895"leave the rejected hunks in corresponding *.rej files"),3896OPT_BOOLEAN(0,"allow-overlap", &allow_overlap,3897"allow overlapping hunks"),3898OPT__VERBOSE(&apply_verbosely,"be verbose"),3899OPT_BIT(0,"inaccurate-eof", &options,3900"tolerate incorrectly detected missing new-line at the end of file",3901 INACCURATE_EOF),3902OPT_BIT(0,"recount", &options,3903"do not trust the line counts in the hunk headers",3904 RECOUNT),3905{ OPTION_CALLBACK,0,"directory", NULL,"root",3906"prepend <root> to all filenames",39070, option_parse_directory },3908OPT_END()3909};39103911 prefix = prefix_;3912 prefix_length = prefix ?strlen(prefix) :0;3913git_config(git_apply_config, NULL);3914if(apply_default_whitespace)3915parse_whitespace_option(apply_default_whitespace);3916if(apply_default_ignorewhitespace)3917parse_ignorewhitespace_option(apply_default_ignorewhitespace);39183919 argc =parse_options(argc, argv, prefix, builtin_apply_options,3920 apply_usage,0);39213922if(apply_with_reject)3923 apply = apply_verbosely =1;3924if(!force_apply && (diffstat || numstat || summary || check || fake_ancestor))3925 apply =0;3926if(check_index && is_not_gitdir)3927die("--index outside a repository");3928if(cached) {3929if(is_not_gitdir)3930die("--cached outside a repository");3931 check_index =1;3932}3933for(i =0; i < argc; i++) {3934const char*arg = argv[i];3935int fd;39363937if(!strcmp(arg,"-")) {3938 errs |=apply_patch(0,"<stdin>", options);3939 read_stdin =0;3940continue;3941}else if(0< prefix_length)3942 arg =prefix_filename(prefix, prefix_length, arg);39433944 fd =open(arg, O_RDONLY);3945if(fd <0)3946die_errno("can't open patch '%s'", arg);3947 read_stdin =0;3948set_default_whitespace_mode(whitespace_option);3949 errs |=apply_patch(fd, arg, options);3950close(fd);3951}3952set_default_whitespace_mode(whitespace_option);3953if(read_stdin)3954 errs |=apply_patch(0,"<stdin>", options);3955if(whitespace_error) {3956if(squelch_whitespace_errors &&3957 squelch_whitespace_errors < whitespace_error) {3958int squelched =3959 whitespace_error - squelch_whitespace_errors;3960warning("squelched%d"3961"whitespace error%s",3962 squelched,3963 squelched ==1?"":"s");3964}3965if(ws_error_action == die_on_ws_error)3966die("%dline%sadd%swhitespace errors.",3967 whitespace_error,3968 whitespace_error ==1?"":"s",3969 whitespace_error ==1?"s":"");3970if(applied_after_fixing_ws && apply)3971warning("%dline%sapplied after"3972" fixing whitespace errors.",3973 applied_after_fixing_ws,3974 applied_after_fixing_ws ==1?"":"s");3975else if(whitespace_error)3976warning("%dline%sadd%swhitespace errors.",3977 whitespace_error,3978 whitespace_error ==1?"":"s",3979 whitespace_error ==1?"s":"");3980}39813982if(update_index) {3983if(write_cache(newfd, active_cache, active_nr) ||3984commit_locked_index(&lock_file))3985die("Unable to write new index file");3986}39873988return!!errs;3989}